diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 665d089..663be34 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -22,7 +22,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     - name: Setup VS environment
       uses: ilammy/msvc-dev-cmd@v1
@@ -43,17 +43,18 @@ jobs:
       run: |
         cmake --build cmake-build-release --target ${{ matrix.target }}
 
-    - name: Fetch hash list
+    - name: Fetch hash lists
       run: |
+        mkdir _rpkg
         Invoke-WebRequest -Uri "https://github.com/glacier-modding/Hitman-Hashes/releases/latest/download/latest-hashes.7z" -OutFile "latest-hashes.7z"
+        Invoke-WebRequest -Uri "https://github.com/glacier-modding/Hitman-l10n-Hashes/releases/latest/download/hash_list.hmla" -OutFile "_rpkg/hash_list.hmla"
 
     - name: Prepare build
       run: |
         7z e latest-hashes.7z -o_rpkg
         cp cmake-build-release/*.dll _rpkg
         cp cmake-build-release/*.exe _rpkg
-        cp cmake-build-release/*.lib _rpkg
-        cp thirdparty/zhmtools/*.dll _rpkg
+        cp cmake-build-release/rpkg*.lib _rpkg
         cp thirdparty/quickentity-ffi/*.dll _rpkg
         cp thirdparty/assimp/*.dll _rpkg
 
@@ -69,7 +70,7 @@ jobs:
     runs-on: ptlm-runner
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Setup MSBuild
         uses: microsoft/setup-msbuild@v1.1.3
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 44c4e7f..2f68edf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,45 +1,65 @@
 cmake_minimum_required(VERSION 3.22)
 project(rpkg VERSION 2.30.0)
+include(FetchContent)
+
+# We need to set the defaults as setting the policy will not
+# persist when adding subdirectories.
+set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
+set(CMAKE_POLICY_DEFAULT_CMP0097 NEW)
+set(CMAKE_POLICY_DEFAULT_CMP0135 NEW)
+cmake_policy(SET CMP0077 NEW)
+cmake_policy(SET CMP0097 NEW)
+cmake_policy(SET CMP0135 NEW)
 
 set(CMAKE_CXX_STANDARD 17)
 
-add_subdirectory(thirdparty/GLTFSDK)
-add_subdirectory(thirdparty/directxtex)
+# rapidjson is here to allow GLTFSDK to use it.
+set(RAPIDJSON_BUILD_DOC OFF)
+set(RAPIDJSON_BUILD_EXAMPLES OFF)
+set(RAPIDJSON_BUILD_TESTS OFF)
+FetchContent_Declare(rjson
+    GIT_REPOSITORY https://github.com/Tencent/rapidjson.git
+    GIT_TAG        516d0473949fdcf0a6dc9fbb40fa92b3b85db184
+    GIT_SUBMODULES ""
+)
 
-option(WITH_DIRECTX_SUPPORT
-        "If DirectX components and support for .PRIM, .TEXT, and .BORG should be compiled. Currently only works on Windows."
-        ON
+# GLTFSDK
+FetchContent_Declare(gltfsdk
+    GIT_REPOSITORY https://github.com/microsoft/glTF-SDK.git
+    GIT_TAG        r1.9.6.0
 )
 
-if (WITH_DIRECTX_SUPPORT)
-    set(lib-directxmath
-            thirdparty/directxmath/DirectXCollision.h
-            thirdparty/directxmath/DirectXCollision.inl
-            thirdparty/directxmath/DirectXColors.h
-            thirdparty/directxmath/DirectXMath.h
-            thirdparty/directxmath/DirectXMathConvert.inl
-            thirdparty/directxmath/DirectXMathMatrix.inl
-            thirdparty/directxmath/DirectXMathMisc.inl
-            thirdparty/directxmath/DirectXMathVector.inl
-            thirdparty/directxmath/DirectXPackedVector.h
-            thirdparty/directxmath/DirectXPackedVector.inl
-    )
-endif()
-set(lib-json
-        thirdparty/json/json.hpp
+# DirectXTex
+set(BUILD_TOOLS OFF)
+set(BUILD_SAMPLE OFF)
+FetchContent_Declare(directxtex
+    GIT_REPOSITORY  https://github.com/microsoft/DirectXTex.git
+    GIT_TAG         jan2023
 )
-set(lib-lz4
-        thirdparty/lz4/LICENSE
-        thirdparty/lz4/lz4.c
-        thirdparty/lz4/lz4.h
-        thirdparty/lz4/lz4frame.c
-        thirdparty/lz4/lz4frame.h
-        thirdparty/lz4/lz4frame_static.h
-        thirdparty/lz4/lz4hc.c
-        thirdparty/lz4/lz4hc.h
-        thirdparty/lz4/xxhash.c
-        thirdparty/lz4/xxhash.h
+
+set(ENABLE_UNIT_TESTS OFF)
+set(ENABLE_SAMPLES OFF)
+FetchContent_Declare(directxmath
+    GIT_REPOSITORY  https://github.com/microsoft/DirectXMath.git
+    GIT_TAG         dec2022
 )
+
+# nlohmann json
+FetchContent_Declare(json
+    URL         https://github.com/nlohmann/json/releases/download/v3.11.2/json.tar.xz
+    URL_HASH    SHA256=8c4b26bf4b422252e13f332bc5e388ec0ab5c3443d24399acb675e68278d341f
+)
+
+# lz4
+set(LZ4_BUILD_CLI OFF)
+set(LZ4_BUILD_LEGACY_LZ4C OFF)
+set(LZ4_BUNDLED_MODE ON)
+FetchContent_Declare(lz4
+    GIT_REPOSITORY  https://github.com/lz4/lz4.git
+    GIT_TAG         v1.9.4
+    SOURCE_SUBDIR   build/cmake
+)
+
 set(lib-md5
         thirdparty/md5/md5.c
         thirdparty/md5/md5.h
@@ -55,45 +75,6 @@ set(lib-ogg
         thirdparty/ogg/src/crctable.h
         thirdparty/ogg/src/framing.c
 )
-set(lib-rapidjson
-        thirdparty/rapidjson/error/en.h
-        thirdparty/rapidjson/error/error.h
-        thirdparty/rapidjson/internal/biginteger.h
-        thirdparty/rapidjson/internal/clzll.h
-        thirdparty/rapidjson/internal/diyfp.h
-        thirdparty/rapidjson/internal/dtoa.h
-        thirdparty/rapidjson/internal/ieee754.h
-        thirdparty/rapidjson/internal/itoa.h
-        thirdparty/rapidjson/internal/meta.h
-        thirdparty/rapidjson/internal/pow10.h
-        thirdparty/rapidjson/internal/regex.h
-        thirdparty/rapidjson/internal/stack.h
-        thirdparty/rapidjson/internal/strfunc.h
-        thirdparty/rapidjson/internal/strtod.h
-        thirdparty/rapidjson/internal/swap.h
-        thirdparty/rapidjson/msinttypes/inttypes.h
-        thirdparty/rapidjson/msinttypes/stdint.h
-        thirdparty/rapidjson/allocators.h
-        thirdparty/rapidjson/cursorstreamwrapper.h
-        thirdparty/rapidjson/document.h
-        thirdparty/rapidjson/encodedstream.h
-        thirdparty/rapidjson/encodings.h
-        thirdparty/rapidjson/filereadstream.h
-        thirdparty/rapidjson/filewritestream.h
-        thirdparty/rapidjson/fwd.h
-        thirdparty/rapidjson/istreamwrapper.h
-        thirdparty/rapidjson/memorybuffer.h
-        thirdparty/rapidjson/memorystream.h
-        thirdparty/rapidjson/ostreamwrapper.h
-        thirdparty/rapidjson/pointer.h
-        thirdparty/rapidjson/prettywriter.h
-        thirdparty/rapidjson/rapidjson.h
-        thirdparty/rapidjson/reader.h
-        thirdparty/rapidjson/schema.h
-        thirdparty/rapidjson/stream.h
-        thirdparty/rapidjson/stringbuffer.h
-        thirdparty/rapidjson/writer.h
-)
 set(lib-revorb
         thirdparty/revorb/revorb.cpp
         thirdparty/revorb/revorb.h
@@ -134,39 +115,42 @@ set(lib-ww2ogg
         thirdparty/ww2ogg/wwriff.cpp
         thirdparty/ww2ogg/wwriff.h
 )
-set(lib-yyjson
-        thirdparty/yyjson/yyjson.c
-        thirdparty/yyjson/yyjson.h
+
+# yyjson
+FetchContent_Declare(yyjson
+    GIT_REPOSITORY  https://github.com/ibireme/yyjson.git
+    GIT_TAG         0.7.0
 )
-set(lib-zhmtools
-        thirdparty/zhmtools/Embind.h
-        thirdparty/zhmtools/ResourceConverter.h
-        thirdparty/zhmtools/ResourceGenerator.h
-        thirdparty/zhmtools/ResourceLib.h
-        thirdparty/zhmtools/ResourceLib_HM2.h
-        thirdparty/zhmtools/ResourceLib_HM3.h
-        thirdparty/zhmtools/ResourceLib_HM2016.h
-        thirdparty/zhmtools/ResourceLibCommon.h
+
+# zhmtools/resourcelib
+set(ZHM_BUILD_TOOLS OFF)
+FetchContent_Declare(zhmtools
+    GIT_REPOSITORY  https://github.com/OrfeasZ/ZHMTools.git
+    GIT_TAG         v3.4.1
 )
+
 set(lib-quickentity-ffi
         thirdparty/quickentity-ffi/quickentity_ffi.dll.h
 )
 set(thirdparty
-#        ${lib-directxmath}
-        ${lib-json}
-        ${lib-lz4}
         ${lib-md5}
         ${lib-mikktspace}
         ${lib-ogg}
-        ${lib-rapidjson}
         ${lib-revorb}
         ${lib-vorbis}
         ${lib-ww2ogg}
-        ${lib-yyjson}
-        ${lib-zhmtools}
         ${lib-quickentity-ffi}
 )
 
+# TonyTools
+set(TONYTOOLS_BUILD_TOOLS OFF)
+FetchContent_Declare(tonytools
+    GIT_REPOSITORY  https://github.com/AnthonyFuller/TonyTools.git
+    GIT_TAG         v1.8.1
+)
+
+FetchContent_MakeAvailable(rjson tonytools gltfsdk directxtex lz4 yyjson json zhmtools directxmath)
+
 configure_file(src/version.h.in src/version.h)
 
 set(RPKG_COMMON_SOURCES
@@ -328,11 +312,37 @@ if (MSVC)
     target_compile_options(rpkg-cli PUBLIC "/bigobj" "/W3" "/wd4068")
 endif()
 
-target_link_directories(rpkg-cli PUBLIC ${PROJECT_SOURCE_DIR}/thirdparty/zhmtools ${PROJECT_SOURCE_DIR}/thirdparty/quickentity-ffi)
-target_link_libraries(rpkg-cli PUBLIC GLTFSDK DirectXTex ResourceLib_HM2 ResourceLib_HM2016 ResourceLib_HM3 quickentity_ffi.dll.lib)
+target_link_directories(rpkg-cli PUBLIC ${PROJECT_SOURCE_DIR}/thirdparty/quickentity-ffi)
+target_include_directories(rpkg-lib PUBLIC rapidjson)
+target_link_libraries(rpkg-cli PUBLIC
+    GLTFSDK
+    DirectXTex
+    DirectXMath
+    lz4_static
+    yyjson
+    nlohmann_json::nlohmann_json
+    ResourceLib_HM2
+    ResourceLib_HM2016
+    ResourceLib_HM3
+    quickentity_ffi.dll.lib
+    TonyTools::HMLanguages
+)
 
-target_link_directories(rpkg-lib PUBLIC ${PROJECT_SOURCE_DIR}/thirdparty/zhmtools ${PROJECT_SOURCE_DIR}/thirdparty/quickentity-ffi)
-target_link_libraries(rpkg-lib PUBLIC GLTFSDK DirectXTex ResourceLib_HM2 ResourceLib_HM2016 ResourceLib_HM3 quickentity_ffi.dll.lib)
+target_link_directories(rpkg-lib PUBLIC ${PROJECT_SOURCE_DIR}/thirdparty/quickentity-ffi)
+target_include_directories(rpkg-lib PUBLIC rapidjson)
+target_link_libraries(rpkg-lib PUBLIC
+    GLTFSDK
+    DirectXTex
+    DirectXMath
+    lz4_static
+    yyjson
+    nlohmann_json::nlohmann_json
+    ResourceLib_HM2
+    ResourceLib_HM2016
+    ResourceLib_HM3
+    quickentity_ffi.dll.lib
+    TonyTools::HMLanguages
+)
 
 include_directories(${CMAKE_SOURCE_DIR})
 # Pre-processed version header file (on configure step, before build)
diff --git a/rpkg-gui/DownloadExtractionProgress.xaml.cs b/rpkg-gui/DownloadExtractionProgress.xaml.cs
index bf73a28..6c5c4b5 100644
--- a/rpkg-gui/DownloadExtractionProgress.xaml.cs
+++ b/rpkg-gui/DownloadExtractionProgress.xaml.cs
@@ -19,9 +19,14 @@
 using System.ComponentModel;
 using MahApps.Metro.Controls;
 using ControlzEx.Theming;
+using System.Text.Json;
 
 namespace rpkg
 {
+    public class HMLAVersion {
+        public int version { get; set; }
+    }
+
     /// <summary>
     /// Interaction logic for DownloadExtractionProgress.xaml
     /// </summary>
@@ -56,6 +61,18 @@ private void Window_Loaded(object sender, RoutedEventArgs e)
 
                 webClient.DownloadFileAsync(uri, "latest-hashes.7z");
             }
+            else if (operation == 3)
+            {
+                WebClient webClient = new WebClient();
+
+                webClient.DownloadProgressChanged += WebClient_DownloadProgressChanged;
+
+                webClient.DownloadFileCompleted += WebClient_DownloadFileCompleted;
+
+                Uri uri = new Uri("https://github.com/glacier-modding/Hitman-l10n-Hashes/releases/latest/download/hash_list.hmla");
+
+                webClient.DownloadFileAsync(uri, "hash_list.hmla");
+            }
             else
             {
                 BackgroundWorker worker = new BackgroundWorker();
@@ -103,6 +120,14 @@ void worker_DoWork(object sender, DoWorkEventArgs e)
 
                 int.TryParse(http.GetAsync("https://github.com/glacier-modding/Hitman-Hashes/releases/latest/download/version").Result.Content.ReadAsStringAsync().Result, out currentVersionAvailable);
             }
+            else if (operation == 4)
+            {
+                HttpClient http = new HttpClient() { Timeout = TimeSpan.FromSeconds(10) };
+
+                string data = http.GetAsync("https://github.com/glacier-modding/Hitman-l10n-Hashes/releases/latest/download/version.json").Result.Content.ReadAsStringAsync().Result;
+                dynamic json = JsonSerializer.Deserialize<HMLAVersion>(data);    
+                currentVersionAvailable = json.version;           
+            }
         }
 
         void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
diff --git a/rpkg-gui/MainWindow.xaml b/rpkg-gui/MainWindow.xaml
index d1e9082..b9c1eff 100644
--- a/rpkg-gui/MainWindow.xaml
+++ b/rpkg-gui/MainWindow.xaml
@@ -615,7 +615,12 @@
                                     <ColumnDefinition Width="Auto"/>
                                 </Grid.ColumnDefinitions>
                                 <Label Grid.Row="0" Grid.Column="0" Content="Search in RPKG(s):" VerticalContentAlignment="Center" FontSize="14"/>
-                                <ComboBox Grid.Row="0" Grid.Column="1" Grid.ColumnSpan="2" x:Name="DeepSearchLocalizationRPKGsComboBox" FontFamily="Consolas" Margin="15" VerticalAlignment="Center"/>
+                                <ComboBox Grid.Row="0" Grid.Column="1" Grid.ColumnSpan="1" x:Name="DeepSearchLocalizationRPKGsComboBox" FontFamily="Consolas" Margin="10" VerticalAlignment="Center"/>
+                                <ComboBox Grid.Row="0" Grid.Column="3" Grid.ColumnSpan="2" x:Name="DeepSearchLocalizationVersionComboBox" FontFamily="Consolas" Margin="15" VerticalAlignment="Center">
+                                    <ComboBoxItem Content="Hitman 2016"/>
+                                    <ComboBoxItem Content="Hitman 2"/>
+                                    <ComboBoxItem Content="Hitman 3" IsSelected="True"/>
+                                </ComboBox>
                                 <Label Grid.Row="1" Grid.Column="0" Content="Search through:" FontSize="14" VerticalAlignment="Center"/>
                                 <Grid Grid.Row="1" Grid.Column="1" Grid.ColumnSpan="2" VerticalAlignment="Center">
                                     <Grid.RowDefinitions>
diff --git a/rpkg-gui/MainWindow.xaml.cs b/rpkg-gui/MainWindow.xaml.cs
index 3d61afc..41e7cdc 100644
--- a/rpkg-gui/MainWindow.xaml.cs
+++ b/rpkg-gui/MainWindow.xaml.cs
@@ -156,6 +156,14 @@ private void DownloadExtractHashList()
 			downloadExtractionProgress2.ShowDialog();
 		}
 
+		private void DownloadHMLAHashList()
+		{
+			DownloadExtractionProgress downloadExtractionProgress = new DownloadExtractionProgress();
+			downloadExtractionProgress.operation = 3;
+			downloadExtractionProgress.message.Content = "Downloading https://github.com/glacier-modding/Hitman-l10n-Hashes/releases/latest/download/hash_list.hmla...";
+			downloadExtractionProgress.ShowDialog();
+		}
+
 		private void Window_Loaded(object sender, RoutedEventArgs e)
 		{
 			AddHandlers();
@@ -247,6 +255,63 @@ private void Window_Loaded(object sender, RoutedEventArgs e)
 				}
 			}
 
+			if (!File.Exists("hash_list.hmla")) {
+				MessageQuestion messageBox = new MessageQuestion();
+				messageBox.message.Content = "Error: The localisation hash list file (hash__list.hmla) is missing.\n\nIt improves the localisation experience greatly.\n\nClick OK to automatically download it.\n\nYou can also download it manually from https://github.com/glacier-modding/Hitman-l10n-Hashes/releases/latest/download/hash_list.hmla and place it next to the program.";
+				messageBox.ShowDialog();
+
+				if (messageBox.buttonPressed == "OKButton")
+				{
+					DownloadHMLAHashList();
+					System.Windows.Forms.Application.Restart();
+
+					if (discordOn)
+					{
+						Client.Dispose();
+					}
+
+					Environment.Exit(0);
+				}
+				else if (messageBox.buttonPressed == "CancelButton")
+				{
+					if (discordOn)
+					{
+						Client.Dispose();
+					}
+
+					Environment.Exit(0);
+				}
+			}
+
+			uint hmla_version = load_hmla_hash_list(AppDomain.CurrentDomain.BaseDirectory + "\\hash_list.hmla");
+			if (hmla_version != uint.MaxValue) {
+				DownloadExtractionProgress downloadExtractionProgress2 = new DownloadExtractionProgress();
+				downloadExtractionProgress2.operation = 4;
+				downloadExtractionProgress2.ProgressBar.IsIndeterminate = true;
+				downloadExtractionProgress2.message.Content = "Checking https://github.com/glacier-modding/Hitman-l10n-Hashes/releases/latest/download/version.json to see if a new hash list is available...";
+				downloadExtractionProgress2.ShowDialog();
+
+				if (hmla_version < downloadExtractionProgress2.currentVersionAvailable)
+				{
+					MessageQuestion messageBox = new MessageQuestion();
+					messageBox.message.Content = "There is a new version of the localisation hash list available.\n\nClick OK to automatically update to the latest version.";
+					messageBox.ShowDialog();
+
+					if (messageBox.buttonPressed == "OKButton")
+					{
+						DownloadHMLAHashList();
+						System.Windows.Forms.Application.Restart();
+
+						if (discordOn)
+						{
+							Client.Dispose();
+						}
+
+						Environment.Exit(0);
+					}
+				}
+			}
+
 			var item = new System.Windows.Forms.TreeNode();
 			item.Text = "Click";
 			MainTreeView.Nodes.Add(item);
@@ -4894,7 +4959,7 @@ public enum EntityDeepSearchCategory
 		public delegate int execute_get_hashes_with_no_reverse_depends(string rpkg_file);
 		public delegate int execute_get_direct_hash_depends(string rpkg_file, string hash_string);
 		public delegate int execute_task(string csharp_command, string csharp_input_path, string csharp_filter, string search, string search_type, string csharp_output_path);
-		public delegate int execute_deep_search_localization(string input_path, string search_value, int search_dlge, int search_locr, int search_rtlv, int max_results);
+		public delegate int execute_deep_search_localization(string input_path, string search_value, int search_dlge, int search_locr, int search_rtlv, int max_results, string version);
 		public delegate int execute_deep_search_entities(string input_path, string[] search_strings, int[] search_types, int[] search_categories, int search_strings_count, int max_results, int store_jsons, int use_latest_hashes);
 
 		[DllImport("rpkg-lib.dll", EntryPoint = "task_execute", CallingConvention = CallingConvention.Cdecl)]
@@ -4977,6 +5042,9 @@ public static extern UInt32 generate_localization_line_string(string rpkg_file_n
 		[DllImport("rpkg-lib.dll", EntryPoint = "load_hash_list", CallingConvention = CallingConvention.Cdecl)]
 		public static extern int load_hash_list(string path);
 
+		[DllImport("rpkg-lib.dll", EntryPoint = "load_hmla_hash_list", CallingConvention = CallingConvention.Cdecl)]
+		public static extern uint load_hmla_hash_list(string path);
+
 		[DllImport("rpkg-lib.dll", EntryPoint = "get_hash_list_string", CallingConvention = CallingConvention.Cdecl)]
 		public static extern IntPtr get_hash_list_string(string hash_string);
 
@@ -5070,7 +5138,7 @@ public static extern int modify_hash_depends(string rpkg_file, string hash_strin
 
 		[DllImport("rpkg-lib.dll", EntryPoint = "deep_search_localization", CallingConvention = CallingConvention.Cdecl)]
 		public static extern int deep_search_localization(string input_path, string search_value, int search_dlge,
-			int search_locr, int search_rtlv, int max_results);
+			int search_locr, int search_rtlv, int max_results, string version);
 
 		[DllImport("rpkg-lib.dll", EntryPoint = "get_localization_search_results_size",
 			CallingConvention = CallingConvention.Cdecl)]
@@ -8399,7 +8467,16 @@ private void DeepSearchLocalizationButton_Click(object sender, RoutedEventArgs e
 						maxSearchResults = 100;
 					}
 
-					IAsyncResult ar = rpkgExecute.BeginInvoke(input_path, DeepSearchLocalizationTextBox.Text, search_dlge, search_locr, search_rtlv, maxSearchResults, null, null);
+					string version = DeepSearchLocalizationVersionComboBox.Text switch
+					{
+						"Hitman 2016" => "HM2016",
+						"Hitman 2" => "HM2",
+						"Hitman 3" => "HM3",
+						_ => "HM3"
+					};
+
+
+                    IAsyncResult ar = rpkgExecute.BeginInvoke(input_path, DeepSearchLocalizationTextBox.Text, search_dlge, search_locr, search_rtlv, maxSearchResults, version, null, null);
 
 					deepSearchLocalizationWorker = new BackgroundWorker();
 					deepSearchLocalizationWorker.WorkerReportsProgress = true;
diff --git a/rpkg-gui/rpkg-gui.csproj b/rpkg-gui/rpkg-gui.csproj
index 92c4b9c..3c2f20e 100644
--- a/rpkg-gui/rpkg-gui.csproj
+++ b/rpkg-gui/rpkg-gui.csproj
@@ -48,7 +48,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DebugType>full</DebugType>
     <PlatformTarget>x64</PlatformTarget>
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>8.0</LangVersion>
     <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
@@ -57,7 +57,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Optimize>true</Optimize>
     <PlatformTarget>x64</PlatformTarget>
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>8.0</LangVersion>
     <ErrorReport>prompt</ErrorReport>
     <DebugSymbols>true</DebugSymbols>
     <DebugType>pdbonly</DebugType>
diff --git a/src/asva.cpp b/src/asva.cpp
index db11990..2cc8c61 100644
--- a/src/asva.cpp
+++ b/src/asva.cpp
@@ -6,7 +6,7 @@
 #include "crypto.h"
 #include "util.h"
 #include "file.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <map>
 #include <fstream>
diff --git a/src/asva.h b/src/asva.h
index 1b27613..cba249d 100644
--- a/src/asva.h
+++ b/src/asva.h
@@ -7,7 +7,7 @@
 #include <variant>
 #include "hash.h"
 #include "global.h"
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 
 class asva {
 public:
diff --git a/src/borg.cpp b/src/borg.cpp
index 9914e70..911cc97 100644
--- a/src/borg.cpp
+++ b/src/borg.cpp
@@ -3,7 +3,7 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <fstream>
 
 borg::borg() = default;
diff --git a/src/borg.h b/src/borg.h
index a868247..cea681b 100644
--- a/src/borg.h
+++ b/src/borg.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "global.h"
-#include "thirdparty/directxmath/DirectXMath.h"
+#include <DirectXMath.h>
 #include <string>
 #include <vector>
 #include <cstdint>
diff --git a/src/cli/command_line.cpp b/src/cli/command_line.cpp
index ff5f4de..e8fafc9 100644
--- a/src/cli/command_line.cpp
+++ b/src/cli/command_line.cpp
@@ -15,6 +15,11 @@ bool command_line::all_args_are_paths(const int argc, char* argv[]) {
     return true;
 }
 
+// Special case for "flag" arguments
+std::vector<std::string> single_arg = {
+    "-hex_precision"
+};
+
 std::vector<std::vector<std::string>> command_line::parse(const int argc, char* argv[]) {
     std::vector<std::vector<std::string>> command_line_args;
 
@@ -25,14 +30,16 @@ std::vector<std::vector<std::string>> command_line::parse(const int argc, char*
 
                 temp_command_line_args.push_back(argv[i]);
 
-                if (argc > (i + 1)) {
-                    if (argv[i + 1][0] != '-' && std::string(argv[i + 1]).length() > 0) {
-                        temp_command_line_args.push_back(argv[i + 1]);
+                if (std::find(single_arg.begin(), single_arg.end(), argv[i]) == single_arg.end()) {
+                    if (argc > (i + 1)) {
+                        if (argv[i + 1][0] != '-' && std::string(argv[i + 1]).length() > 0) {
+                            temp_command_line_args.push_back(argv[i + 1]);
+                        } else {
+                            LOG_AND_EXIT_NOP("Error: Invalid command line input.");
+                        }
                     } else {
                         LOG_AND_EXIT_NOP("Error: Invalid command line input.");
                     }
-                } else {
-                    LOG_AND_EXIT_NOP("Error: Invalid command line input.");
                 }
 
                 command_line_args.push_back(temp_command_line_args);
diff --git a/src/dev_dlge_names.cpp b/src/dev_dlge_names.cpp
index 0bac46c..07f9dc5 100644
--- a/src/dev_dlge_names.cpp
+++ b/src/dev_dlge_names.cpp
@@ -6,7 +6,7 @@
 #include "util.h"
 #include <fstream>
 #include <filesystem>
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 
 void dev_function::dev_dlge_names(std::string& input_path, const std::string& output_path) {
     input_path = file::parse_input_folder_path(input_path);
diff --git a/src/dev_extract_wwem_strings.cpp b/src/dev_extract_wwem_strings.cpp
index 239c527..c7dfcc2 100644
--- a/src/dev_extract_wwem_strings.cpp
+++ b/src/dev_extract_wwem_strings.cpp
@@ -5,7 +5,7 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <unordered_map>
 #include <fstream>
diff --git a/src/dev_extract_wwes_strings.cpp b/src/dev_extract_wwes_strings.cpp
index a520535..4ae3f40 100644
--- a/src/dev_extract_wwes_strings.cpp
+++ b/src/dev_extract_wwes_strings.cpp
@@ -5,7 +5,7 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <unordered_map>
 #include <fstream>
diff --git a/src/dev_extract_wwev_strings.cpp b/src/dev_extract_wwev_strings.cpp
index 0546293..e710151 100644
--- a/src/dev_extract_wwev_strings.cpp
+++ b/src/dev_extract_wwev_strings.cpp
@@ -5,7 +5,7 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <fstream>
 
diff --git a/src/dev_extract_wwise_ids.cpp b/src/dev_extract_wwise_ids.cpp
index 4721a77..ee8bc5b 100644
--- a/src/dev_extract_wwise_ids.cpp
+++ b/src/dev_extract_wwise_ids.cpp
@@ -4,7 +4,7 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <fstream>
 
diff --git a/src/dev_map_editor.cpp b/src/dev_map_editor.cpp
index 439af4c..8c01683 100644
--- a/src/dev_map_editor.cpp
+++ b/src/dev_map_editor.cpp
@@ -7,8 +7,8 @@
 #include <iostream>
 #include <filesystem>
 #include <sstream>
-#include "thirdparty/rapidjson/document.h"
-#include "thirdparty/rapidjson/stringbuffer.h"
+#include <rapidjson/document.h>
+#include <rapidjson/stringbuffer.h>
 
 void extract_glb_and_return_coords(uint32_t temps_index, uint32_t entry_index, std::string parent_string,
                                    std::vector<uint64_t>& entityId_temp_index,
diff --git a/src/entity.cpp b/src/entity.cpp
index c8ec30c..507f826 100644
--- a/src/entity.cpp
+++ b/src/entity.cpp
@@ -5,17 +5,15 @@
 #include "crypto.h"
 #include "file.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/rapidjson/stringbuffer.h"
-#include "thirdparty/directxmath/DirectXMath.h"
+#include <lz4.h>
+#include <rapidjson/stringbuffer.h>
+#include <DirectXMath.h>
 #include "thirdparty/quickentity-ffi/quickentity_ffi.dll.h"
 #include <unordered_map>
 #include <fstream>
 #include <iomanip>
 #include <regex>
 
-#pragma comment(lib, "../thirdparty/zhmtools/ResourceLib_HM2.lib")
-#pragma comment(lib, "../thirdparty/zhmtools/ResourceLib_HM3.lib")
 #pragma comment(lib, "../thirdparty/quickentity-ffi/quickentity_ffi.dll.lib")
 
 entity::entity() = default;
diff --git a/src/entity.h b/src/entity.h
index 1bcd9b7..0270299 100644
--- a/src/entity.h
+++ b/src/entity.h
@@ -3,9 +3,10 @@
 #include <string>
 #include <unordered_map>
 #include <cstdint>
-#include "thirdparty/zhmtools/ResourceLib_HM2.h"
-#include "thirdparty/zhmtools/ResourceLib_HM3.h"
-#include "thirdparty/yyjson/yyjson.h"
+
+#include <ResourceLib_HM2.h>
+#include <ResourceLib_HM3.h>
+#include <yyjson.h>
 
 class entity {
 public:
diff --git a/src/extract_all_text_from.cpp b/src/extract_all_text_from.cpp
index b2b47d4..d12c733 100644
--- a/src/extract_all_text_from.cpp
+++ b/src/extract_all_text_from.cpp
@@ -3,7 +3,7 @@
 #include "global.h"
 #include "console.h"
 #include "util.h"
-#include "thirdparty/directxtex/DirectXTex.h"
+#include <DirectXTex.h>
 #include <unordered_map>
 #include <chrono>
 #include <sstream>
diff --git a/src/extract_dlge_to_json_from.cpp b/src/extract_dlge_to_json_from.cpp
index 9896a70..ef754f5 100644
--- a/src/extract_dlge_to_json_from.cpp
+++ b/src/extract_dlge_to_json_from.cpp
@@ -5,19 +5,30 @@
 #include "console.h"
 #include "util.h"
 #include "hash.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/json/json.hpp"
+#include <lz4.h>
+#include <nlohmann/json.hpp>
 #include <iostream>
 #include <chrono>
 #include <sstream>
 #include <fstream>
 #include <regex>
 #include <filesystem>
+#include <TonyTools/Languages.h>
 
 using json = nlohmann::ordered_json;
 
 void rpkg_function::extract_dlge_to_json_from(std::string& input_path, std::string& filter, std::string& output_path,
-                                              bool output_to_string) {
+                                              bool output_to_string, std::string version, bool hexPrecision) { 
+    TonyTools::Language::Version ttVersion = TonyTools::Language::Version::H3;
+    if (version == "HM2") {
+        ttVersion = TonyTools::Language::Version::H2;
+    }
+    else if (version == "HM2016") {
+        ttVersion = TonyTools::Language::Version::H2016;
+    }
+
+    util::load_hmla_hash_list();
+
     task_single_status = TASK_EXECUTING;
     task_multiple_status = TASK_EXECUTING;
 
@@ -67,8 +78,9 @@ void rpkg_function::extract_dlge_to_json_from(std::string& input_path, std::stri
 
     timing_string = "Extracting DLGE as JSON...";
 
-    if (log_output)
-            LOG("Extracting DLGE as JSON...");
+    if (log_output) {
+        LOG("Extracting DLGE as JSON...");
+    }
 
     std::chrono::time_point start_time = std::chrono::high_resolution_clock::now();
     int stringstream_length = 80;
@@ -77,6 +89,11 @@ void rpkg_function::extract_dlge_to_json_from(std::string& input_path, std::stri
         if (rpkgs.at(i).rpkg_file_path != input_path && input_path_is_rpkg_file)
             continue;
 
+        // We do some setup here to avoid having to re-do the match everytime for this RPKG.
+        // This is a special case for H3 LOCR
+        const std::regex baseOrP1("chunk([0-9]|1[0-9]|2[0-7])(?:patch1+)?\\.rpkg");
+        bool oldH3Lang = (ttVersion == TonyTools::Language::Version::H3) && std::regex_match(rpkgs.at(i).rpkg_file_name, baseOrP1);
+
         bool archive_folder_created = false;
 
         for (uint64_t r = 0; r < rpkgs.at(i).hash_resource_types.size(); r++) {
@@ -157,333 +174,51 @@ void rpkg_function::extract_dlge_to_json_from(std::string& input_path, std::stri
 
                 uint32_t decompressed_size = rpkgs.at(i).hash.at(hash_index).data.resource.size_final;
 
-                std::vector<char> output_data(decompressed_size, 0);
-
-                std::vector<char>* dlge_data;
+                std::vector<char> dlge_data(decompressed_size, 0);
 
                 if (rpkgs.at(i).hash.at(hash_index).data.lz4ed) {
-                    LZ4_decompress_safe(input_data.data(), output_data.data(), static_cast<int>(hash_size),
+                    LZ4_decompress_safe(input_data.data(), dlge_data.data(), static_cast<int>(hash_size),
                                         decompressed_size);
-
-                    dlge_data = &output_data;
                 } else {
-                    dlge_data = &input_data;
-                }
-
-                uint32_t dlge_data_size = 0;
-                uint32_t number_of_dlge_categories = 0;
-                std::vector<uint32_t> dlge_categories;
-                std::vector<uint32_t> dlge_identifiers;
-                std::vector<uint64_t> dlge_section_metas;
-                std::vector<char> dlge_footer;
-                uint32_t number_of_languages = 0;
-                std::vector<std::vector<std::string>> language_string;
-                std::vector<std::vector<uint32_t>> language_string_sizes;
-                std::vector<std::vector<uint64_t>> language_string_metas;
-                std::vector<std::string> languages;
-                languages.emplace_back("en");
-                languages.emplace_back("fr");
-                languages.emplace_back("it");
-                languages.emplace_back("de");
-                languages.emplace_back("es");
-                languages.emplace_back("ru");
-                languages.emplace_back("cn");
-                languages.emplace_back("tc");
-                languages.emplace_back("jp");
-
-                std::vector<char> json_meta_data;
-
-                json json_object;
-
-                uint32_t position = 0;
-
-                uint8_t bytes1 = 0;
-                uint32_t bytes4 = 0;
-                uint64_t bytes8 = 0;
-
-                std::memcpy(&bytes4, &(*dlge_data)[position], BYTES4);
-
-                position += BYTES4;
-
-                if (bytes4 != 0) {
-                    LOG("Error: DLGE file " << hash_file_name << " in " << rpkgs.at(i).rpkg_file_name
-                                            << " is malformed.");
-                    break;
-                }
-
-                std::memcpy(&bytes4, &(*dlge_data)[position], BYTES4);
-
-                position += BYTES4;
-
-                if (bytes4 != 1) {
-                    LOG("Error: DLGE file " << hash_file_name << " in " << rpkgs.at(i).rpkg_file_name
-                                            << " is malformed.");
-                    break;
+                    dlge_data = input_data;
                 }
 
-                uint8_t text_available = 0;
-
-                std::memcpy(&bytes1, &(*dlge_data)[position], BYTES1);
-
-                position += BYTES1;
-
-                if (bytes1 == 1) {
-                    text_available = 1;
-                }
-
-                uint32_t text_count = 0;
-
-                bool dlge_has_text = false;
-
-                bool do_not_break = true;
-
-                while (text_available) {
-                    number_of_dlge_categories++;
-
-                    std::memcpy(&bytes4, &(*dlge_data)[position], BYTES4);
-
-                    for (uint64_t k = 0; k < BYTES4; k++) {
-                        json_meta_data.push_back((*dlge_data)[position + k]);
-                    }
-
-                    position += BYTES4;
-
-                    dlge_categories.push_back(bytes4);
-
-                    std::memcpy(&bytes4, &(*dlge_data)[position], BYTES4);
-
-                    for (uint64_t k = 0; k < BYTES4; k++) {
-                        json_meta_data.push_back((*dlge_data)[position + k]);
-                    }
-
-                    position += BYTES4;
-
-                    dlge_identifiers.push_back(bytes4);
-
-                    std::memcpy(&bytes4, &(*dlge_data)[position], BYTES4);
-
-                    position += BYTES4;
-
-                    if (bytes4 != 0) {
-                        LOG("Error: DLGE file " << hash_file_name << " in " << rpkgs.at(i).rpkg_file_name
-                                                << " is malformed.");
-                        do_not_break = false;
-                        break;
-                    }
-
-                    std::memcpy(&bytes8, &(*dlge_data)[position], BYTES8);
-
-                    position += BYTES8;
-
-                    if (bytes8 != 0xFFFFFFFFFFFFFFFF) {
-                        LOG("Error: DLGE file " << hash_file_name << " in " << rpkgs.at(i).rpkg_file_name
-                                                << " is malformed.");
-                        do_not_break = false;
-                        break;
-                    }
-
-                    std::memcpy(&bytes4, &(*dlge_data)[position], BYTES4);
-
-                    position += BYTES4;
-
-                    if (bytes4 != 0) {
-                        LOG("Error: DLGE file " << hash_file_name << " in " << rpkgs.at(i).rpkg_file_name
-                                                << " is malformed.");
-                        do_not_break = false;
-                        break;
-                    }
-
-                    std::memcpy(&bytes4, &(*dlge_data)[position], BYTES4);
-
-                    if (bytes4 == 0) {
-                        for (uint64_t k = 0; k < BYTES4; k++) {
-                            json_meta_data.push_back((*dlge_data)[position + k]);
-                        }
-
-                        position += BYTES4;
-                    }
-
-                    uint32_t check_variable_1 = 0;
-                    uint32_t check_variable_2 = 0;
-
-                    std::memcpy(&check_variable_1, &(*dlge_data)[position], BYTES4);
-
-                    position += BYTES4;
-
-                    std::memcpy(&check_variable_2, &(*dlge_data)[position], BYTES4);
-
-                    position += BYTES4;
-
-                    position -= BYTES8;
-
-                    if ((check_variable_1 == 0xFFFFFFFF && check_variable_2 == 0xFFFFFFFF) ||
-                        ((check_variable_1 + 1) == check_variable_2) || check_variable_2 == 0xFFFFFFFF) {
-                        std::memcpy(&bytes8, &(*dlge_data)[position], BYTES8);
-
-                        for (uint64_t k = 0; k < BYTES8; k++) {
-                            json_meta_data.push_back((*dlge_data)[position + k]);
-                        }
-
-                        position += BYTES8;
-
-                        dlge_section_metas.push_back(bytes8);
-                    } else {
-                        LOG("Error: DLGE file " << hash_file_name << " in " << rpkgs.at(i).rpkg_file_name
-                                                << " is malformed.");
-                        do_not_break = false;
-                        break;
-                    }
-
-                    bool done_scanning_languages = false;
-
-                    std::vector<uint32_t> temp_language_string_sizes;
-
-                    std::vector<uint64_t> temp_language_string_metas;
-
-                    number_of_languages = 0;
-
-                    while (!done_scanning_languages) {
-                        json temp_language_json_object;
-
-                        temp_language_json_object["Language"] = languages.at(number_of_languages);
-
-                        std::memcpy(&bytes4, &(*dlge_data)[position], BYTES4);
-                        position += BYTES4;
-
-                        temp_language_string_sizes.push_back(bytes4);
-
-                        std::vector<char> temp_string;
-
-                        for (uint64_t l = 0; l < temp_language_string_sizes.back(); l++) {
-                            temp_string.push_back((*dlge_data)[position]);
-                            position += 1;
-                        }
-
-                        if (temp_language_string_sizes.back() % 8 != 0) {
-                            LOG("Error: DLGE file " << hash_file_name << " in " << rpkgs.at(i).rpkg_file_name
-                                                    << " is malformed.");
-                            do_not_break = false;
-                            break;
-                        }
-
-                        for (uint32_t m = 0; m < temp_language_string_sizes.back() / 8; m++) {
-                            uint32_t data[2];
-                            std::memcpy(data, &temp_string[static_cast<uint64_t>(m) * static_cast<uint64_t>(8)],
-                                        sizeof(uint32_t));
-                            std::memcpy(data + 1, &temp_string[static_cast<uint64_t>(m) * static_cast<uint64_t>(8) +
-                                                               static_cast<uint64_t>(4)], sizeof(uint32_t));
-
-                            crypto::xtea_decrypt_localization(data);
-
-                            std::memcpy(&temp_string[static_cast<uint64_t>(m) * static_cast<uint64_t>(8)], data,
-                                        sizeof(uint32_t));
-                            std::memcpy(&temp_string[static_cast<uint64_t>(m) * static_cast<uint64_t>(8) +
-                                                     static_cast<uint64_t>(4)], data + 1, sizeof(uint32_t));
-
-                            dlge_has_text = true;
-                        }
-
-                        auto last_zero_position = static_cast<uint32_t>(temp_string.size());
-
-                        if (!temp_string.empty()) {
-                            auto m = static_cast<uint32_t>(temp_string.size() - 1);
-
-                            while (m >= 0) {
-                                if (temp_string.at(m) != 0) {
-                                    break;
-                                }
-
-                                last_zero_position--;
-                                m--;
-                            }
-                        }
-
-                        if (!temp_string.empty()) {
-                            std::string temp_string_with_zero_pad_removed = std::string(temp_string.begin(),
-                                                                                        temp_string.end()).substr(0,
-                                                                                                                  last_zero_position);
-
-                            temp_language_json_object["String"] = temp_string_with_zero_pad_removed;
-                        } else {
-                            temp_language_json_object["String"] = "";
-                        }
-
-                        json_object.push_back(temp_language_json_object);
-
-                        if ((position + 0x8) <= decompressed_size) {
-                            std::memcpy(&bytes4, &(*dlge_data)[position], BYTES4);
-
-                            if (bytes4 == 0) {
-                                for (uint64_t k = 0; k < BYTES4; k++) {
-                                    json_meta_data.push_back((*dlge_data)[position + k]);
-                                }
-
-                                position += BYTES4;
-                            }
-
-                            std::memcpy(&check_variable_1, &(*dlge_data)[position], BYTES4);
-                            position += BYTES4;
-
-                            std::memcpy(&check_variable_2, &(*dlge_data)[position], BYTES4);
-                            position += BYTES4;
-
-                            position -= BYTES8;
-
-                            if ((check_variable_1 == 0xFFFFFFFF && check_variable_2 == 0xFFFFFFFF) ||
-                                ((check_variable_1 + 1) == check_variable_2) || check_variable_2 == 0xFFFFFFFF) {
-                                std::memcpy(&bytes8, &(*dlge_data)[position], BYTES8);
-
-                                for (uint64_t k = 0; k < BYTES8; k++) {
-                                    json_meta_data.push_back((*dlge_data)[position + k]);
-                                }
-
-                                position += BYTES8;
-
-                                temp_language_string_metas.push_back(bytes8);
-                            } else {
-                                done_scanning_languages = true;
-                            }
-                        } else {
-                            done_scanning_languages = true;
-                        }
-
-                        number_of_languages++;
-                    }
-
-                    if ((position + 0x1) <= decompressed_size) {
-                        std::memcpy(&bytes1, &(*dlge_data)[position], BYTES1);
-
-                        if (bytes1 == 1) {
-                            text_available = 1;
-
-                            position += BYTES1;
-                        } else {
-                            text_available = 0;
-                        }
-                    } else {
-                        text_available = 0;
-                    }
-
-                    text_count++;
+                std::string dlgeJson;
+
+                if (oldH3Lang) {
+                    // Special case for H3 DLGE in base chunks/patch1 to avoid crashing.
+                    dlgeJson = TonyTools::Language::DLGE::Convert(
+                        ttVersion,
+                        dlge_data,
+                        generate_hash_meta_json(i, hash_index),
+                        "en",
+                        hexPrecision,
+                        "xx,en,fr,it,de,es"
+                    );
+                } else {
+                    dlgeJson = TonyTools::Language::DLGE::Convert(
+                        ttVersion,
+                        dlge_data,
+                        generate_hash_meta_json(i, hash_index),
+                        "en",
+                        hexPrecision
+                    );
                 }
 
-                if ((decompressed_size - position) > 0) {
-                    for (uint64_t k = 0; k < (decompressed_size - position); k++) {
-                        json_meta_data.push_back((*dlge_data)[position + k]);
-                    }
+                if (dlgeJson.empty()) {
+                    LOG_AND_EXIT("Failed to convert DLGE to JSON!");
                 }
 
-                if (!dlge_has_text || !do_not_break)
-                    continue;
+                json parsedJson = json::parse(dlgeJson);
 
                 if (output_to_string) {
                     std::stringstream ss;
 
-                    ss << std::setw(4) << json_object << std::endl;
+                    ss << std::setw(4) << parsedJson << std::endl;
 
                     localization_string = ss.str();
 
-                    localization_json = json_object;
+                    localization_json = parsedJson;
                 } else {
                     std::string json_path = current_path + "\\" + hash_file_name + ".JSON";
 
@@ -493,112 +228,9 @@ void rpkg_function::extract_dlge_to_json_from(std::string& input_path, std::stri
                         LOG_AND_EXIT("Error: JSON file " + json_path + " could not be created.");
                     }
 
-                    json_file << std::setw(4) << json_object << std::endl;
+                    json_file << std::setw(4) << parsedJson << std::endl;
 
                     json_file.close();
-
-                    std::string json_meta_path = current_path + "\\" + hash_file_name + ".JSON.meta";
-
-                    std::ofstream json_meta_file = std::ofstream(json_meta_path, std::ofstream::binary);
-
-                    if (!json_meta_file.good()) {
-                        LOG_AND_EXIT("Error: JSON meta file " + json_meta_path + " could not be created.");
-                    }
-
-                    char char4[4];
-
-                    std::memcpy(&char4, &number_of_dlge_categories, BYTES4);
-                    json_meta_file.write(char4, BYTES4);
-
-                    std::memcpy(&char4, &number_of_languages, BYTES4);
-                    json_meta_file.write(char4, BYTES4);
-
-                    json_meta_file.write(json_meta_data.data(), json_meta_data.size());
-
-                    json_meta_file.close();
-
-                    std::vector<hash_depends_variables> hash_depends_data;
-
-                    uint64_t hash_value = rpkgs.at(i).hash.at(hash_index).hash_value;
-
-                    for (uint64_t a = 0; a < rpkgs.size(); a++) {
-                        auto it2 = rpkgs.at(a).hash_map.find(hash_value);
-
-                        hash_depends_variables temp_hash_depends_data;
-
-                        temp_hash_depends_data.rpkg_file_name = rpkgs.at(a).rpkg_file_name;
-
-                        if (it2 == rpkgs.at(a).hash_map.end())
-                            continue;
-
-                        temp_hash_depends_data.hash_value = hash_value;
-
-                        uint32_t temp_hash_reference_count =
-                                rpkgs.at(a).hash.at(it2->second).hash_reference_data.hash_reference_count & 0x3FFFFFFF;
-
-                        if (temp_hash_reference_count > 0) {
-                            for (uint64_t b = 0; b < temp_hash_reference_count; b++) {
-                                std::vector<std::string> dependency_in_rpkg_file;
-
-                                bool found = false;
-
-                                for (uint64_t c = 0; c < rpkgs.size(); c++) {
-                                    auto it3 = rpkgs.at(c).hash_map.find(
-                                            rpkgs.at(a).hash.at(it2->second).hash_reference_data.hash_reference.at(b));
-
-                                    if (it3 == rpkgs.at(c).hash_map.end())
-                                        continue;
-
-                                    if (!found) {
-                                        temp_hash_depends_data.hash_dependency_file_name.push_back(
-                                                util::uint64_t_to_hex_string(
-                                                        rpkgs.at(c).hash.at(it3->second).hash_value) + "." +
-                                                rpkgs.at(c).hash.at(it3->second).hash_resource_type);
-
-                                        std::string hash_link_file_name = current_path + "\\" + hash_file_name + "_" +
-                                                                          util::uint64_t_to_hex_string(
-                                                                                  rpkgs.at(c).hash.at(
-                                                                                          it3->second).hash_value) +
-                                                                          "." + rpkgs.at(c).hash.at(
-                                                it3->second).hash_resource_type;
-
-                                        if (rpkgs.at(c).hash.at(it3->second).hash_resource_type == "WWES") {
-                                            if (!file::path_exists(hash_link_file_name)) {
-                                                std::ofstream json_meta_hash_link_file = std::ofstream(
-                                                        hash_link_file_name, std::ofstream::binary);
-
-                                                if (!json_meta_hash_link_file.good()) {
-                                                    LOG_AND_EXIT("Error: JSON meta file " + hash_link_file_name +
-                                                                 " could not be created.");
-                                                }
-
-                                                json_meta_hash_link_file.close();
-                                            }
-                                        }
-                                    }
-
-                                    found = true;
-
-                                    dependency_in_rpkg_file.push_back(rpkgs.at(c).rpkg_file_name);
-                                }
-
-                                if (!found) {
-                                    temp_hash_depends_data.hash_dependency_file_name.push_back(
-                                            util::uint64_t_to_hex_string(rpkgs.at(a).hash.at(
-                                                    it2->second).hash_reference_data.hash_reference.at(b)));
-                                }
-
-                                temp_hash_depends_data.hash_dependency_map[hash_value] = temp_hash_depends_data.hash_dependency_map.size();
-
-                                temp_hash_depends_data.hash_dependency.push_back(
-                                        util::uint64_t_to_hex_string(hash_value));
-
-                                temp_hash_depends_data.hash_dependency_in_rpkg.push_back(dependency_in_rpkg_file);
-                            }
-                        }
-
-                        hash_depends_data.push_back(temp_hash_depends_data);
-                    }
                 }
             }
         }
@@ -608,8 +240,9 @@ void rpkg_function::extract_dlge_to_json_from(std::string& input_path, std::stri
 
     ss << "Extracting DLGE as JSON: Done";
 
-    if (log_output)
-            LOG("\r" << ss.str() << std::string((80 - ss.str().length()), ' '));
+    if (log_output) {
+        LOG("\r" << ss.str() << std::string((80 - ss.str().length()), ' '));
+    }
 
     if (!output_to_string) {
         percent_progress = static_cast<uint32_t>(100);
diff --git a/src/extract_from_rpkg.cpp b/src/extract_from_rpkg.cpp
index 099f283..ab4d318 100644
--- a/src/extract_from_rpkg.cpp
+++ b/src/extract_from_rpkg.cpp
@@ -4,7 +4,7 @@
 #include "console.h"
 #include "file.h"
 #include "crypto.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <fstream>
 #include <sstream>
diff --git a/src/extract_from_rpkg_with_map.cpp b/src/extract_from_rpkg_with_map.cpp
index 3fc78d0..18ba23b 100644
--- a/src/extract_from_rpkg_with_map.cpp
+++ b/src/extract_from_rpkg_with_map.cpp
@@ -3,7 +3,7 @@
 #include "util.h"
 #include "file.h"
 #include "crypto.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <fstream>
 
diff --git a/src/extract_from_rpkgs.cpp b/src/extract_from_rpkgs.cpp
index 9fe2692..aeb3c44 100644
--- a/src/extract_from_rpkgs.cpp
+++ b/src/extract_from_rpkgs.cpp
@@ -4,7 +4,7 @@
 #include "console.h"
 #include "file.h"
 #include "crypto.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <fstream>
 #include <sstream>
 #include <filesystem>
diff --git a/src/extract_gfxf_from.cpp b/src/extract_gfxf_from.cpp
index 9a3b984..67301d0 100644
--- a/src/extract_gfxf_from.cpp
+++ b/src/extract_gfxf_from.cpp
@@ -4,7 +4,7 @@
 #include "global.h"
 #include "crypto.h"
 #include "console.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <chrono>
 #include <filesystem>
 #include <sstream>
diff --git a/src/extract_locr_to_json_from.cpp b/src/extract_locr_to_json_from.cpp
index 3b25f31..aa19ed2 100644
--- a/src/extract_locr_to_json_from.cpp
+++ b/src/extract_locr_to_json_from.cpp
@@ -4,19 +4,30 @@
 #include "crypto.h"
 #include "console.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/json/json.hpp"
+#include <lz4.h>
+#include <nlohmann/json.hpp>
 #include <iostream>
 #include <set>
 #include <chrono>
 #include <sstream>
 #include <fstream>
 #include <filesystem>
+#include <TonyTools/Languages.h>
 
 using json = nlohmann::ordered_json;
 
 void rpkg_function::extract_locr_to_json_from(std::string& input_path, std::string& filter, std::string& output_path,
-                                              bool output_to_string) {
+                                              bool output_to_string, std::string version) {
+    TonyTools::Language::Version ttVersion = TonyTools::Language::Version::H3;
+    if (version == "HM2") {
+        ttVersion = TonyTools::Language::Version::H2;
+    }
+    else if (version == "HM2016") {
+        ttVersion = TonyTools::Language::Version::H2016;
+    }
+
+    util::load_hmla_hash_list();
+
     task_single_status = TASK_EXECUTING;
     task_multiple_status = TASK_EXECUTING;
 
@@ -65,13 +76,16 @@ void rpkg_function::extract_locr_to_json_from(std::string& input_path, std::stri
 
     timing_string = "Extracting LOCR as JSON...";
 
-    if (log_output)
-            LOG("Extracting LOCR as JSON...");
+    if (log_output) {
+        LOG("Extracting LOCR as JSON...");
+    }
 
     std::chrono::time_point start_time = std::chrono::high_resolution_clock::now();
     int stringstream_length = 80;
 
-    for (auto& rpkg : rpkgs) {
+    for (uint32_t i = 0; i < rpkgs.size(); i++) {
+        auto& rpkg = rpkgs.at(i);
+
         if (rpkg.rpkg_file_path != input_path && input_path_is_rpkg_file)
             continue;
 
@@ -158,235 +172,51 @@ void rpkg_function::extract_locr_to_json_from(std::string& input_path, std::stri
 
                     uint32_t decompressed_size = rpkg.hash.at(hash_index).data.resource.size_final;
 
-                    std::vector<char> output_data(decompressed_size, 0);
-
-                    std::vector<char>* locr_data;
+                    std::vector<char> locr_data(decompressed_size, 0);
 
                     if (rpkg.hash.at(hash_index).data.lz4ed) {
-                        LZ4_decompress_safe(input_data.data(), output_data.data(), (int) hash_size,
+                        LZ4_decompress_safe(input_data.data(), locr_data.data(), (int) hash_size,
                                             decompressed_size);
-
-                        locr_data = &output_data;
-                    } else {
-                        locr_data = &input_data;
-                    }
-
-                    uint32_t number_of_languages = 0;
-                    std::vector<uint32_t> language_offsets;
-                    std::vector<uint32_t> language_string_count;
-                    std::vector<std::vector<uint32_t>> language_string_hash;
-                    std::vector<std::vector<uint32_t>> language_string_length;
-                    std::vector<std::vector<std::string>> language_string;
-                    std::vector<std::set<std::pair<uint32_t, std::string>>> language_string_set;
-                    std::vector<std::string> languages;
-
-                    std::vector<char> json_meta_data;
-
-                    json json_object;
-
-                    uint32_t position = 0;
-
-                    uint8_t bytes1 = 0;
-                    uint32_t bytes4 = 0;
-                    uint64_t bytes8 = 0;
-                    bool isLOCRv2 = false;
-                    bool symKey = false;
-
-                    if ((unsigned int) (*locr_data)[0] == 0 || (unsigned int) (*locr_data)[0] == 1) {
-                        position += 1;
-                        std::memcpy(&number_of_languages, &(*locr_data)[position], BYTES4);
-                        number_of_languages = (number_of_languages - 1) / 4;
-                        isLOCRv2 = true;
                     } else {
-                        std::memcpy(&number_of_languages, &(*locr_data)[position], BYTES4);
-                        number_of_languages = (number_of_languages) / 4;
+                        locr_data = input_data;
                     }
 
-#ifdef _DEBUG
-                    if (log_output)
-                            LOG((isLOCRv2 ? "LOCRv2 identified" : "LOCRv1 identified"));
-#endif
-
-                    if (number_of_languages == 10 && !isLOCRv2) {
-                        LOG("Symmetric key cipher identified");
-                        symKey = true;
-                    }
-
-                    // Quick fix for New Hitman 3 LOCR
-                    if (number_of_languages == 9 && isLOCRv2) {
-                        languages.emplace_back("xx");
-                        languages.emplace_back("en");
-                        languages.emplace_back("fr");
-                        languages.emplace_back("it");
-                        languages.emplace_back("de");
-                        languages.emplace_back("es");
-                        languages.emplace_back("ru");
-                        languages.emplace_back("cn");
-                        languages.emplace_back("tc");
-                    } else if (number_of_languages == 10 && isLOCRv2) {
-                        languages.emplace_back("xx");
-                        languages.emplace_back("en");
-                        languages.emplace_back("fr");
-                        languages.emplace_back("it");
-                        languages.emplace_back("de");
-                        languages.emplace_back("es");
-                        languages.emplace_back("ru");
-                        languages.emplace_back("cn");
-                        languages.emplace_back("tc");
-                        languages.emplace_back("jp");
-                    } else {
-                        languages.emplace_back("xx");
-                        languages.emplace_back("en");
-                        languages.emplace_back("fr");
-                        languages.emplace_back("it");
-                        languages.emplace_back("de");
-                        languages.emplace_back("es");
-                        languages.emplace_back("ru");
-                        languages.emplace_back("mx");
-                        languages.emplace_back("br");
-                        languages.emplace_back("pl");
-                        languages.emplace_back("cn");
-                        languages.emplace_back("jp");
-                        languages.emplace_back("tc");
-                    }
-
-                    for (uint64_t k = 0; k < number_of_languages; k++) {
-                        std::memcpy(&bytes4, &(*locr_data)[position], BYTES4);
-                        position += 4;
-
-                        language_offsets.push_back(bytes4);
-                    }
-
-                    for (uint64_t k = 0; k < (number_of_languages * (uint64_t) 0x4 +
-                                              (isLOCRv2 ? (uint64_t) 0x1 : (uint64_t) 0x0)); k++) {
-                        json_meta_data.push_back((*locr_data)[k]);
-                    }
-
-                    for (uint64_t k = 0; k < number_of_languages; k++) {
-                        if (language_offsets.at(k) == 0xFFFFFFFF)
-                            continue;
-
-                        std::memcpy(&bytes4, &(*locr_data)[position], BYTES4);
-                        position += 4;
-
-                        language_string_count.push_back(bytes4);
-
-                        std::vector<uint32_t> temp_language_string_hash;
-                        std::vector<uint32_t> temp_language_string_length;
-                        std::vector<std::string> temp_language_string;
-                        std::set<std::pair<uint32_t, std::string>> temp_language_string_set;
-                        json temp_language_json_object;
-
-                        json temp_json_object1;
-
-                        temp_json_object1["Language"] = languages.at(k);
+                    std::string locrJson = TonyTools::Language::LOCR::Convert(
+                        ttVersion,
+                        locr_data,
+                        generate_hash_meta_json(i, hash_index)
+                    );
 
-                        temp_language_json_object.push_back(temp_json_object1);
+                    bool doneSym = false;
 
-                        for (uint64_t l = 0; l < language_string_count.back(); l++) {
-                            std::vector<char> temp_string;
+                checkLOCR:
+                    if (locrJson.empty()) {
+                        if (version == "HM2016" && !doneSym) {
+                            locrJson = TonyTools::Language::LOCR::Convert(
+                                ttVersion,
+                                locr_data,
+                                generate_hash_meta_json(i, hash_index),
+                                "",
+                                true
+                            );
 
-                            std::memcpy(&bytes4, &(*locr_data)[position], BYTES4);
-                            position += 4;
+                            doneSym = true;
 
-                            temp_language_string_hash.push_back(bytes4);
-
-                            std::memcpy(&bytes4, &(*locr_data)[position], BYTES4);
-                            position += 4;
-
-                            temp_language_string_length.push_back(bytes4);
-
-                            for (uint64_t m = 0; m < temp_language_string_length.back(); m++) {
-                                temp_string.push_back((*locr_data)[position]);
-                                position += 1;
-                            }
-
-                            position += 1;
-
-                            if (symKey) {
-                                for (uint32_t m = 0; m < temp_language_string_length.back(); m++) {
-                                    temp_string.at(m) = crypto::symmetric_key_decrypt_localization(
-                                            temp_string.at(m));
-                                }
-
-                                json temp_json_object2;
-
-                                temp_json_object2["StringHash"] = temp_language_string_hash.back();
-                                temp_json_object2["String"] = std::string(temp_string.begin(),
-                                                                          temp_string.end());
-
-                                temp_language_json_object.push_back(temp_json_object2);
-                            } else {
-                                if (temp_language_string_length.back() % 8 != 0) {
-                                    LOG_AND_EXIT("Error: LOCR file " + hash_file_name + " in " +
-                                                 rpkg.rpkg_file_name + " is malformed.");
-                                }
-
-                                for (uint32_t m = 0; m < temp_language_string_length.back() / 8; m++) {
-                                    uint32_t data[2];
-                                    std::memcpy(data, &temp_string[(uint64_t) m * (uint64_t) 8],
-                                                sizeof(uint32_t));
-                                    std::memcpy(data + 1,
-                                                &temp_string[(uint64_t) m * (uint64_t) 8 + (uint64_t) 4],
-                                                sizeof(uint32_t));
-
-                                    crypto::xtea_decrypt_localization(data);
-
-                                    std::memcpy(&temp_string[(uint64_t) m * (uint64_t) 8], data,
-                                                sizeof(uint32_t));
-                                    std::memcpy(&temp_string[(uint64_t) m * (uint64_t) 8 + (uint64_t) 4],
-                                                data + 1, sizeof(uint32_t));
-                                }
-
-                                auto last_zero_position = (uint32_t) temp_string.size();
-
-                                if (!temp_string.empty()) {
-                                    auto m = (uint32_t) (temp_string.size() - 1);
-
-                                    while (m >= 0) {
-                                        if (temp_string.at(m) != 0) {
-                                            break;
-                                        } else {
-                                            last_zero_position--;
-                                        }
-
-                                        m--;
-                                    }
-                                }
-
-                                std::string temp_string_with_zero_pad_removed = std::string(temp_string.begin(),
-                                                                                            temp_string.end()).substr(
-                                        0, last_zero_position);
-
-                                temp_language_string.push_back(temp_string_with_zero_pad_removed);
-
-                                std::pair<uint32_t, std::string> temp_pair;
-
-                                temp_pair.first = temp_language_string_hash.back();
-                                temp_pair.second = temp_language_string.back();
-
-                                temp_language_string_set.insert(temp_pair);
-
-                                json temp_json_object2;
-
-                                temp_json_object2["StringHash"] = temp_language_string_hash.back();
-                                temp_json_object2["String"] = temp_language_string.back();
-
-                                temp_language_json_object.push_back(temp_json_object2);
-                            }
+                            goto checkLOCR;
                         }
-
-                        json_object.push_back(temp_language_json_object);
+                        LOG_AND_EXIT("Failed to convert LOCR file to JSON.");
                     }
 
+                    json parsedJson = json::parse(locrJson);
+
                     if (output_to_string) {
                         std::stringstream ss1;
 
-                        ss1 << std::setw(4) << json_object << std::endl;
+                        ss1 << std::setw(4) << parsedJson << std::endl;
 
                         localization_string = ss1.str();
 
-                        localization_json = json_object;
+                        localization_json = parsedJson;
                     } else {
                         std::string json_path = current_path + "\\" + hash_file_name + ".JSON";
 
@@ -396,21 +226,9 @@ void rpkg_function::extract_locr_to_json_from(std::string& input_path, std::stri
                             LOG_AND_EXIT("Error: JSON file " + json_path + " could not be created.");
                         }
 
-                        json_file << std::setw(4) << json_object << std::endl;
+                        json_file << std::setw(4) << parsedJson << std::endl;
 
                         json_file.close();
-
-                        std::string json_meta_path = current_path + "\\" + hash_file_name + ".JSON.meta";
-
-                        std::ofstream json_meta_file = std::ofstream(json_meta_path, std::ofstream::binary);
-
-                        if (!json_meta_file.good()) {
-                            LOG_AND_EXIT("Error: JSON meta file " + json_meta_path + " could not be created.");
-                        }
-
-                        json_meta_file.write(json_meta_data.data(), json_meta_data.size());
-
-                        json_meta_file.close();
                     }
                 }
             }
@@ -421,8 +239,9 @@ void rpkg_function::extract_locr_to_json_from(std::string& input_path, std::stri
 
     ss << "Extracting LOCR as JSON: Done";
 
-    if (log_output)
-            LOG("\r" << ss.str() << std::string((80 - ss.str().length()), ' '));
+    if (log_output) {
+        LOG("\r" << ss.str() << std::string((80 - ss.str().length()), ' '));
+    }
 
     if (!output_to_string) {
         percent_progress = (uint32_t) 100;
diff --git a/src/extract_prel_from.cpp b/src/extract_prel_from.cpp
index 86af73f..bcf7490 100644
--- a/src/extract_prel_from.cpp
+++ b/src/extract_prel_from.cpp
@@ -4,7 +4,7 @@
 #include "crypto.h"
 #include "util.h"
 #include "generic_function.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <sstream>
 #include <fstream>
diff --git a/src/extract_rtlv_to_json_from.cpp b/src/extract_rtlv_to_json_from.cpp
index 4358ab2..3296d4e 100644
--- a/src/extract_rtlv_to_json_from.cpp
+++ b/src/extract_rtlv_to_json_from.cpp
@@ -4,19 +4,30 @@
 #include "crypto.h"
 #include "console.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/json/json.hpp"
+#include <lz4.h>
+#include <nlohmann/json.hpp>
 #include <set>
 #include <chrono>
 #include <sstream>
 #include <fstream>
 #include <regex>
 #include <filesystem>
+#include <TonyTools/Languages.h>
 
 using json = nlohmann::ordered_json;
 
 void rpkg_function::extract_rtlv_to_json_from(std::string& input_path, std::string& filter, std::string& output_path,
-                                              bool output_to_string) {
+                                              bool output_to_string, std::string version) {
+    TonyTools::Language::Version ttVersion = TonyTools::Language::Version::H3;
+    if (version == "HM2") {
+        ttVersion = TonyTools::Language::Version::H2;
+    }
+    else if (version == "HM2016") {
+        ttVersion = TonyTools::Language::Version::H2016;
+    }
+
+    util::load_hmla_hash_list();
+
     task_single_status = TASK_EXECUTING;
     task_multiple_status = TASK_EXECUTING;
 
@@ -71,7 +82,9 @@ void rpkg_function::extract_rtlv_to_json_from(std::string& input_path, std::stri
     std::chrono::time_point start_time = std::chrono::high_resolution_clock::now();
     int stringstream_length = 80;
 
-    for (auto& rpkg : rpkgs) {
+    for (uint32_t i = 0; i < rpkgs.size(); i++) {
+        auto& rpkg = rpkgs.at(i);
+
         if (rpkg.rpkg_file_path != input_path && input_path_is_rpkg_file)
             continue;
 
@@ -152,251 +165,47 @@ void rpkg_function::extract_rtlv_to_json_from(std::string& input_path, std::stri
 
                     uint32_t decompressed_size = rpkg.hash.at(hash_index).data.resource.size_final;
 
-                    std::vector<char> output_data(decompressed_size, 0);
-
-                    std::vector<char>* rtlv_data;
+                    std::vector<char> rtlv_data(decompressed_size, 0);
 
                     if (rpkg.hash.at(hash_index).data.lz4ed) {
-                        LZ4_decompress_safe(input_data.data(), output_data.data(), static_cast<int>(hash_size),
+                        LZ4_decompress_safe(input_data.data(), rtlv_data.data(), static_cast<int>(hash_size),
                                             decompressed_size);
-
-                        rtlv_data = &output_data;
                     } else {
-                        rtlv_data = &input_data;
+                        rtlv_data = input_data;
                     }
 
-                    uint32_t rtlv_data_size = 0;
-                    uint64_t rtlv_header_value = 0;
-                    std::vector<char> rtlv_footer;
-                    uint32_t rtlv_header_data_size = 0;
-                    std::vector<char> rtlv_header;
-                    uint32_t languages_starting_offset = 0;
-                    uint32_t number_of_languages = 0;
-                    uint32_t check_for_languages = 0;
-                    std::vector<uint32_t> language_offsets;
-                    std::vector<std::vector<char>> language_data;
-                    std::vector<uint16_t> language_data_sizes;
-                    std::vector<uint16_t> language_unknowns;
-                    std::vector<std::vector<std::string>> language_string;
-                    std::vector<std::set<std::pair<uint32_t, std::string>>> language_string_set;
-                    std::vector<std::string> languages;
-
-                    std::vector<char> json_meta_data;
-
-                    json json_object;
-
-                    uint32_t position = 0;
-
-                    char char4[4] = "";
-
-                    position = 0x58;
-                    std::memcpy(&languages_starting_offset, &(*rtlv_data)[position], BYTES4);
-
-                    // Quick fix for New Hitman 3 LOCR
-                    std::memcpy(&check_for_languages, &(*rtlv_data)[0xC4], BYTES4);
-                    if (check_for_languages == 9) {
-                        languages.emplace_back("xx");
-                        languages.emplace_back("en");
-                        languages.emplace_back("fr");
-                        languages.emplace_back("it");
-                        languages.emplace_back("de");
-                        languages.emplace_back("es");
-                        languages.emplace_back("ru");
-                        languages.emplace_back("cn");
-                        languages.emplace_back("tc");
-                    } else {
-                        languages.emplace_back("xx");
-                        languages.emplace_back("en");
-                        languages.emplace_back("fr");
-                        languages.emplace_back("it");
-                        languages.emplace_back("de");
-                        languages.emplace_back("es");
-                        languages.emplace_back("ru");
-                        languages.emplace_back("mx");
-                        languages.emplace_back("br");
-                        languages.emplace_back("pl");
-                        languages.emplace_back("cn");
-                        languages.emplace_back("jp");
-                        languages.emplace_back("tc");
-                    }
+                    std::string rtlvJson = TonyTools::Language::RTLV::Convert(
+                        ttVersion,
+                        rtlv_data,
+                        generate_hash_meta_json(i, hash_index)
+                    );
 
-                    position = 0;
-                    std::memcpy(&rtlv_header_value, &(*rtlv_data)[position], BYTES8);
-
-                    for (uint64_t k = 0; k < BYTES8; k++) {
-                        json_meta_data.push_back((*rtlv_data)[position + k]);
+                    if (rtlvJson.empty()) {
+                        LOG_AND_EXIT("Failed to convert RTLV to JSON!");
                     }
 
-                    uint32_t bytes4 = 0;
-
-                    position += BYTES8;
-
-                    std::memcpy(&bytes4, &(*rtlv_data)[position], BYTES4);
-                    position += BYTES4;
-
-                    rtlv_data_size = ((bytes4 & 0x000000FF) << 0x18) + ((bytes4 & 0x0000FF00) << 0x8) +
-                                     ((bytes4 & 0x00FF0000) >> 0x8) + ((bytes4 & 0xFF000000) >> 0x18);
-
-                    if (languages_starting_offset < rtlv_data_size) {
-                        languages_starting_offset += 0xC;
-
-                        rtlv_header_data_size = languages_starting_offset - position;
-
-                        std::memcpy(&char4, &rtlv_header_data_size, BYTES4);
-
-                        for (char& k : char4) {
-                            json_meta_data.push_back(k);
-                        }
-
-                        for (uint64_t k = 0; k < rtlv_header_data_size; k++) {
-                            rtlv_header.push_back((*rtlv_data)[position]);
-
-                            json_meta_data.push_back((*rtlv_data)[position]);
-
-                            position += 1;
-                        }
-
-                        std::memcpy(&number_of_languages, &(*rtlv_data)[position], BYTES4);
-
-                        for (uint64_t k = 0; k < BYTES4; k++) {
-                            json_meta_data.push_back((*rtlv_data)[position + k]);
-                        }
-
-                        position += BYTES4;
-
-                        uint16_t bytes2 = 0;
-
-                        for (uint64_t k = 0; k < number_of_languages; k++) {
-                            uint16_t section_length = 0;
-
-                            std::memcpy(&section_length, &(*rtlv_data)[position], BYTES2);
-                            position += BYTES2;
-
-                            std::memcpy(&bytes2, &(*rtlv_data)[position], BYTES2);
-                            position += BYTES2;
-
-                            language_unknowns.push_back(BYTES2);
+                    json parsedJson = json::parse(rtlvJson);
 
-                            std::memcpy(&bytes4, &(*rtlv_data)[position], BYTES4);
-                            position += BYTES4;
+                    if (output_to_string) {
+                        std::stringstream ss;
 
-                            std::memcpy(&bytes4, &(*rtlv_data)[position], BYTES4);
-                            position += BYTES4;
+                        ss << std::setw(4) << parsedJson << std::endl;
 
-                            language_offsets.push_back(bytes4);
+                        localization_string = ss.str();
 
-                            std::memcpy(&bytes4, &(*rtlv_data)[position], BYTES4);
-                            position += BYTES4;
-                        }
-
-                        for (uint64_t k = 0; k < number_of_languages; k++) {
-                            json temp_language_json_object;
-
-                            temp_language_json_object["Language"] = languages.at(k);
-
-                            std::memcpy(&bytes4, &(*rtlv_data)[position], BYTES4);
-                            position += BYTES4;
-
-                            language_data_sizes.push_back(bytes4);
-
-                            std::vector<char> temp_string;
-
-                            if (language_data_sizes.back() == 0) {
-                                std::memcpy(&bytes4, &(*rtlv_data)[position], BYTES4);
-                                position += BYTES4;
-
-                                temp_language_json_object["String"] = "";
-                            } else {
-                                for (uint64_t l = 0; l < language_data_sizes.back(); l++) {
-                                    temp_string.push_back((*rtlv_data)[position]);
-                                    position += 1;
-                                }
-
-                                if (language_data_sizes.back() % 8 != 0) {
-                                    LOG_AND_EXIT("Error: RTLV file " + hash_file_name + " in " + rpkg.rpkg_file_name +
-                                                 " is malformed.");
-                                }
-
-                                for (uint32_t m = 0; m < static_cast<uint32_t>(language_data_sizes.back()) / 8; m++) {
-                                    uint32_t data[2];
-                                    std::memcpy(data, &temp_string[static_cast<uint64_t>(m) * static_cast<uint64_t>(8)],
-                                                sizeof(uint32_t));
-                                    std::memcpy(data + 1,
-                                                &temp_string[static_cast<uint64_t>(m) * static_cast<uint64_t>(8) +
-                                                             static_cast<uint64_t>(4)], sizeof(uint32_t));
-
-                                    crypto::xtea_decrypt_localization(data);
-
-                                    std::memcpy(&temp_string[static_cast<uint64_t>(m) * static_cast<uint64_t>(8)], data,
-                                                sizeof(uint32_t));
-                                    std::memcpy(&temp_string[static_cast<uint64_t>(m) * static_cast<uint64_t>(8) +
-                                                             static_cast<uint64_t>(4)], data + 1, sizeof(uint32_t));
-                                }
-
-                                auto last_zero_position = static_cast<uint32_t>(temp_string.size());
-
-                                if (!temp_string.empty()) {
-                                    auto m = static_cast<uint32_t>(temp_string.size() - 1);
-
-                                    while (m >= 0) {
-                                        if (temp_string.at(m) != 0) {
-                                            break;
-                                        }
-
-                                        last_zero_position--;
-                                        m--;
-                                    }
-                                }
-
-                                std::string temp_string_with_zero_pad_removed = std::string(temp_string.begin(),
-                                                                                            temp_string.end()).substr(0,
-                                                                                                                      last_zero_position);
-
-                                temp_language_json_object["String"] = temp_string_with_zero_pad_removed;
-                            }
+                        localization_json = parsedJson;
+                    } else {
+                        std::string json_path = current_path + "\\" + hash_file_name + ".JSON";
 
-                            json_object.push_back(temp_language_json_object);
-                        }
+                        std::ofstream json_file = std::ofstream(json_path, std::ofstream::binary);
 
-                        if ((decompressed_size - position) > 0) {
-                            for (uint64_t k = 0; k < (decompressed_size - position); k++) {
-                                json_meta_data.push_back((*rtlv_data)[position + k]);
-                            }
+                        if (!json_file.good()) {
+                            LOG_AND_EXIT("Error: JSON file " + json_path + " could not be created.");
                         }
 
-                        if (output_to_string) {
-                            std::stringstream ss;
-
-                            ss << std::setw(4) << json_object << std::endl;
-
-                            localization_string = ss.str();
-
-                            localization_json = json_object;
-                        } else {
-                            std::string json_path = current_path + "\\" + hash_file_name + ".JSON";
-
-                            std::ofstream json_file = std::ofstream(json_path, std::ofstream::binary);
+                        json_file << std::setw(4) << parsedJson << std::endl;
 
-                            if (!json_file.good()) {
-                                LOG_AND_EXIT("Error: JSON file " + json_path + " could not be created.");
-                            }
-
-                            json_file << std::setw(4) << json_object << std::endl;
-
-                            json_file.close();
-
-                            std::string json_meta_path = current_path + "\\" + hash_file_name + ".JSON.meta";
-
-                            std::ofstream json_meta_file = std::ofstream(json_meta_path, std::ofstream::binary);
-
-                            if (!json_meta_file.good()) {
-                                LOG_AND_EXIT("Error: JSON meta file " + json_meta_path + " could not be created.");
-                            }
-
-                            json_meta_file.write(json_meta_data.data(), json_meta_data.size());
-
-                            json_meta_file.close();
-                        }
+                        json_file.close();
                     }
                 }
             }
diff --git a/src/extract_temp_from.cpp b/src/extract_temp_from.cpp
index d567aa1..9e06a34 100644
--- a/src/extract_temp_from.cpp
+++ b/src/extract_temp_from.cpp
@@ -5,7 +5,7 @@
 // #include "console.h"
 // #include "util.h"
 // #include "generic_function.h"
-// #include "thirdparty/lz4/lz4.h"
+// #include <lz4.h>
 // #include <iostream>
 // #include <unordered_map>
 // #include <chrono>
diff --git a/src/extract_to_rt_json.cpp b/src/extract_to_rt_json.cpp
index 8c40c37..2f732f9 100644
--- a/src/extract_to_rt_json.cpp
+++ b/src/extract_to_rt_json.cpp
@@ -3,20 +3,16 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/rapidjson/document.h"
-#include "thirdparty/rapidjson/prettywriter.h"
-#include "thirdparty/rapidjson/stringbuffer.h"
+#include <lz4.h>
+#include <rapidjson/document.h>
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/stringbuffer.h>
 #include <sstream>
 #include <fstream>
 #include <filesystem>
-#include "thirdparty/zhmtools/ResourceLib_HM2016.h"
-#include "thirdparty/zhmtools/ResourceLib_HM2.h"
-#include "thirdparty/zhmtools/ResourceLib_HM3.h"
-
-#pragma comment(lib, "../thirdparty/zhmtools/ResourceLib_HM2016.lib")
-#pragma comment(lib, "../thirdparty/zhmtools/ResourceLib_HM2.lib")
-#pragma comment(lib, "../thirdparty/zhmtools/ResourceLib_HM3.lib")
+#include <ResourceLib_HM2016.h>
+#include <ResourceLib_HM2.h>
+#include <ResourceLib_HM3.h>
 
 const std::vector<std::string> hm2016_valid_resources = {"TEMP", "AIRG", "TBLU", "RTLV", "CRMD", "ATMD", "CBLU", "CPPT", "DSWB",
                                                          "GFXF", "GIDX", "VIDB", "WSGB"};
diff --git a/src/extract_wwem_to_ogg_from.cpp b/src/extract_wwem_to_ogg_from.cpp
index d1457f2..914ff70 100644
--- a/src/extract_wwem_to_ogg_from.cpp
+++ b/src/extract_wwem_to_ogg_from.cpp
@@ -5,7 +5,7 @@
 #include "console.h"
 #include "util.h"
 #include "generic_function.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include "thirdparty/ww2ogg/packed_codebooks_aoTuV_603.h"
 #include "thirdparty/ww2ogg/wwriff.h"
 #include "thirdparty/revorb/revorb.h"
diff --git a/src/extract_wwes_to_ogg_from.cpp b/src/extract_wwes_to_ogg_from.cpp
index 54dc54d..d04e744 100644
--- a/src/extract_wwes_to_ogg_from.cpp
+++ b/src/extract_wwes_to_ogg_from.cpp
@@ -5,7 +5,7 @@
 #include "console.h"
 #include "util.h"
 #include "generic_function.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include "thirdparty/ww2ogg/packed_codebooks_aoTuV_603.h"
 #include "thirdparty/ww2ogg/wwriff.h"
 #include "thirdparty/revorb/revorb.h"
diff --git a/src/extract_wwev_to_ogg_from.cpp b/src/extract_wwev_to_ogg_from.cpp
index 98c795e..8b1b8a7 100644
--- a/src/extract_wwev_to_ogg_from.cpp
+++ b/src/extract_wwev_to_ogg_from.cpp
@@ -4,7 +4,7 @@
 #include "crypto.h"
 #include "console.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include "thirdparty/ww2ogg/packed_codebooks_aoTuV_603.h"
 #include "thirdparty/ww2ogg/wwriff.h"
 #include "thirdparty/revorb/revorb.h"
diff --git a/src/generate_hash_meta_json.cpp b/src/generate_hash_meta_json.cpp
index 3490e47..3895d4a 100644
--- a/src/generate_hash_meta_json.cpp
+++ b/src/generate_hash_meta_json.cpp
@@ -1,9 +1,14 @@
 #include "rpkg_function.h"
+#include "generic_function.h"
 #include "global.h"
 #include "util.h"
 
 std::string rpkg_function::generate_hash_meta_json(const uint64_t rpkg_index, const uint64_t hash_index)
 {
+    if (!hash_list_loaded) {
+        generic_function::load_hash_list(false);
+    }
+
     // Output hash's meta data to JSON format
     nlohmann::ordered_json json;
     json["hash_value"] = util::uint64_t_to_hex_string(rpkgs.at(rpkg_index).hash.at(hash_index).hash_value);
diff --git a/src/generate_rpkg_from.cpp b/src/generate_rpkg_from.cpp
index 0e37e51..137b498 100644
--- a/src/generate_rpkg_from.cpp
+++ b/src/generate_rpkg_from.cpp
@@ -6,8 +6,8 @@
 #include "console.h"
 #include "crypto.h"
 #include "global.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/lz4/lz4hc.h"
+#include <lz4.h>
+#include <lz4hc.h>
 #include <chrono>
 #include <filesystem>
 #include <iostream>
diff --git a/src/get_line_string.cpp b/src/get_line_string.cpp
index 11cd600..87e5154 100644
--- a/src/get_line_string.cpp
+++ b/src/get_line_string.cpp
@@ -4,11 +4,12 @@
 #include "global.h"
 #include "util.h"
 #include "crypto.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <unordered_map>
 #include <sstream>
 #include <fstream>
+#include <TonyTools/Languages.h>
 
 void rpkg_function::get_line_string(std::string& input_path, std::string& filter, std::string& output_path) {
     std::string input_rpkg_folder_path = file::parse_input_folder_path(input_path);
@@ -122,48 +123,27 @@ void rpkg_function::get_line_string(std::string& input_path, std::string& filter
 
             if (it6 != rpkgs.at(rpkg_index2).hash_map.end()) {
                 rpkg_function::extract_locr_to_json_from(rpkgs.at(rpkg_index2).rpkg_file_path, hash_string, output_path,
-                                                         true);
+                                                         true, "HM3");
 
-                for (const auto& it : localization_json.items()) {
-                    bool language_found = false;
+                for (const auto& [language, translations] : localization_json["languages"].items()) {
+                    std::string locrKey = TonyTools::Language::HashList::GetLine(line_crc32);
+                    std::string hash = util::uint32_t_to_hex_string(line_crc32);
 
-                    std::string language = "";
-
-                    for (const auto& it2 : it.value().items()) {
-                        if (it2.value().contains("Language")) {
-                            language_found = true;
-
-                            language = it2.value()["Language"];
-                        }
-                    }
-
-                    if (!language_found)
+                    if (!translations.contains(locrKey)) {
                         continue;
+                    }
 
-                    for (const auto& it2 : it.value().items()) {
-                        if (!it2.value().contains("StringHash") ||
-                            static_cast<uint32_t>(it2.value()["StringHash"]) != line_crc32)
-                            continue;
-
-                        //LOG("FOUND CRC32: " + util::uint32_t_to_hex_string(line_crc32) + " in " << hash_string);
-
-                        if (!it2.value().contains("String"))
-                            continue;
+                    std::string found_translation = translations.at(locrKey).get<std::string>();
 
+                    if (found_translation != "") {
                         if (localization_line_string == "") {
-                            localization_line_string =
-                                    "\nLINE CRC32: " + util::uint32_t_to_string(line_crc32) + "\nLOCR Strings:\n";
-
-                            localization_line_string +=
-                                    "  - " + language + ": " + std::string(it2.value()["String"]) + "\n";
-                        } else {
-                            localization_line_string +=
-                                    "  - " + language + ": " + std::string(it2.value()["String"]) + "\n";
+                            localization_line_string = "\n" + (hash != locrKey ? "LINE: " + locrKey + "\n" : "") + "Hash: " + hash + "\nLOCR Strings:\n";
                         }
 
-                        //LOG("FOUND STRING: " + std::string(it2.value()["String"]) + " in " << hash_string);
+                        localization_line_string += "  - " + language + ": " + found_translation + "\n";
                     }
                 }
+
             }
         }
     }
diff --git a/src/global.h b/src/global.h
index 66d6a06..af0edf9 100644
--- a/src/global.h
+++ b/src/global.h
@@ -9,7 +9,7 @@
 #include <string>
 #include <vector>
 #include <cstdint>
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 
 #ifdef RPKG_CLI
 #include <iostream>
@@ -26,6 +26,24 @@
 #define LOG_AND_EXIT_NOP(x)
 #endif
 
+// Helps clean up l10n deep search
+enum class DLGE_Type : uint8_t
+{
+    eDEIT_WavFile = 0x01,
+    eDEIT_RandomContainer,
+    eDEIT_SwitchContainer,
+    eDEIT_SequenceContainer,
+    eDEIT_Invalid = 0x15
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DLGE_Type, {
+    {DLGE_Type::eDEIT_Invalid, "Invalid"},
+    {DLGE_Type::eDEIT_WavFile, "WavFile"},
+    {DLGE_Type::eDEIT_RandomContainer, "Random"},
+    {DLGE_Type::eDEIT_SwitchContainer, "Switch"},
+    {DLGE_Type::eDEIT_SequenceContainer, "Sequence"}
+});
+
 enum RPKGStatus {
     READY,
     TASK_EXECUTING,
diff --git a/src/hash_meta_to_json.cpp b/src/hash_meta_to_json.cpp
index 8f6e9f6..67d1bda 100644
--- a/src/hash_meta_to_json.cpp
+++ b/src/hash_meta_to_json.cpp
@@ -4,9 +4,9 @@
 #include "file.h"
 #include "util.h"
 #include <fstream>
-#include "thirdparty/rapidjson/document.h"
-#include "thirdparty/rapidjson/prettywriter.h"
-#include "thirdparty/rapidjson/stringbuffer.h"
+#include <rapidjson/document.h>
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/stringbuffer.h>
 
 void rpkg_function::hash_meta_to_json(std::string& input_path) {
     task_single_status = TASK_EXECUTING;
diff --git a/src/import_hash_meta_json.cpp b/src/import_hash_meta_json.cpp
index 1eed2fa..ec0b04d 100644
--- a/src/import_hash_meta_json.cpp
+++ b/src/import_hash_meta_json.cpp
@@ -8,9 +8,9 @@
 #include <fstream>
 #include <string>
 #include <sstream>
-#include "thirdparty/rapidjson/document.h"
-#include "thirdparty/rapidjson/writer.h"
-#include "thirdparty/rapidjson/error/en.h"
+#include <rapidjson/document.h>
+#include <rapidjson/writer.h>
+#include <rapidjson/error/en.h>
 
 bool rpkg_function::import_hash_meta_json(hash& meta_data, const std::string& input_path) {
     std::string input_json_string = file::read_file_to_string(input_path);
diff --git a/src/json_to_hash_meta.cpp b/src/json_to_hash_meta.cpp
index eb0d89c..2c86d96 100644
--- a/src/json_to_hash_meta.cpp
+++ b/src/json_to_hash_meta.cpp
@@ -5,46 +5,22 @@
 #include "util.h"
 #include <fstream>
 #include <iostream>
-#include "thirdparty/rapidjson/document.h"
-#include "thirdparty/rapidjson/writer.h"
+#include <rapidjson/document.h>
+#include <rapidjson/writer.h>
 
-void rpkg_function::json_to_hash_meta(std::string& input_path) {
+std::vector<char> rpkg_function::json_to_hash_meta(std::string& json_string) {
     task_single_status = TASK_EXECUTING;
     task_multiple_status = TASK_EXECUTING;
 
-    if (!file::path_exists(input_path)) {
-        task_single_status = TASK_SUCCESSFUL;
-        task_multiple_status = TASK_SUCCESSFUL;
-        return;
-    }
-
     std::vector<char> meta_data;
 
     char char1[1];
     char char4[4];
     char char8[8];
 
-    std::ifstream json_file = std::ifstream(input_path, std::ifstream::binary);
-
-    if (!json_file.good()) {
-        LOG_AND_EXIT("Error: Hash meta JSON file " + input_path + " could not be read.");
-    }
-
-    json_file.seekg(0, std::ifstream::end);
-
-    uint64_t json_file_size = json_file.tellg();
-
-    json_file.seekg(0, std::ifstream::beg);
-
-    std::string input_json_string(json_file_size, '\0');
-
-    json_file.read(&input_json_string[0], json_file_size);
-
-    json_file.close();
-
     rapidjson::Document document;
 
-    document.Parse(input_json_string.c_str());
+    document.Parse(json_string.c_str());
 
     const rapidjson::Value& hash_value = document["hash_value"];
 
@@ -53,7 +29,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_value is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     std::cout << hash_value.GetString() << std::endl;
@@ -79,7 +55,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_offset is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     std::cout << hash_offset.GetUint64() << std::endl;
@@ -99,7 +75,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_size is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     std::cout << hash_size.GetUint() << std::endl;
@@ -119,7 +95,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_resource_type is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     std::cout << hash_resource_type.GetString() << std::endl;
@@ -137,7 +113,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_reference_data is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     if (!hash_reference_data.IsArray()) {
@@ -145,7 +121,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_reference_data is in the JSON but not an array.";
 
-        return;
+        return {};
     }
 
     uint32_t hash_reference_data_size = hash_reference_data.Size();
@@ -157,7 +133,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_reference_table_size is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     std::cout << hash_reference_table_size.GetUint() << std::endl;
@@ -181,7 +157,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_reference_table_dummy is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     std::cout << hash_reference_table_dummy.GetUint() << std::endl;
@@ -201,7 +177,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_size_final is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     std::cout << hash_size_final.GetUint() << std::endl;
@@ -221,7 +197,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_size_in_memory is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     std::cout << hash_size_in_memory.GetUint() << std::endl;
@@ -241,7 +217,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
 
         response_string = "Error: hash_size_in_video_memory is missing from the JSON.";
 
-        return;
+        return {};
     }
 
     std::cout << hash_size_in_video_memory.GetUint() << std::endl;
@@ -270,7 +246,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
                 response_string =
                         "Error: hash_reference_data[" + std::to_string(i) + "][\"flag\"] is missing from the JSON.";
 
-                return;
+                return {};
             }
 
             std::cout << hash_reference_data[i]["flag"].GetString() << std::endl;
@@ -289,7 +265,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
                 response_string =
                         "Error: hash_reference_data[" + std::to_string(i) + "][\"hash\"] is missing from the JSON.";
 
-                return;
+                return {};
             }
 
             std::cout << hash_reference_data[i]["hash"].GetString() << std::endl;
@@ -302,7 +278,7 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
                 response_string =
                     "Error: hash_reference_data[" + std::to_string(i) + "][\"hash\"] is empty in the JSON.";
 
-                return;
+                return {};
             } else if (util::is_valid_hash(hash_value_string)) {
                 temp_string = hash_value_string;
             } else {
@@ -319,26 +295,8 @@ void rpkg_function::json_to_hash_meta(std::string& input_path) {
         }
     }
 
-    if (input_path.length() > 11) {
-        if (util::to_upper_case(input_path.substr(input_path.length() - 10)) != ".META.JSON") {
-            LOG("Error: Input file does not end in .meta.JSON");
-
-            response_string = "Error: Input file does not end in .meta.JSON";
-
-            return;
-        }
-    }
-
-    std::ofstream meta_file = std::ofstream(input_path.substr(0, input_path.length() - 5), std::ofstream::binary);
-
-    LOG("Success: " + input_path + " has been converted.");
-
-    response_string = "Success: " + input_path + " has been converted.";
-
-    meta_file.write(meta_data.data(), meta_data.size());
-
-    meta_file.close();
-
     task_single_status = TASK_SUCCESSFUL;
     task_multiple_status = TASK_SUCCESSFUL;
+
+    return meta_data;
 }
\ No newline at end of file
diff --git a/src/lib/rpkg_dll.cpp b/src/lib/rpkg_dll.cpp
index aaf4dfd..bf40f18 100644
--- a/src/lib/rpkg_dll.cpp
+++ b/src/lib/rpkg_dll.cpp
@@ -7,8 +7,8 @@
 #include "../console.h"
 #include "../text.h"
 #include "../generic_function.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/json/json.hpp"
+#include <lz4.h>
+#include <nlohmann/json.hpp>
 #include "thirdparty/ww2ogg/packed_codebooks_aoTuV_603.h"
 #include "thirdparty/ww2ogg/wwriff.h"
 #include "thirdparty/revorb/revorb.h"
@@ -32,6 +32,10 @@ int load_hash_list(char* path) {
     return hash_list_version;
 }
 
+uint32_t load_hmla_hash_list(char* path) {
+    return util::load_hmla_hash_list(std::string(path));
+}
+
 char* get_hash_list_string(char* hash_string) {
     uint64_t hash = std::strtoull(hash_string, nullptr, 16);
 
@@ -828,11 +832,11 @@ uint32_t generate_localization_string(char* rpkg_file, char* hash_string, char*
     std::string resource = std::string(resource_type);
 
     if (resource == "DLGE") {
-        rpkg_function::extract_dlge_to_json_from(input_path, filter, output_path, true);
+        rpkg_function::extract_dlge_to_json_from(input_path, filter, output_path, true, "HM3");
     } else if (resource == "LOCR") {
-        rpkg_function::extract_locr_to_json_from(input_path, filter, output_path, true);
+        rpkg_function::extract_locr_to_json_from(input_path, filter, output_path, true, "HM3");
     } else if (resource == "RTLV") {
-        rpkg_function::extract_rtlv_to_json_from(input_path, filter, output_path, true);
+        rpkg_function::extract_rtlv_to_json_from(input_path, filter, output_path, true, "HM3");
     }
 
     return (uint32_t) localization_string.length();
@@ -2152,7 +2156,7 @@ char* get_entry_name(uint32_t temp_index, int entry_index) {
 }
 
 int deep_search_localization(char* input_path, char* search_value, int search_dlge, int search_locr, int search_rtlv,
-                             int max_results) {
+                             int max_results, char* version) {
     gui_control = READY;
     task_single_status = READY;
     task_multiple_status = READY;
@@ -2177,7 +2181,7 @@ int deep_search_localization(char* input_path, char* search_value, int search_dl
         search_rtlv_bool = true;
 
     rpkg_function::search_localization(input_path_string, search, output_path, search_dlge_bool,
-                                       search_locr_bool, search_rtlv_bool, max_results);
+                                       search_locr_bool, search_rtlv_bool, max_results, std::string(version));
 
     return 0;
 }
diff --git a/src/lib/rpkg_dll.h b/src/lib/rpkg_dll.h
index 2074e28..5389435 100644
--- a/src/lib/rpkg_dll.h
+++ b/src/lib/rpkg_dll.h
@@ -6,6 +6,8 @@
 
 RPKG_EXPORT int load_hash_list(char* path);
 
+RPKG_EXPORT uint32_t load_hmla_hash_list(char* path);
+
 RPKG_EXPORT char* get_hash_list_string(char* hash_string);
 
 RPKG_EXPORT int
@@ -168,7 +170,7 @@ RPKG_EXPORT char* get_entry_name(uint32_t temp_index, int entry_index);
 
 RPKG_EXPORT int
 deep_search_localization(char* input_path, char* search_value, int search_dlge, int search_locr, int search_rtlv,
-                         int max_results);
+                         int max_results, char* version);
 
 RPKG_EXPORT uint32_t get_localization_search_results_size();
 
diff --git a/src/map.cpp b/src/map.cpp
index 33df9e0..b1b568a 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -11,10 +11,10 @@
 #include <filesystem>
 #include <regex>
 #include <sstream>
-#include "thirdparty/rapidjson/document.h"
-#include "thirdparty/rapidjson/pointer.h"
-#include "thirdparty/rapidjson/stringbuffer.h"
-#include "thirdparty/directxmath/DirectXMath.h"
+#include <rapidjson/document.h>
+#include <rapidjson/pointer.h>
+#include <rapidjson/stringbuffer.h>
+#include <DirectXMath.h>
 
 map::map() = default;
 
diff --git a/src/material.cpp b/src/material.cpp
index 5f4d8d7..4bf4a78 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -4,7 +4,7 @@
 #include "crypto.h"
 #include "util.h"
 #include "file.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <map>
 #include <fstream>
diff --git a/src/material.h b/src/material.h
index ea649c0..1153e25 100644
--- a/src/material.h
+++ b/src/material.h
@@ -7,7 +7,7 @@
 #include <variant>
 #include "hash.h"
 #include "global.h"
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 
 struct mati_property {
     std::string name = "AAAA";
diff --git a/src/mati.cpp b/src/mati.cpp
index c98583f..52d4510 100644
--- a/src/mati.cpp
+++ b/src/mati.cpp
@@ -4,7 +4,7 @@
 #include "crypto.h"
 #include "util.h"
 #include "file.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <unordered_map>
 #include <fstream>
diff --git a/src/mati.h b/src/mati.h
index c8244c0..5c5745d 100644
--- a/src/mati.h
+++ b/src/mati.h
@@ -5,7 +5,7 @@
 #include <unordered_map>
 #include <cstdint>
 #include "hash.h"
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 
 struct mati_property {
     std::string name = "AAAA";
diff --git a/src/mrtr.cpp b/src/mrtr.cpp
index b0f3a6e..ae3c749 100644
--- a/src/mrtr.cpp
+++ b/src/mrtr.cpp
@@ -4,7 +4,7 @@
 #include "crypto.h"
 #include "util.h"
 #include "file.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include "DirectXMath.h"
 #include <iostream>
 #include <unordered_map>
diff --git a/src/mrtr.h b/src/mrtr.h
index 6181754..8999daf 100644
--- a/src/mrtr.h
+++ b/src/mrtr.h
@@ -5,7 +5,7 @@
 #include <unordered_map>
 #include <cstdint>
 #include "global.h"
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 
 struct mrtr_entry {
     uint32_t index = 0;
diff --git a/src/ores.cpp b/src/ores.cpp
index 8c7d899..122dab4 100644
--- a/src/ores.cpp
+++ b/src/ores.cpp
@@ -2,7 +2,7 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <fstream>
 
 ores::ores() = default;
diff --git a/src/prim.cpp b/src/prim.cpp
index 9d73279..6ac2c36 100644
--- a/src/prim.cpp
+++ b/src/prim.cpp
@@ -4,8 +4,8 @@
 #include "crypto.h"
 #include "util.h"
 #include "borg.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/lz4/lz4hc.h"
+#include <lz4.h>
+#include <lz4hc.h>
 #include <fstream>
 
 prim::prim(uint64_t rpkgs_index, uint64_t hash_index) {
diff --git a/src/rebuild_dlge_from_json_from.cpp b/src/rebuild_dlge_from_json_from.cpp
index 28e13d4..99f4952 100644
--- a/src/rebuild_dlge_from_json_from.cpp
+++ b/src/rebuild_dlge_from_json_from.cpp
@@ -3,17 +3,28 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 #include <iostream>
 #include <chrono>
 #include <sstream>
 #include <fstream>
 #include <regex>
 #include <filesystem>
+#include <TonyTools/Languages.h>
 
 using json = nlohmann::ordered_json;
 
-void rpkg_function::rebuild_dlge_from_json_from(std::string& input_path, std::string& output_path) {
+void rpkg_function::rebuild_dlge_from_json_from(std::string& input_path, std::string& output_path, std::string version) {
+    TonyTools::Language::Version ttVersion = TonyTools::Language::Version::H3;
+    if (version == "HM2") {
+        ttVersion = TonyTools::Language::Version::H2;
+    }
+    else if (version == "HM2016") {
+        ttVersion = TonyTools::Language::Version::H2016;
+    }
+
+    util::load_hmla_hash_list();
+
     task_single_status = TASK_EXECUTING;
 
     std::string input_folder_path = file::parse_input_folder_path(input_path);
@@ -22,11 +33,8 @@ void rpkg_function::rebuild_dlge_from_json_from(std::string& input_path, std::st
         LOG_AND_EXIT("Error: The folder " + input_folder_path + " to rebuild the DLGE files from does not exist.");
     }
 
-    std::vector<std::string> json_file_names;
     std::vector<std::string> json_file_paths;
     std::vector<std::string> json_file_base_paths;
-    std::vector<uint64_t> dlge_hashes;
-    std::vector<std::string> dlge_hash_strings;
     std::vector<std::string> dlge_file_names;
 
     std::chrono::time_point start_time = std::chrono::high_resolution_clock::now();
@@ -100,10 +108,7 @@ void rpkg_function::rebuild_dlge_from_json_from(std::string& input_path, std::st
         if (is_dlge_hash_file) {
             json_file_paths.push_back(entry.path().string());
             json_file_base_paths.push_back(json_file_base_path);
-            json_file_names.push_back(json_file_name);
-            dlge_hashes.push_back(std::strtoll(hash_string.c_str(), nullptr, 16));
             dlge_file_names.push_back(util::to_upper_case(hash_file_name));
-            dlge_hash_strings.push_back(util::to_upper_case(hash_string));
         }
     }
 
@@ -125,245 +130,67 @@ void rpkg_function::rebuild_dlge_from_json_from(std::string& input_path, std::st
             return;
         }
 
-        if (file::path_exists(json_file_paths.at(p) + ".meta")) {
-            std::chrono::time_point end_time = std::chrono::high_resolution_clock::now();
-
-            double time_in_seconds_from_start_time = (0.000000001 *
-                                                      std::chrono::duration_cast<std::chrono::nanoseconds>(
-                                                              end_time - start_time).count());
-
-            if (time_in_seconds_from_start_time > console_update_rate) {
-                start_time = end_time;
-
-                if (period_count > 3) {
-                    period_count = 0;
-                }
-
-                ss.str(std::string());
-
-                ss << "Rebuilding JSON as DLGE" << std::string(period_count, '.');
-
-                timing_string = ss.str();
-
-                LOG_NO_ENDL("\r" << ss.str() << std::string((80 - ss.str().length()), ' '));
-
-                period_count++;
-            }
-
-            std::ifstream input_json_meta_file = std::ifstream(json_file_paths.at(p) + ".meta", std::ifstream::binary);
-
-            if (!input_json_meta_file.good()) {
-                LOG_AND_EXIT("Error: JSON meta file " + json_file_paths.at(p) + ".meta" + " could not be read.");
-            }
-
-            input_json_meta_file.seekg(0, input_json_meta_file.end);
-
-            uint64_t input_json_meta_file_size = input_json_meta_file.tellg();
-
-            input_json_meta_file.seekg(0, input_json_meta_file.beg);
-
-            std::vector<char> input_json_meta(input_json_meta_file_size, 0);
-
-            input_json_meta_file.read(input_json_meta.data(), input_json_meta_file_size);
-
-            input_json_meta_file.close();
-
-            std::ifstream input_json_file(json_file_paths.at(p));
+        std::chrono::time_point end_time = std::chrono::high_resolution_clock::now();
 
-            if (!input_json_file.good()) {
-                LOG_AND_EXIT("Error: JSON file " + json_file_paths.at(p) + " could not be read.");
-            }
+        double time_in_seconds_from_start_time = (0.000000001 *
+                                                    std::chrono::duration_cast<std::chrono::nanoseconds>(
+                                                            end_time - start_time).count());
 
-            json input_json;
+        if (time_in_seconds_from_start_time > console_update_rate) {
+            start_time = end_time;
 
-            try {
-                input_json_file >> input_json;
-            }
-            catch (json::parse_error& e) {
-                std::stringstream ss;
-                ss << "Error: " << json_file_paths.at(p) << "\n"
-                   << "Error message: " << e.what() << '\n'
-                   << "Error exception id: " << e.id << '\n'
-                   << "Error byte position of error: " << e.byte;
-                LOG_AND_EXIT(ss.str());
+            if (period_count > 3) {
+                period_count = 0;
             }
 
-            input_json_file.close();
-
-            int category_language_count = 0;
+            ss.str(std::string());
 
-            for (const auto& it : input_json.items()) {
-                bool language_found = false;
+            ss << "Rebuilding JSON as DLGE" << std::string(period_count, '.');
 
-                if (it.value().contains("Language")) {
-                    language_found = true;
-
-                    category_language_count++;
-                }
-
-                if (!language_found) {
-                    LOG_AND_EXIT("Error: JSON file " + json_file_paths.at(p) +
-                                 " is malformed and can not be rebuilt into a DLGE file/resource.");
-                }
-            }
-
-            std::vector<char> dlge_data;
-
-            char char4[4] = "";
-            uint32_t zerocheck;
+            timing_string = ss.str();
 
-            uint32_t position = 0;
+            LOG_NO_ENDL("\r" << ss.str() << std::string((80 - ss.str().length()), ' '));
 
-            uint32_t number_of_dlge_categories = 0;
+            period_count++;
+        }
 
-            std::memcpy(&number_of_dlge_categories, &input_json_meta.data()[position], sizeof(uint32_t));
-            position += sizeof(uint32_t);
+        std::string inputJson = file::read_file_to_string(json_file_paths.at(p));
 
-            uint32_t number_of_languages = 0;
+        TonyTools::Language::Rebuilt rebuiltDLGE = TonyTools::Language::DLGE::Rebuild(
+            ttVersion,
+            inputJson
+        );
 
-            std::memcpy(&number_of_languages, &input_json_meta.data()[position], sizeof(uint32_t));
-            position += sizeof(uint32_t);
+        if (rebuiltDLGE.file.empty() || rebuiltDLGE.meta.empty()) {
+            LOG_AND_EXIT("Failed to rebuild JSON to DLGE!");
+        }
 
-            if (category_language_count != (number_of_dlge_categories * number_of_languages)) {
-                LOG_AND_EXIT(
-                        "Error: Number of strings in the input DLGE JSON file do not match the number of strings in the meta file.");
-            }
+        std::vector<char> outMeta = json_to_hash_meta(rebuiltDLGE.meta);
 
-            dlge_data.push_back(0x0);
-            dlge_data.push_back(0x0);
-            dlge_data.push_back(0x0);
-            dlge_data.push_back(0x0);
-            dlge_data.push_back(0x1);
-            dlge_data.push_back(0x0);
-            dlge_data.push_back(0x0);
-            dlge_data.push_back(0x0);
-
-            for (uint64_t i = 0; i < number_of_dlge_categories; i++) {
-                dlge_data.push_back(0x1);
-
-                std::memcpy(&char4, &input_json_meta.data()[position], sizeof(uint32_t));
-                position += sizeof(uint32_t);
-
-                for (char& j : char4) {
-                    dlge_data.push_back(j);
-                }
-
-                std::memcpy(&char4, &input_json_meta.data()[position], sizeof(uint32_t));
-                position += sizeof(uint32_t);
-
-                for (char& j : char4) {
-                    dlge_data.push_back(j);
-                }
-
-                dlge_data.push_back(0x0);
-                dlge_data.push_back(0x0);
-                dlge_data.push_back(0x0);
-                dlge_data.push_back(0x0);
-                dlge_data.push_back(static_cast<char>(0xFF));
-                dlge_data.push_back(static_cast<char>(0xFF));
-                dlge_data.push_back(static_cast<char>(0xFF));
-                dlge_data.push_back(static_cast<char>(0xFF));
-                dlge_data.push_back(static_cast<char>(0xFF));
-                dlge_data.push_back(static_cast<char>(0xFF));
-                dlge_data.push_back(static_cast<char>(0xFF));
-                dlge_data.push_back(static_cast<char>(0xFF));
-                dlge_data.push_back(0x0);
-                dlge_data.push_back(0x0);
-                dlge_data.push_back(0x0);
-                dlge_data.push_back(0x0);
-
-                uint32_t key_range_min = static_cast<uint32_t>(i * number_of_languages);
-                uint32_t key_range_max = key_range_min + number_of_languages;
-                uint32_t key_current = 0;
-
-                for (const auto& it : input_json.items()) {
-                    if (key_current >= key_range_min && key_current < key_range_max) {
-                        std::memcpy(&zerocheck, &input_json_meta.data()[position], sizeof(uint32_t));
-
-                        if (zerocheck == 0) {
-                            dlge_data.push_back(0x0);
-                            dlge_data.push_back(0x0);
-                            dlge_data.push_back(0x0);
-                            dlge_data.push_back(0x0);
-
-                            position += 4;
-                        }
-
-                        std::memcpy(&char4, &input_json_meta.data()[position], sizeof(uint32_t));
-                        position += sizeof(uint32_t);
-
-                        for (char& j : char4) {
-                            dlge_data.push_back(j);
-                        }
-
-                        std::memcpy(&char4, &input_json_meta.data()[position], sizeof(uint32_t));
-                        position += sizeof(uint32_t);
-
-                        for (char& j : char4) {
-                            dlge_data.push_back(j);
-                        }
-
-                        std::string temp_string = it.value()["String"];
-
-                        uint32_t string_length = static_cast<uint32_t>(temp_string.length());
-
-                        while (string_length % 8 != 0) {
-                            string_length++;
-
-                            temp_string.push_back(0x0);
-                        }
-
-                        std::memcpy(&char4, &string_length, sizeof(uint32_t));
-
-                        for (char& k : char4) {
-                            dlge_data.push_back(k);
-                        }
-
-                        for (uint32_t k = 0; k < string_length / 8; k++) {
-                            uint32_t data[2];
-                            std::memcpy(data, &temp_string[static_cast<uint64_t>(k) * static_cast<uint64_t>(8)],
-                                        sizeof(uint32_t));
-                            std::memcpy(data + 1, &temp_string[static_cast<uint64_t>(k) * static_cast<uint64_t>(8) +
-                                                               static_cast<uint64_t>(4)], sizeof(uint32_t));
-
-                            crypto::xtea_encrypt_localization(data);
-
-                            std::memcpy(&temp_string[static_cast<uint64_t>(k) * static_cast<uint64_t>(8)], data,
-                                        sizeof(uint32_t));
-                            std::memcpy(&temp_string[static_cast<uint64_t>(k) * static_cast<uint64_t>(8) +
-                                                     static_cast<uint64_t>(4)], data + 1, sizeof(uint32_t));
-                        }
-
-                        for (uint64_t k = 0; k < string_length; k++) {
-                            dlge_data.push_back(temp_string[k]);
-                        }
-                    }
-
-                    key_current++;
-                }
-            }
+        if (outMeta.empty()) {
+            LOG_AND_EXIT("Failed to rebuild JSON to DLGE (meta error)!");
+        }
 
-            for (uint64_t k = 0; k < (input_json_meta_file_size - position); k++) {
-                dlge_data.push_back(input_json_meta.data()[position + k]);
-            }
+        std::string current_path = json_file_base_paths.at(p) + "\\DLGE.rebuilt";
 
-            std::string current_path = json_file_base_paths.at(p) + "\\DLGE.rebuilt";
+        file::create_directories(current_path);
 
-            file::create_directories(current_path);
+        std::ofstream output_file = std::ofstream(current_path + "\\" + dlge_file_names.at(p),
+                                                    std::ofstream::binary);
 
-            std::ofstream output_file = std::ofstream(current_path + "\\" + dlge_file_names.at(p),
-                                                      std::ofstream::binary);
+        std::ofstream output_meta_file = std::ofstream(current_path + "\\" + dlge_file_names.at(p) + ".meta",
+            std::ofstream::binary);
 
-            if (!output_file.good()) {
-                LOG_AND_EXIT("Error: Rebuilt DLGE file " + dlge_file_names.at(p) + " could not be created.");
-            }
+        if (!output_file.good()) {
+            LOG_AND_EXIT("Error: Rebuilt DLGE file " + dlge_file_names.at(p) + " could not be created.");
+        }
 
-            output_file.write(dlge_data.data(), dlge_data.size());
-        } else {
-            LOG("Error: JSON meta file " << json_file_paths.at(p) + ".meta"
-                                         << " could not be found.");
-            LOG("       Can not rebuild " << dlge_file_names.at(p) << " from JSON file " << json_file_paths.at(p));
+        if (!output_meta_file.good()) {
+            LOG_AND_EXIT("Error: Rebuilt DLGE meta file " + dlge_file_names.at(p) + ".meta could not be created.");
         }
+
+        output_file.write(rebuiltDLGE.file.data(), rebuiltDLGE.file.size());
+        output_meta_file.write(outMeta.data(), outMeta.size());
     }
 
     ss.str(std::string());
diff --git a/src/rebuild_locr_from_json_from.cpp b/src/rebuild_locr_from_json_from.cpp
index 62872b3..78750b5 100644
--- a/src/rebuild_locr_from_json_from.cpp
+++ b/src/rebuild_locr_from_json_from.cpp
@@ -3,15 +3,26 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 #include <chrono>
 #include <sstream>
 #include <fstream>
 #include <filesystem>
+#include <TonyTools/Languages.h>
 
 using json = nlohmann::ordered_json;
 
-void rpkg_function::rebuild_locr_from_json_from(std::string& input_path) {
+void rpkg_function::rebuild_locr_from_json_from(std::string& input_path, std::string version) {
+    TonyTools::Language::Version ttVersion = TonyTools::Language::Version::H3;
+    if (version == "HM2") {
+        ttVersion = TonyTools::Language::Version::H2;
+    }
+    else if (version == "HM2016") {
+        ttVersion = TonyTools::Language::Version::H2016;
+    }
+
+    util::load_hmla_hash_list();
+
     task_single_status = TASK_EXECUTING;
 
     std::string input_folder_path = file::parse_input_folder_path(input_path);
@@ -20,11 +31,8 @@ void rpkg_function::rebuild_locr_from_json_from(std::string& input_path) {
         LOG_AND_EXIT("Error: The folder " + input_folder_path + " to rebuild the LOCR files from does not exist.");
     }
 
-    std::vector<std::string> json_file_names;
     std::vector<std::string> json_file_paths;
     std::vector<std::string> json_file_base_paths;
-    std::vector<uint64_t> locr_hashes;
-    std::vector<std::string> locr_hash_strings;
     std::vector<std::string> locr_file_names;
 
     std::chrono::time_point start_time = std::chrono::high_resolution_clock::now();
@@ -98,10 +106,7 @@ void rpkg_function::rebuild_locr_from_json_from(std::string& input_path) {
         if (is_locr_hash_file) {
             json_file_paths.push_back(entry.path().string());
             json_file_base_paths.push_back(json_file_base_path);
-            json_file_names.push_back(json_file_name);
-            locr_hashes.push_back(std::strtoll(hash_string.c_str(), nullptr, 16));
             locr_file_names.push_back(util::to_upper_case(hash_file_name));
-            locr_hash_strings.push_back(util::to_upper_case(hash_string));
         }
     }
 
@@ -146,352 +151,49 @@ void rpkg_function::rebuild_locr_from_json_from(std::string& input_path) {
             period_count++;
         }
 
-        if (!file::path_exists(json_file_paths.at(p) + ".meta")) {
-            LOG("Error: JSON meta file " << json_file_paths.at(p) + ".meta"
-                                         << " could not be found.");
-            LOG("       Can not rebuild " << locr_file_names.at(p) << " from JSON file " << json_file_paths.at(p));
-        }
-
-        std::ifstream input_json_meta_file = std::ifstream(json_file_paths.at(p) + ".meta", std::ifstream::binary);
-
-        if (!input_json_meta_file.good()) {
-            LOG_AND_EXIT("Error: JSON meta file " + json_file_paths.at(p) + ".meta" + " could not be read.");
-        }
-
-        bool isLOCRv2 = false;
-        bool symKey = false;
-        int identifyByte = input_json_meta_file.get();
-
-        if (identifyByte == 0 || identifyByte == 1) {
-            isLOCRv2 = true;
-        }
-
-#ifdef _DEBUG
-        LOG((isLOCRv2 ? "LOCRv2 identified" : "LOCRv1 identified"));
-#endif
-
-        input_json_meta_file.seekg(0, std::ios_base::end);
-
-        uint64_t input_json_meta_file_size = input_json_meta_file.tellg();
-
-        input_json_meta_file.seekg(0, input_json_meta_file.beg);
-
-        if ((isLOCRv2 && (input_json_meta_file_size - 1) % 4 != 0) ||
-            (!isLOCRv2 && input_json_meta_file_size % 4 != 0)) {
-            LOG_AND_EXIT("Error: JSON meta file " + json_file_paths.at(p) + ".meta" + " is corrupt.");
-        }
-
-        std::vector<char> input_json_meta_header(input_json_meta_file_size, 0);
-
-        input_json_meta_file.read(input_json_meta_header.data(), input_json_meta_file_size);
-
-        input_json_meta_file.close();
-
         std::ifstream input_json_file(json_file_paths.at(p));
 
         if (!input_json_file.good()) {
             LOG_AND_EXIT("Error: JSON file " + json_file_paths.at(p) + " could not be read.");
         }
-        json input_json;
-
-        try {
-            input_json_file >> input_json;
-        }
-        catch (json::parse_error& e) {
-            std::stringstream ss;
-            ss << "Error: " << json_file_paths.at(p) << "\n"
-               << "Error message: " << e.what() << '\n'
-               << "Error exception id: " << e.id << '\n'
-               << "Error byte position of error: " << e.byte;
-            LOG_AND_EXIT(ss.str());
-        }
+        
+        std::string inputJson(std::istreambuf_iterator<char>{input_json_file}, {});
 
         input_json_file.close();
 
-        int language_count = 0;
-
-        for (const auto& it : input_json.items()) {
-            bool language_found = false;
-
-            for (const auto& it2 : it.value().items()) {
-                if (it2.value().contains("Language")) {
-                    language_found = true;
-
-                    language_count++;
-                }
-            }
-
-            if (!language_found) {
-                LOG_AND_EXIT("Error: JSON file " + json_file_paths.at(p) +
-                             " is malformed and can not be rebuilt into a LOCR file/resource.");
-            }
-        }
+        TonyTools::Language::Rebuilt rebuiltLocr = TonyTools::Language::LOCR::Rebuild(
+            ttVersion,
+            inputJson
+        );
 
-        std::vector<char> locr_data;
-
-        std::vector<std::string> languages;
-
-        if (input_json_meta_file_size == 0x19) {
-            // Old Hitman 3 LOCR
-            languages.push_back("xx");
-            languages.push_back("en");
-            languages.push_back("fr");
-            languages.push_back("it");
-            languages.push_back("de");
-            languages.push_back("es");
-        } else if (input_json_meta_file_size == 0x25) {
-            // New Hitman 3 LOCR
-            languages.push_back("xx");
-            languages.push_back("en");
-            languages.push_back("fr");
-            languages.push_back("it");
-            languages.push_back("de");
-            languages.push_back("es");
-            languages.push_back("ru");
-            languages.push_back("cn");
-            languages.push_back("tc");
-        } else if (input_json_meta_file_size == 0x29) {
-            // New Hitman 3 LOCR
-            languages.push_back("xx");
-            languages.push_back("en");
-            languages.push_back("fr");
-            languages.push_back("it");
-            languages.push_back("de");
-            languages.push_back("es");
-            languages.push_back("ru");
-            languages.push_back("cn");
-            languages.push_back("tc");
-            languages.push_back("jp");
-        } else if (input_json_meta_file_size == 0x35) {
-            // Hitman 2
-            languages.push_back("xx");
-            languages.push_back("en");
-            languages.push_back("fr");
-            languages.push_back("it");
-            languages.push_back("de");
-            languages.push_back("es");
-            languages.push_back("ru");
-            languages.push_back("mx");
-            languages.push_back("br");
-            languages.push_back("pl");
-            languages.push_back("cn");
-            languages.push_back("jp");
-            languages.push_back("tc");
-        } else if (input_json_meta_file_size == 0x30) {
-            // Hitman 2016 (post GOTY?)
-            languages.push_back("xx");
-            languages.push_back("en");
-            languages.push_back("fr");
-            languages.push_back("it");
-            languages.push_back("de");
-            languages.push_back("es");
-            languages.push_back("ru");
-            languages.push_back("mx");
-            languages.push_back("br");
-            languages.push_back("pl");
-            languages.push_back("cn");
-            languages.push_back("jp");
-        } else if (input_json_meta_file_size == 0x28) {
-            // Hitman 2016 (pre GOTY?)
-            languages.push_back("xx");
-            languages.push_back("en");
-            languages.push_back("fr");
-            languages.push_back("it");
-            languages.push_back("de");
-            languages.push_back("es");
-            languages.push_back("ru");
-            languages.push_back("mx");
-            languages.push_back("br");
-            languages.push_back("pl");
-
-            LOG("Symmetric key cipher identified");
-            symKey = true;
+        if (rebuiltLocr.file.empty() || rebuiltLocr.meta.empty()) {
+            LOG_AND_EXIT("Failed to rebuild JSON to LOCR!");
         }
 
-        std::vector<bool> language_in_locr;
-
-        for (uint64_t i = 0; i < languages.size(); i++) {
-            uint32_t offset = 0;
-
-            std::memcpy(&offset, &input_json_meta_header.data()[isLOCRv2 ? i * 0x4 + 0x1 : i * 0x4],
-                        sizeof(uint32_t));
-
-            if (offset != 0xFFFFFFFF) {
-                language_in_locr.push_back(true);
-            } else {
-                language_in_locr.push_back(false);
-            }
-        }
-
-        if (isLOCRv2)
-            locr_data.push_back(input_json_meta_header.data()[0]);
-
-        uint32_t offset = input_json_meta_file_size;
-        uint32_t prevoffset;
-        char char4[4];
-
-        std::vector<std::vector<uint32_t>> locr_language_section_string_hashes;
-        std::vector<std::vector<std::string>> locr_language_section_strings;
-        std::vector<std::vector<uint32_t>> locr_language_section_string_lengths;
-
-        for (uint64_t i = 0; i < languages.size(); i++) {
-            if (language_in_locr.at(i)) {
-                for (const auto& it : input_json.items()) {
-                    for (const auto& it2 : it.value().items()) {
-                        if (it2.value().contains("Language")) {
-                            if (it2.value()["Language"] == languages.at(i) && language_in_locr.at(i)) {
-                                std::vector<uint32_t> temp_locr_language_section_string_hashes;
-                                std::vector<std::string> temp_locr_language_section_strings;
-                                std::vector<uint32_t> temp_locr_language_section_string_lengths;
-
-                                uint32_t locr_section_size = 0x4;
-
-                                for (const auto& it3 : it.value().items()) {
-                                    if (!it3.value().contains("Language")) {
-                                        temp_locr_language_section_string_hashes.push_back(
-                                                it3.value()["StringHash"]);
-
-                                        std::string temp_string = it3.value()["String"];
-
-                                        uint32_t string_length = static_cast<uint32_t>(temp_string.length());
-
-                                        if (symKey) {
-                                            locr_section_size += static_cast<uint32_t>(temp_string.size()) +
-                                                                 static_cast<uint32_t>(0x9);
-                                        } else {
-                                            while (string_length % 8 != 0) {
-                                                string_length++;
-
-                                                temp_string.push_back(0x0);
-                                            }
-
-                                            locr_section_size += static_cast<uint32_t>(temp_string.size()) +
-                                                                 static_cast<uint32_t>(0x9);
-                                        }
-
-                                        temp_locr_language_section_strings.push_back(temp_string);
-                                        temp_locr_language_section_string_lengths.push_back(
-                                                static_cast<uint32_t>(temp_string.size()));
-                                    }
-                                }
-
-                                prevoffset = offset;
-                                offset += locr_section_size;
-
-                                std::memcpy(&char4, &prevoffset, sizeof(uint32_t));
-
-                                for (char& j : char4) {
-                                    locr_data.push_back(j);
-                                }
-
-                                locr_language_section_string_hashes.push_back(
-                                        temp_locr_language_section_string_hashes);
-                                locr_language_section_strings.push_back(temp_locr_language_section_strings);
-                                locr_language_section_string_lengths.push_back(
-                                        temp_locr_language_section_string_lengths);
-                            } else if (it2.value()["Language"] == languages.at(i) && !language_in_locr.at(i)) {
-                                LOG_AND_EXIT("Error: LOCR has language in JSON but not in the meta file.");
-                            }
-                        }
-                    }
-                }
-            } else {
-                std::vector<uint32_t> temp_locr_language_section_string_hashes;
-                std::vector<std::string> temp_locr_language_section_strings;
-                std::vector<uint32_t> temp_locr_language_section_string_lengths;
-
-                locr_data.push_back(0xFF);
-                locr_data.push_back(0xFF);
-                locr_data.push_back(0xFF);
-                locr_data.push_back(0xFF);
-
-                locr_language_section_string_hashes.push_back(temp_locr_language_section_string_hashes);
-                locr_language_section_strings.push_back(temp_locr_language_section_strings);
-                locr_language_section_string_lengths.push_back(temp_locr_language_section_string_lengths);
-            }
-        }
+        std::string current_path = json_file_base_paths.at(p) + "\\LOCR.rebuilt";
+        std::vector<char> binMeta = json_to_hash_meta(rebuiltLocr.meta);
 
-        for (uint64_t i = 0; i < languages.size(); i++) {
-            for (const auto& it : input_json.items()) {
-                for (const auto& it2 : it.value().items()) {
-                    if (it2.value().contains("Language")) {
-                        if (it2.value()["Language"] == languages.at(i)) {
-                            uint32_t section_string_count = static_cast<uint32_t>(locr_language_section_string_hashes.at(
-                                    i).size());
-
-                            std::memcpy(&char4, &section_string_count, sizeof(uint32_t));
-
-                            for (char& j : char4) {
-                                locr_data.push_back(j);
-                            }
-
-                            for (uint64_t j = 0; j < locr_language_section_strings.at(i).size(); j++) {
-                                std::memcpy(&char4, &locr_language_section_string_hashes.at(i).at(j),
-                                            sizeof(uint32_t));
-
-                                for (char& k : char4) {
-                                    locr_data.push_back(k);
-                                }
-
-                                std::memcpy(&char4, &locr_language_section_string_lengths.at(i).at(j),
-                                            sizeof(uint32_t));
-
-                                for (char& k : char4) {
-                                    locr_data.push_back(k);
-                                }
-
-                                if (symKey) {
-                                    for (uint32_t k = 0; k < locr_language_section_string_lengths.at(i).at(j); k++) {
-                                        locr_data.push_back(crypto::symmetric_key_encrypt_localization(
-                                                locr_language_section_strings.at(i).at(
-                                                        j)[static_cast<uint64_t>(k)]));
-                                    }
-                                } else {
-                                    for (uint32_t k = 0;
-                                         k < locr_language_section_string_lengths.at(i).at(j) / 8; k++) {
-                                        uint32_t data[2];
-                                        std::memcpy(data, &locr_language_section_strings.at(i).at(j)[
-                                                            static_cast<uint64_t>(k) * static_cast<uint64_t>(8)],
-                                                    sizeof(uint32_t));
-                                        std::memcpy(data + 1, &locr_language_section_strings.at(i).at(j)[
-                                                static_cast<uint64_t>(k) * static_cast<uint64_t>(8) +
-                                                static_cast<uint64_t>(4)], sizeof(uint32_t));
-
-                                        crypto::xtea_encrypt_localization(data);
-
-                                        std::memcpy(&locr_language_section_strings.at(i).at(j)[
-                                                            static_cast<uint64_t>(k) * static_cast<uint64_t>(8)], data,
-                                                    sizeof(uint32_t));
-                                        std::memcpy(&locr_language_section_strings.at(i).at(j)[
-                                                static_cast<uint64_t>(k) * static_cast<uint64_t>(8) +
-                                                static_cast<uint64_t>(4)], data + 1, sizeof(uint32_t));
-                                    }
-
-                                    for (uint64_t k = 0; k < locr_language_section_string_lengths.at(i).at(j); k++) {
-                                        locr_data.push_back(locr_language_section_strings.at(i).at(j)[k]);
-                                    }
-                                }
-
-                                locr_data.push_back(0x0);
-                            }
-                        }
-                    }
-                }
-            }
+        if (binMeta.empty()) {
+            LOG_AND_EXIT("Failed to rebuild JSON to LOCR (meta issue).");
         }
 
-        std::string current_path = json_file_base_paths.at(p) + "\\LOCR.rebuilt";
-
         file::create_directories(current_path);
 
         std::ofstream output_file = std::ofstream(current_path + "\\" + locr_file_names.at(p),
                                                   std::ofstream::binary);
 
+        std::ofstream output_meta_file = std::ofstream(current_path + "\\" + locr_file_names.at(p) + ".meta", std::ofstream::binary);
+
         if (!output_file.good()) {
             LOG_AND_EXIT("Error: Rebuilt LOCR file " + locr_file_names.at(p) + " could not be created.");
         }
 
-        output_file.write(locr_data.data(), locr_data.size());
+        if (!output_meta_file.good()) {
+            LOG_AND_EXIT("Error: Rebuilt LOCR meta file " + locr_file_names.at(p) + ".meta could not be created.");
+        }
+
+        output_file.write(rebuiltLocr.file.data(), rebuiltLocr.file.size());
+        output_meta_file.write(binMeta.data(), binMeta.size());
     }
 
     ss.str(std::string());
diff --git a/src/rebuild_prim_in.cpp b/src/rebuild_prim_in.cpp
index f5c16c7..95e292f 100644
--- a/src/rebuild_prim_in.cpp
+++ b/src/rebuild_prim_in.cpp
@@ -4,9 +4,9 @@
 #include "console.h"
 #include "util.h"
 #include "prim.h"
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 #include "thirdparty/mikktspace/mikktspace.h"
-#include "thirdparty/directxmath/DirectXMath.h"
+#include <DirectXMath.h>
 #include <GLTFSDK/GLTF.h>
 #include <GLTFSDK/GLTFResourceReader.h>
 #include <GLTFSDK/GLBResourceReader.h>
diff --git a/src/rebuild_rtlv_from_json_from.cpp b/src/rebuild_rtlv_from_json_from.cpp
index 51f151c..cf42f13 100644
--- a/src/rebuild_rtlv_from_json_from.cpp
+++ b/src/rebuild_rtlv_from_json_from.cpp
@@ -3,16 +3,27 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 #include <chrono>
 #include <sstream>
 #include <fstream>
 #include <regex>
 #include <filesystem>
+#include <TonyTools/Languages.h>
 
 using json = nlohmann::ordered_json;
 
-void rpkg_function::rebuild_rtlv_from_json_from(std::string& input_path) {
+void rpkg_function::rebuild_rtlv_from_json_from(std::string& input_path, std::string version) {
+    TonyTools::Language::Version ttVersion = TonyTools::Language::Version::H3;
+    if (version == "HM2") {
+        ttVersion = TonyTools::Language::Version::H2;
+    }
+    else if (version == "HM2016") {
+        ttVersion = TonyTools::Language::Version::H2016;
+    }
+
+    util::load_hmla_hash_list();
+
     task_single_status = TASK_EXECUTING;
 
     std::string input_folder_path = file::parse_input_folder_path(input_path);
@@ -21,11 +32,8 @@ void rpkg_function::rebuild_rtlv_from_json_from(std::string& input_path) {
         LOG_AND_EXIT("Error: The folder " + input_folder_path + " to rebuild the RTLV files from does not exist.");
     }
 
-    std::vector<std::string> json_file_names;
     std::vector<std::string> json_file_paths;
     std::vector<std::string> json_file_base_paths;
-    std::vector<uint64_t> rtlv_hashes;
-    std::vector<std::string> rtlv_hash_strings;
     std::vector<std::string> rtlv_file_names;
 
     std::chrono::time_point start_time = std::chrono::high_resolution_clock::now();
@@ -100,10 +108,7 @@ void rpkg_function::rebuild_rtlv_from_json_from(std::string& input_path) {
         if (is_rtlv_hash_file) {
             json_file_paths.push_back(entry.path().string());
             json_file_base_paths.push_back(json_file_base_path);
-            json_file_names.push_back(json_file_name);
-            rtlv_hashes.push_back(std::strtoll(hash_string.c_str(), nullptr, 16));
             rtlv_file_names.push_back(util::to_upper_case(hash_file_name));
-            rtlv_hash_strings.push_back(util::to_upper_case(hash_string));
         }
     }
 
@@ -125,12 +130,6 @@ void rpkg_function::rebuild_rtlv_from_json_from(std::string& input_path) {
             return;
         }
 
-        if (!file::path_exists(json_file_paths.at(p) + ".meta")) {
-            LOG("Error: JSON meta file " << json_file_paths.at(p) + ".meta" << " could not be found.");
-            LOG("       Can not rebuild " << rtlv_file_names.at(p) << " from JSON file " << json_file_paths.at(p));
-            continue;
-        }
-
         std::chrono::time_point end_time = std::chrono::high_resolution_clock::now();
 
         double time_in_seconds_from_start_time = (0.000000001 *
@@ -155,223 +154,21 @@ void rpkg_function::rebuild_rtlv_from_json_from(std::string& input_path) {
             period_count++;
         }
 
-        std::ifstream input_json_meta_file = std::ifstream(json_file_paths.at(p) + ".meta",
-                                                           std::ifstream::binary);
-
-        if (!input_json_meta_file.good()) {
-            LOG_AND_EXIT("Error: JSON meta file " + json_file_paths.at(p) + ".meta" + " could not be read.");
-        }
-
-        input_json_meta_file.seekg(0, std::ifstream::end);
-
-        uint64_t input_json_meta_file_size = input_json_meta_file.tellg();
+        std::string inputJson = file::read_file_to_string(json_file_paths.at(p));
 
-        input_json_meta_file.seekg(0, std::ifstream::beg);
+        TonyTools::Language::Rebuilt rebuiltRTLV = TonyTools::Language::RTLV::Rebuild(
+            ttVersion,
+            inputJson
+        );
 
-        std::vector<char> input_json_meta(input_json_meta_file_size, 0);
-
-        input_json_meta_file.read(input_json_meta.data(), input_json_meta_file_size);
-
-        input_json_meta_file.close();
-
-        std::ifstream input_json_file(json_file_paths.at(p));
-
-        if (!input_json_file.good()) {
-            LOG_AND_EXIT("Error: JSON file " + json_file_paths.at(p) + " could not be read.");
+        if (rebuiltRTLV.file.empty() || rebuiltRTLV.meta.empty()) {
+            LOG_AND_EXIT("Failed to rebuild JSON to RTLV!");
         }
 
-        json input_json;
+        std::vector<char> outMeta = json_to_hash_meta(rebuiltRTLV.meta);
 
-        try {
-            input_json_file >> input_json;
-        }
-        catch (json::parse_error& e) {
-            std::stringstream ss;
-            ss << "Error: " << json_file_paths.at(p) << "\n" << "Error message: " << e.what() << '\n'
-               << "Error exception id: " << e.id << '\n' << "Error byte position of error: " << e.byte;
-            LOG_AND_EXIT(ss.str());
-        }
-
-        input_json_file.close();
-
-        int language_count = 0;
-
-        for (const auto& it : input_json.items()) {
-            bool language_found = false;
-
-            if (it.value().contains("Language")) {
-                language_found = true;
-
-                language_count++;
-            }
-
-            if (!language_found) {
-                LOG_AND_EXIT("Error: JSON file " + json_file_paths.at(p) +
-                             " is malformed and can not be rebuilt into a RTLV file/resource.");
-            }
-        }
-
-        std::vector<char> rtlv_data;
-
-        char char4[4] = "";
-        char char8[8] = "";
-
-        uint32_t position = 0;
-
-        std::memcpy(&char8, &input_json_meta[position], sizeof(uint64_t));
-        position += sizeof(uint64_t);
-
-        for (char j : char8) {
-            rtlv_data.push_back(j);
-        }
-
-        rtlv_data.push_back(0x0);
-        rtlv_data.push_back(0x0);
-        rtlv_data.push_back(0x0);
-        rtlv_data.push_back(0x0);
-
-        uint32_t rtlv_header_data_size = 0;
-
-        std::memcpy(&rtlv_header_data_size, &input_json_meta[position], sizeof(uint32_t));
-        position += sizeof(uint32_t);
-
-        for (uint64_t j = 0; j < rtlv_header_data_size; j++) {
-            rtlv_data.push_back(input_json_meta[position]);
-            position += 0x1;
-        }
-
-        uint32_t number_of_languages = 0;
-
-        std::memcpy(&number_of_languages, &input_json_meta[position], sizeof(uint32_t));
-        position += sizeof(uint32_t);
-
-        if (language_count != number_of_languages) {
-            LOG_AND_EXIT(
-                    "Error: Number of language in the input RTLV JSON file do not match the number of languages in the meta file.");
-        }
-
-        std::memcpy(&char4, &number_of_languages, sizeof(uint32_t));
-
-        for (char j : char4) {
-            rtlv_data.push_back(j);
-        }
-
-        std::vector<std::string> language_strings;
-
-        uint32_t offset =
-                (uint32_t) rtlv_data.size() + (uint32_t) number_of_languages * (uint32_t) 0x10 - (uint32_t) 0xC;
-
-        for (uint64_t i = 0; i < number_of_languages; i++) {
-            uint32_t key = 0;
-
-            for (const auto& it : input_json.items()) {
-                if (key == i) {
-                    std::string temp_string = it.value()["String"];
-
-                    uint32_t string_length = (uint32_t) temp_string.length();
-
-                    while (string_length % 8 != 0) {
-                        string_length++;
-
-                        temp_string.push_back(0x0);
-                    }
-
-                    uint32_t string_length_value = string_length | 0x40000000;
-
-                    std::memcpy(&char4, &string_length_value, sizeof(uint32_t));
-
-                    for (char k : char4) {
-                        rtlv_data.push_back(k);
-                    }
-
-                    rtlv_data.push_back(0x0);
-                    rtlv_data.push_back(0x0);
-                    rtlv_data.push_back(0x0);
-                    rtlv_data.push_back(0x0);
-
-                    std::memcpy(&char4, &offset, sizeof(uint32_t));
-
-                    for (char k : char4) {
-                        rtlv_data.push_back(k);
-                    }
-
-                    rtlv_data.push_back(0x0);
-                    rtlv_data.push_back(0x0);
-                    rtlv_data.push_back(0x0);
-                    rtlv_data.push_back(0x0);
-
-                    if (string_length == 0x0) {
-                        offset += (uint32_t) 0x4 + (uint32_t) string_length + (uint32_t) 0x4;
-                    } else {
-                        offset += (uint32_t) 0x4 + (uint32_t) string_length;
-                    }
-                }
-
-                key++;
-            }
-        }
-
-        for (uint64_t i = 0; i < number_of_languages; i++) {
-            uint32_t key = 0;
-
-            for (const auto& it : input_json.items()) {
-                if (key == i) {
-                    std::string temp_string = it.value()["String"];
-
-                    uint32_t string_length = (uint32_t) temp_string.length();
-
-                    while (string_length % 8 != 0) {
-                        string_length++;
-
-                        temp_string.push_back(0x0);
-                    }
-
-                    std::memcpy(&char4, &string_length, sizeof(uint32_t));
-
-                    for (char k : char4) {
-                        rtlv_data.push_back(k);
-                    }
-
-                    if (string_length == 0x0) {
-                        rtlv_data.push_back(0x0);
-                        rtlv_data.push_back(0x0);
-                        rtlv_data.push_back(0x0);
-                        rtlv_data.push_back(0x0);
-                    }
-
-                    for (uint32_t k = 0; k < string_length / 8; k++) {
-                        uint32_t data[2];
-                        std::memcpy(data, &temp_string[(uint64_t) k * (uint64_t) 8], sizeof(uint32_t));
-                        std::memcpy(data + 1, &temp_string[(uint64_t) k * (uint64_t) 8 + (uint64_t) 4],
-                                    sizeof(uint32_t));
-
-                        crypto::xtea_encrypt_localization(data);
-
-                        std::memcpy(&temp_string[(uint64_t) k * (uint64_t) 8], data, sizeof(uint32_t));
-                        std::memcpy(&temp_string[(uint64_t) k * (uint64_t) 8 + (uint64_t) 4], data + 1,
-                                    sizeof(uint32_t));
-                    }
-
-                    for (uint64_t k = 0; k < string_length; k++) {
-                        rtlv_data.push_back(temp_string[k]);
-                    }
-                }
-
-                key++;
-            }
-        }
-
-        uint32_t file_size = (uint32_t) rtlv_data.size() - (uint32_t) 0x10;
-
-        std::memcpy(&char4, &file_size, sizeof(uint32_t));
-
-        rtlv_data.at(0x8) = char4[3];
-        rtlv_data.at(0x9) = char4[2];
-        rtlv_data.at(0xA) = char4[1];
-        rtlv_data.at(0xB) = char4[0];
-
-        for (uint64_t k = 0; k < (input_json_meta_file_size - position); k++) {
-            rtlv_data.push_back(input_json_meta[position + k]);
+        if (outMeta.empty()) {
+            LOG_AND_EXIT("Failed to rebuild JSON to RTLV (meta error)!");
         }
 
         std::string current_path = json_file_base_paths.at(p) + "\\RTLV.rebuilt";
@@ -381,11 +178,19 @@ void rpkg_function::rebuild_rtlv_from_json_from(std::string& input_path) {
         std::ofstream output_file = std::ofstream(current_path + "\\" + rtlv_file_names.at(p),
                                                   std::ofstream::binary);
 
+        std::ofstream output_meta_file = std::ofstream(current_path + "\\" + rtlv_file_names.at(p) + ".meta",
+            std::ofstream::binary);
+
         if (!output_file.good()) {
             LOG_AND_EXIT("Error: Rebuilt RTLV file " + rtlv_file_names.at(p) + " could not be created.");
         }
 
-        output_file.write(rtlv_data.data(), rtlv_data.size());
+        if (!output_meta_file.good()) {
+            LOG_AND_EXIT("Error: Rebuilt RTLV meta file " + rtlv_file_names.at(p) + ".meta could not be created.");
+        }
+
+        output_file.write(rebuiltRTLV.file.data(), rebuiltRTLV.file.size());
+        output_meta_file.write(outMeta.data(), outMeta.size());
     }
 
     ss.str(std::string());
diff --git a/src/rebuild_text.cpp b/src/rebuild_text.cpp
index 057748e..720d352 100644
--- a/src/rebuild_text.cpp
+++ b/src/rebuild_text.cpp
@@ -3,7 +3,7 @@
 #include "global.h"
 #include "util.h"
 #include "gpudevice.h"
-#include "thirdparty/directxtex/DirectXTex.h"
+#include <DirectXTex.h>
 #include <iostream>
 #include <fstream>
 #include <filesystem>
diff --git a/src/repo.cpp b/src/repo.cpp
index 536b130..3e868ed 100644
--- a/src/repo.cpp
+++ b/src/repo.cpp
@@ -2,7 +2,7 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <unordered_map>
 #include <fstream>
 #include <sstream>
diff --git a/src/repo.h b/src/repo.h
index e6af4cd..5a521b6 100644
--- a/src/repo.h
+++ b/src/repo.h
@@ -4,7 +4,7 @@
 #include <unordered_map>
 #include <set>
 #include <cstdint>
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 #include "ores.h"
 
 enum REPOCategory {
diff --git a/src/rpkg_function.h b/src/rpkg_function.h
index 4ae8bba..89f8fd1 100644
--- a/src/rpkg_function.h
+++ b/src/rpkg_function.h
@@ -62,7 +62,7 @@ class rpkg_function {
     extract_mati_to_json(std::string& input_path, const std::string& filter, const std::string& output_path);
 
     static void search_localization(std::string& input_path, std::string& search, std::string& output_path,
-                                    bool search_dlge, bool search_locr, bool search_rtlv, int max_results);
+                                    bool search_dlge, bool search_locr, bool search_rtlv, int max_results, std::string version);
 
     static void search_entities(std::string& input_path,
                                 char** search_strings,
@@ -84,7 +84,7 @@ class rpkg_function {
 
     static uint32_t get_latest_hash(uint64_t hash_value);
 
-    static void json_to_hash_meta(std::string& input_path);
+    static std::vector<char> json_to_hash_meta(std::string& json_string);
 
     static void hash_meta_to_json(std::string& input_path);
 
@@ -149,20 +149,20 @@ class rpkg_function {
 
     static void hash_depends(std::string& input_path, std::string& filter);
 
-    static void rebuild_rtlv_from_json_from(std::string& input_path);
+    static void rebuild_rtlv_from_json_from(std::string& input_path, std::string version);
 
-    static void rebuild_locr_from_json_from(std::string& input_path);
+    static void rebuild_locr_from_json_from(std::string& input_path, std::string version);
 
-    static void rebuild_dlge_from_json_from(std::string& input_path, std::string& output_path);
+    static void rebuild_dlge_from_json_from(std::string& input_path, std::string& output_path, std::string version);
 
     static void extract_rtlv_to_json_from(std::string& input_path, std::string& filter, std::string& output_path,
-                                          bool output_to_string);
+                                          bool output_to_string, std::string version);
 
     static void extract_locr_to_json_from(std::string& input_path, std::string& filter, std::string& output_path,
-                                          bool output_to_string);
+                                          bool output_to_string, std::string version);
 
     static void extract_dlge_to_json_from(std::string& input_path, std::string& filter, std::string& output_path,
-                                          bool output_to_string);
+                                          bool output_to_string, std::string version, bool hexPrecision = false);
 
     static void generate_rpkg_from(std::string& input_path, std::string& output_path, bool increased_compression);
 
diff --git a/src/sdef.cpp b/src/sdef.cpp
index 66dbc84..fb0b5dd 100644
--- a/src/sdef.cpp
+++ b/src/sdef.cpp
@@ -5,7 +5,7 @@
 #include "console.h"
 #include "util.h"
 #include "file.h"
-#include "thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <fstream>
 #include <sstream>
diff --git a/src/sdef.h b/src/sdef.h
index f13817e..dc9f592 100644
--- a/src/sdef.h
+++ b/src/sdef.h
@@ -5,7 +5,7 @@
 #include <unordered_map>
 #include <cstdint>
 #include "hash.h"
-#include "thirdparty/json/json.hpp"
+#include <nlohmann/json.hpp>
 
 class sdef {
 public:
diff --git a/src/search_localization.cpp b/src/search_localization.cpp
index 38fe901..6df1eef 100644
--- a/src/search_localization.cpp
+++ b/src/search_localization.cpp
@@ -6,8 +6,123 @@
 #include <chrono>
 #include <sstream>
 
+void add_search_result(rpkg& rpkg, uint32_t hash_index, std::string& data) {
+    localization_search_results += rpkg.rpkg_file_path + "||||" +
+        util::uint64_t_to_hex_string(rpkg.hash.at(hash_index).hash_value) +
+            "." + rpkg.hash.at(hash_index).hash_resource_type + " " +
+        util::hash_to_ioi_string(rpkg.hash.at(hash_index).hash_value, false) + "||||" +
+        data + "||||||";
+}
+
+uint32_t search_dlge_container(
+    json container,
+    rpkg& rpkg,
+    uint32_t hash_index,
+    std::string search_term
+) {
+    uint32_t results_count = 0;
+    json type = container.at("type");
+    if (util::to_lower_case(type.get<std::string>()).find(search_term) != std::string::npos) {
+        add_search_result(rpkg, hash_index, type.get<std::string>());
+        results_count++;
+    }
+
+    switch (type.get<DLGE_Type>()) {
+        case DLGE_Type::eDEIT_WavFile: {
+            // God I hate this.
+            if (util::to_lower_case(container.at("wavName").get<std::string>()).find(search_term) != std::string::npos) {
+                add_search_result(rpkg, hash_index, container.at("wavName").get<std::string>());
+                return ++results_count;
+            }
+
+            if (util::to_lower_case(container.at("soundtag").get<std::string>()).find(search_term) != std::string::npos) {
+                add_search_result(rpkg, hash_index, container.at("soundtag").get<std::string>());
+                return ++results_count;
+            }
+
+            if (util::to_lower_case(container.at("defaultWav").get<std::string>()).find(search_term) != std::string::npos) {
+                add_search_result(rpkg, hash_index, container.at("defaultWav").get<std::string>());
+                return ++results_count;
+            }
+
+            if (util::to_lower_case(container.at("defaultFfx").get<std::string>()).find(search_term) != std::string::npos) {
+                add_search_result(rpkg, hash_index, container.at("defaultFfx").get<std::string>());
+                return ++results_count;
+            }
+
+            for (const auto &[lang, entry] : container.at("languages").items()) {
+                if (entry.is_object()) {
+                    if (util::to_lower_case(entry.at("wav").get<std::string>()).find(search_term) != std::string::npos) {
+                        add_search_result(rpkg, hash_index, entry.at("wav").get<std::string>());
+                        results_count++;
+                    }
+
+                    if (util::to_lower_case(entry.at("ffx").get<std::string>()).find(search_term) != std::string::npos) {
+                        add_search_result(rpkg, hash_index, entry.at("ffx").get<std::string>());
+                        results_count++;
+                    }
+
+                    if (entry.contains("subtitle")) {
+                        if (util::to_lower_case(entry.at("subtitle").get<std::string>()).find(search_term) != std::string::npos) {
+                            add_search_result(rpkg, hash_index, lang + ": " + entry.at("subtitle").get<std::string>());
+                            results_count++;
+                        }
+                    }
+                } else {
+                    if (util::to_lower_case(entry.get<std::string>()).find(search_term) != std::string::npos) {
+                        add_search_result(rpkg, hash_index, lang + ": " + entry.get<std::string>());
+                        results_count++;
+                    }
+                }
+            }
+
+            return results_count;
+        }
+        case DLGE_Type::eDEIT_RandomContainer: {
+            // Types are already searched at the top so all we need to do is process wavfiles.
+            for (const json &childContainer : container.at("containers")) {
+                results_count += search_dlge_container(childContainer, rpkg, hash_index, search_term);
+            }
+
+            return results_count;
+        }
+        case DLGE_Type::eDEIT_SwitchContainer: {
+            if (util::to_lower_case(container.at("switchKey")).find(search_term) != std::string::npos) {
+                add_search_result(rpkg, hash_index, container.at("switchKey").get<std::string>());
+                results_count++;
+            }
+
+            if (util::to_lower_case(container.at("default")).find(search_term) != std::string::npos) {
+                add_search_result(rpkg, hash_index, container.at("default").get<std::string>());
+                results_count++;
+            }
+
+            for (const json &childContainer : container.at("containers")) {
+                for (const json &sCase : childContainer.at("cases")) {
+                    if (util::to_lower_case(sCase.get<std::string>()).find(search_term) != std::string::npos) {
+                        add_search_result(rpkg, hash_index, sCase.get<std::string>());
+                        results_count++;
+                    }
+                }
+
+                results_count += search_dlge_container(childContainer, rpkg, hash_index, search_term);
+            }
+
+            return results_count;
+        }
+        case DLGE_Type::eDEIT_SequenceContainer: {
+            // Already checked the type, now to process the containers.
+            for (const json& childContainer : container.at("containers")) {
+                results_count += search_dlge_container(childContainer, rpkg, hash_index, search_term);
+            }
+
+            return results_count;
+        }
+    }
+}
+
 void rpkg_function::search_localization(std::string& input_path, std::string& search, std::string& output_path,
-                                        bool search_dlge, bool search_locr, bool search_rtlv, int max_results) {
+                                        bool search_dlge, bool search_locr, bool search_rtlv, int max_results, std::string version) {
     task_single_status = TASK_EXECUTING;
     task_multiple_status = TASK_EXECUTING;
 
@@ -19,11 +134,9 @@ void rpkg_function::search_localization(std::string& input_path, std::string& se
 
     uint32_t results_count = 0;
 
-    std::string search_lower_case = util::to_lower_case(search);
+    std::string search_upper_case = util::to_upper_case(search);
 
-    uint32_t search_crc32_dec = std::strtoul(search.c_str(), nullptr, 10);
-
-    uint32_t search_crc32_hex = std::strtoul(search.c_str(), nullptr, 16);
+    std::string search_lower_case = util::to_lower_case(search);
 
     std::chrono::time_point start_time = std::chrono::high_resolution_clock::now();
     int stringstream_length = 80;
@@ -113,40 +226,15 @@ void rpkg_function::search_localization(std::string& input_path, std::string& se
                                 localization_hash_count_current++;
 
                                 rpkg_function::extract_dlge_to_json_from(rpkg.rpkg_file_path, temp_hash_string,
-                                                                         output_path, true);
+                                                                         output_path, true, version);
 
                                 try {
-                                    for (const auto& it : localization_json.items()) {
-                                        for (const auto& it2 : it.value().items()) {
-                                            //std::cout << " RLTV3: " << it.key() << ", " << it.value() << std::endl;
-                                            //std::cout << "SEARCHING lol2: " << it.key() << std::endl;
-                                            if (it2.value().is_string()) {
-                                                //std::cout << "SEARCHING s: " << it.key() << std::endl;
-                                                if (util::to_lower_case(std::string(it2.value())).find(
-                                                        search_lower_case) != std::string::npos) {
-                                                    std::cout << "FOUND STRING: " << it2.key() << ", " << it2.value()
-                                                              << " in " << util::uint64_t_to_hex_string(
-                                                            rpkg.hash.at(hash_index).hash_value) + "." +
-                                                                           rpkg.hash.at(hash_index).hash_resource_type
-                                                              << std::endl;
-
-                                                    localization_search_results += rpkg.rpkg_file_path + "||||" +
-                                                                                   util::uint64_t_to_hex_string(
-                                                                                           rpkg.hash.at(
-                                                                                                   hash_index).hash_value) +
-                                                                                   "." + rpkg.hash.at(
-                                                            hash_index).hash_resource_type + " " +
-                                                                                   util::hash_to_ioi_string(
-                                                                                           rpkg.hash.at(
-                                                                                                   hash_index).hash_value,
-                                                                                           false) + "||||" +
-                                                                                   std::string(it2.value()) + "||||||";
-
-                                                    results_count++;
-                                                }
-                                            }
-                                        }
-                                    }
+                                    results_count += search_dlge_container(
+                                        localization_json.at("rootContainer"),
+                                        rpkg,
+                                        hash_index,
+                                        search_lower_case
+                                    );
                                 }
                                 catch (json::parse_error& e) {
                                     std::stringstream ss;
@@ -179,67 +267,18 @@ void rpkg_function::search_localization(std::string& input_path, std::string& se
                                 localization_hash_count_current++;
 
                                 rpkg_function::extract_locr_to_json_from(rpkg.rpkg_file_path, temp_hash_string,
-                                                                         output_path, true);
+                                                                         output_path, true, version);
 
                                 try {
-                                    for (const auto& it : localization_json.items()) {
-                                        bool language_found = false;
-
-                                        std::string language;
-
-                                        for (const auto& it2 : it.value().items()) {
-                                            if (it2.value().contains("Language")) {
-                                                language_found = true;
+                                    for (const auto &[lang, strings] : localization_json.at("languages").items()) {
+                                        for (const auto &[hash, string] : strings.items()) {
+                                            if (
+                                                hash.find(search_upper_case) != std::string::npos ||
+                                                util::to_lower_case(string.get<std::string>()).find(search_lower_case) != std::string::npos
+                                            ) {
+                                                add_search_result(rpkg, hash_index, lang + ": " + hash + ": " + string.get<std::string>());
 
-                                                language = it2.value()["Language"];
-                                            }
-                                        }
-
-                                        if (language_found) {
-                                            for (const auto& it2 : it.value().items()) {
-                                                if (it2.value().contains("StringHash") &&
-                                                    it2.value().contains("String")) {
-                                                    if ((uint32_t) it2.value()["StringHash"] == search_crc32_dec ||
-                                                        (uint32_t) it2.value()["StringHash"] == search_crc32_hex) {
-                                                        localization_search_results += rpkg.rpkg_file_path + "||||" +
-                                                                                       util::uint64_t_to_hex_string(
-                                                                                               rpkg.hash.at(
-                                                                                                       hash_index).hash_value) +
-                                                                                       "." + rpkg.hash.at(
-                                                                hash_index).hash_resource_type + " " +
-                                                                                       util::hash_to_ioi_string(
-                                                                                               rpkg.hash.at(
-                                                                                                       hash_index).hash_value,
-                                                                                               false) + "||||" +
-                                                                                       language + ": " +
-                                                                                       util::uint32_t_to_string(
-                                                                                               it2.value()["StringHash"]) +
-                                                                                       ": " + std::string(
-                                                                it2.value()["String"]) + "||||||";
-
-                                                        results_count++;
-                                                    } else if (util::to_lower_case(
-                                                            std::string(it2.value()["String"])).find(
-                                                            search_lower_case) != std::string::npos) {
-                                                        localization_search_results += rpkg.rpkg_file_path + "||||" +
-                                                                                       util::uint64_t_to_hex_string(
-                                                                                               rpkg.hash.at(
-                                                                                                       hash_index).hash_value) +
-                                                                                       "." + rpkg.hash.at(
-                                                                hash_index).hash_resource_type + " " +
-                                                                                       util::hash_to_ioi_string(
-                                                                                               rpkg.hash.at(
-                                                                                                       hash_index).hash_value,
-                                                                                               false) + "||||" +
-                                                                                       language + ": " +
-                                                                                       util::uint32_t_to_string(
-                                                                                               it2.value()["StringHash"]) +
-                                                                                       ": " + std::string(
-                                                                it2.value()["String"]) + "||||||";
-
-                                                        results_count++;
-                                                    }
-                                                }
+                                                results_count++;
                                             }
                                         }
                                     }
@@ -275,33 +314,14 @@ void rpkg_function::search_localization(std::string& input_path, std::string& se
                                 localization_hash_count_current++;
 
                                 rpkg_function::extract_rtlv_to_json_from(rpkg.rpkg_file_path, temp_hash_string,
-                                                                         output_path, true);
+                                                                         output_path, true, version);
 
                                 try {
-                                    for (const auto& it : localization_json.items()) {
-                                        for (const auto& it2 : it.value().items()) {
-                                            //std::cout << " RLTV3: " << it.key() << ", " << it.value() << std::endl;
-                                            //std::cout << "SEARCHING lol2: " << it.key() << std::endl;
-                                            if (it2.value().is_string() &&
-                                                util::to_lower_case(std::string(it2.value())).find(search_lower_case) !=
-                                                std::string::npos) {
-                                                std::cout << "FOUND STRING: " << it2.key() << ", " << it2.value()
-                                                          << " in " << util::uint64_t_to_hex_string(
-                                                        rpkg.hash.at(hash_index).hash_value) + "." +
-                                                                       rpkg.hash.at(hash_index).hash_resource_type
-                                                          << std::endl;
-
-                                                localization_search_results += rpkg.rpkg_file_path + "||||" +
-                                                                               util::uint64_t_to_hex_string(
-                                                                                       rpkg.hash.at(
-                                                                                               hash_index).hash_value) +
-                                                                               "." + rpkg.hash.at(
-                                                        hash_index).hash_resource_type + " " + util::hash_to_ioi_string(
-                                                        rpkg.hash.at(hash_index).hash_value, false) + "||||" +
-                                                                               std::string(it2.value()) + "||||||";
+                                    for (const auto &[lang, string] : localization_json.at("subtitles").items()) {
+                                        if (util::to_lower_case(string.get<std::string>()).find(search_lower_case) != std::string::npos) {
+                                            add_search_result(rpkg, hash_index, lang + ": " + string.get<std::string>());
 
-                                                results_count++;
-                                            }
+                                            results_count++;
                                         }
                                     }
                                 }
diff --git a/src/task.cpp b/src/task.cpp
index b7ea36d..1de2590 100644
--- a/src/task.cpp
+++ b/src/task.cpp
@@ -8,6 +8,7 @@
 #include "map.h"
 #include <string>
 #include <vector>
+#include <fstream>
 
 void task::execute(std::string& command, std::string& input_path, std::string& filter, std::string& search,
                    std::string& search_type, std::string& output_path) {
@@ -73,11 +74,11 @@ void task::execute(std::string& command, std::string& input_path, std::string& f
     } else if (command == "-extract_wwev_to_ogg_from") {
         rpkg_function::extract_wwev_to_ogg_from(input_path, filter, output_path);
     } else if (command == "-extract_dlge_to_json_from") {
-        rpkg_function::extract_dlge_to_json_from(input_path, filter, output_path, false);
+        rpkg_function::extract_dlge_to_json_from(input_path, filter, output_path, false, search, search_type == "hex_precision");
     } else if (command == "-extract_locr_to_json_from") {
-        rpkg_function::extract_locr_to_json_from(input_path, filter, output_path, false);
+        rpkg_function::extract_locr_to_json_from(input_path, filter, output_path, false, search);
     } else if (command == "-extract_rtlv_to_json_from") {
-        rpkg_function::extract_rtlv_to_json_from(input_path, filter, output_path, false);
+        rpkg_function::extract_rtlv_to_json_from(input_path, filter, output_path, false, search);
     } else if (command == "-generate_rpkg_from") {
         rpkg_function::generate_rpkg_from(input_path, output_path, true);
     } else if (command == "-generate_rpkg_quickly_from") {
@@ -114,11 +115,11 @@ void task::execute(std::string& command, std::string& input_path, std::string& f
     } else if (command == "-rebuild_wwev_in") {
         rpkg_function::rebuild_wwev_in(input_path);
     } else if (command == "-rebuild_dlge_from_json_from") {
-        rpkg_function::rebuild_dlge_from_json_from(input_path, output_path);
+        rpkg_function::rebuild_dlge_from_json_from(input_path, output_path, search);
     } else if (command == "-rebuild_locr_from_json_from") {
-        rpkg_function::rebuild_locr_from_json_from(input_path);
+        rpkg_function::rebuild_locr_from_json_from(input_path, search);
     } else if (command == "-rebuild_rtlv_from_json_from") {
-        rpkg_function::rebuild_rtlv_from_json_from(input_path);
+        rpkg_function::rebuild_rtlv_from_json_from(input_path, search);
     } else if (command == "-search_rpkg") {
         rpkg_extraction_vars rpkg_vars;
 
@@ -147,7 +148,34 @@ void task::execute(std::string& command, std::string& input_path, std::string& f
     } else if (command == "-hash_meta_to_json") {
         rpkg_function::hash_meta_to_json(input_path);
     } else if (command == "-json_to_hash_meta") {
-        rpkg_function::json_to_hash_meta(input_path);
+        std::string jsonmeta = file::read_file_to_string(input_path);
+
+        std::vector<char> hashmeta = rpkg_function::json_to_hash_meta(jsonmeta);
+
+        if (hashmeta.empty()) {
+            LOG("Failed to convert json to hash meta.");
+            return;
+        }
+
+        if (input_path.length() > 11) {
+            if (util::to_upper_case(input_path.substr(input_path.length() - 10)) != ".META.JSON") {
+                LOG("Error: Input file does not end in .meta.JSON");
+
+                response_string = "Error: Input file does not end in .meta.JSON";
+
+                return;
+            }
+        }
+
+        std::ofstream meta_file = std::ofstream(input_path.substr(0, input_path.length() - 5), std::ofstream::binary);
+
+        LOG("Success: " + input_path + " has been converted.");
+
+        response_string = "Success: " + input_path + " has been converted.";
+
+        meta_file.write(hashmeta.data(), hashmeta.size());
+
+        meta_file.close();
     } else if (command == "-latest_hash") {
         rpkg_function::latest_hash(input_path, filter, output_path);
     } else if (command == "-export_map") {
@@ -178,7 +206,7 @@ void task::execute(std::string& command, std::string& input_path, std::string& f
         search_categories[1] = (int)entity::search_category::TEMPHASH;
         rpkg_function::search_entities(input_path, search_strings, search_types, search_categories, 2, 10, true, true);*/
     } else if (command == "-search_localization") {
-        rpkg_function::search_localization(input_path, search, output_path, true, true, true, 1000);
+        rpkg_function::search_localization(input_path, search, output_path, true, true, true, 1000, "HM3");
     } else if (command == "-get_line_string") {
         rpkg_function::get_line_string(input_path, filter, output_path);
     } else if (command == "-extract_sdef_to_json") {
@@ -352,6 +380,8 @@ void task::process_and_execute_command_line_args(std::vector<std::vector<std::st
             search = i.at(1);
         } else if (util::to_lower_case(i.at(0)) == "-output_path") {
             output_path = i.at(1);
+        } else if (util::to_lower_case(i.at(0)) == "-hex_precision") {
+            search_type = "hex_precision";
         } else {
             LOG_AND_EXIT("Error: Invalid command in command line.");
         }
diff --git a/src/temp.cpp b/src/temp.cpp
index de7569e..8e84a11 100644
--- a/src/temp.cpp
+++ b/src/temp.cpp
@@ -4,12 +4,12 @@
 #include "crypto.h"
 #include "util.h"
 #include "generic_function.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/rapidjson/document.h"
-#include "thirdparty/rapidjson/writer.h"
-#include "thirdparty/rapidjson/stringbuffer.h"
-#include "thirdparty/rapidjson/pointer.h"
-#include "thirdparty/directxmath/DirectXMath.h"
+#include <lz4.h>
+#include <rapidjson/document.h>
+#include <rapidjson/writer.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/pointer.h>
+#include <DirectXMath.h>
 #include <unordered_map>
 #include <fstream>
 #include <sstream>
@@ -17,9 +17,6 @@
 #include <algorithm>
 #include <iomanip>
 
-#pragma comment(lib, "../thirdparty/zhmtools/ResourceLib_HM2.lib")
-#pragma comment(lib, "../thirdparty/zhmtools/ResourceLib_HM3.lib")
-
 temp::temp() = default;
 
 temp::temp(uint64_t rpkgs_index, uint64_t hash_index) {
diff --git a/src/temp.h b/src/temp.h
index cba8739..d8a3792 100644
--- a/src/temp.h
+++ b/src/temp.h
@@ -4,9 +4,9 @@
 #include <vector>
 #include <unordered_map>
 #include <cstdint>
-#include "thirdparty/rapidjson/document.h"
-#include "thirdparty/zhmtools/ResourceLib_HM3.h"
-#include "thirdparty/json/json.hpp"
+#include <rapidjson/document.h>
+#include <ResourceLib_HM3.h>
+#include <nlohmann/json.hpp>
 
 using json = nlohmann::ordered_json;
 
diff --git a/src/texd.cpp b/src/texd.cpp
index fe71e81..3ffe8b3 100644
--- a/src/texd.cpp
+++ b/src/texd.cpp
@@ -3,7 +3,7 @@
 #include "global.h"
 #include "crypto.h"
 #include "util.h"
-#include "../thirdparty/lz4/lz4.h"
+#include <lz4.h>
 #include <iostream>
 #include <fstream>
 
diff --git a/src/text.cpp b/src/text.cpp
index d5c8b76..23b0692 100644
--- a/src/text.cpp
+++ b/src/text.cpp
@@ -4,9 +4,9 @@
 #include "crypto.h"
 #include "util.h"
 #include "texd.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/directxtex/DirectXTex.h"
-#include "thirdparty/directxtex/DDS.h"
+#include <lz4.h>
+#include <DirectXTex.h>
+#include <DDS.h>
 #include <unordered_map>
 #include <fstream>
 #include <locale>
diff --git a/src/text.h b/src/text.h
index 96ad2ef..334ed68 100644
--- a/src/text.h
+++ b/src/text.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "texd.h"
-#include "thirdparty/directxtex/DirectXTex.h"
-#include "thirdparty/directxtex/DDS.h"
+#include <DirectXTex.h>
+#include <DDS.h>
 #include <string>
 #include <vector>
 #include <unordered_map>
diff --git a/src/util.cpp b/src/util.cpp
index c508158..e24108d 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -1,13 +1,15 @@
 #include "util.h"
 #include "global.h"
 #include "generic_function.h"
-#include "thirdparty/lz4/lz4.h"
-#include "thirdparty/lz4/lz4hc.h"
-#include "thirdparty/directxtex/DirectXTex.h"
+#include "file.h"
+#include <lz4.h>
+#include <lz4hc.h>
+#include <DirectXTex.h>
 #include <string>
 #include <sstream>
 #include <iomanip>
 #include <regex>
+#include <TonyTools/Languages.h>
 
 std::string util::generate_guid() {
     GUID guid;
@@ -418,6 +420,29 @@ bool util::lz4_compress_hc(const char* source, std::vector<char>& destination, i
     return compressed_size != 0;
 }
 
+uint32_t util::load_hmla_hash_list(const std::string& path) {
+    std::string hmlaPath = path.empty() ? exe_path + std::string("\\hash_list.hmla") : path;
+
+    if (!TonyTools::Language::HashList::GetStatus().loaded) {
+        if (!file::path_exists(hmlaPath)) {
+            LOG("Skipping loading HMLanguages hash list. File does not exist.");
+            return -1;
+        }
+
+        if (TonyTools::Language::HashList::Load(
+            file::read_file(hmlaPath)
+        )) {
+            LOG("Successfully loaded HMLanguages hash list!");
+            return TonyTools::Language::HashList::GetStatus().version;
+        } else {
+            LOG("Failed to load HMLanguages hash list!");
+            return -1;
+        }
+    } else {
+        return -1;
+    }
+}
+
 uint32_t util::uint32_t_byteswap(uint32_t input) {
 #if _MSC_VER
     return _byteswap_ulong(input);
diff --git a/src/util.h b/src/util.h
index 06c230f..8fbb3fb 100644
--- a/src/util.h
+++ b/src/util.h
@@ -71,6 +71,8 @@ class util {
 
     static std::wstring string_to_wstring(const std::string& input_string);
 
+    static uint32_t load_hmla_hash_list(const std::string &path = "");
+
     static bool
     lz4_compress_hc(const char* source, std::vector<char>& destination, int source_size, int& compressed_size);
 
diff --git a/thirdparty/GLTFSDK/CMakeLists.txt b/thirdparty/GLTFSDK/CMakeLists.txt
deleted file mode 100644
index 4f8919d..0000000
--- a/thirdparty/GLTFSDK/CMakeLists.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-cmake_minimum_required(VERSION 3.5)
-project(GLTFSDK)
-
-file(GLOB GLTFSDK_SOURCE_FILES
-    "${CMAKE_CURRENT_LIST_DIR}/Source/*.cpp"
-)
-file(GLOB GLTFSDK_GEN_HEADER_FILES
-    "${CMAKE_CURRENT_LIST_DIR}/Inc/*.h"
-)
-file(GLOB GLTFSDK_HEADER_FILES
-    "${CMAKE_CURRENT_LIST_DIR}/Inc/GLTFSDK/*.h"
-)
-
-add_library(GLTFSDK ${GLTFSDK_SOURCE_FILES} ${GLTFSDK_GEN_HEADER_FILES} ${GLTFSDK_HEADER_FILES})
-
-if (MSVC)
-    # Generate PDB files in all configurations, not just Debug (/Zi)
-    # Set warning level to 4 (/W4)
-    target_compile_options(GLTFSDK PRIVATE "/Zi;/EHsc")
-
-    # Make sure that all PDB files on Windows are installed to the output folder with the libraries. By default, only the debug build does this.
-    set_target_properties(GLTFSDK PROPERTIES COMPILE_PDB_NAME "GLTFSDK" COMPILE_PDB_OUTPUT_DIRECTORY "${LIBRARY_OUTPUT_DIRECTORY}")
-endif()
-
-if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    target_compile_options(GLTFSDK
-        PRIVATE "-Wunguarded-availability"
-        PRIVATE "-Wall"
-        PRIVATE "-Werror"
-        PUBLIC "-Wno-unknown-pragmas")
-endif()
-
-target_include_directories(GLTFSDK
-    PUBLIC "${CMAKE_CURRENT_LIST_DIR}/Inc"
-    PRIVATE "${CMAKE_SOURCE_DIR}/Built/Int"
-)
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/AnimationUtils.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/AnimationUtils.h
deleted file mode 100644
index ad4377a..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/AnimationUtils.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <vector>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class Document;
-        class GLTFResourceReader;
-        struct Accessor;
-        struct AnimationSampler;
-        struct Skin;
-
-        namespace AnimationUtils
-        {
-            std::vector<float> GetKeyframeTimes(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<float> GetKeyframeTimes(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& sampler);
-
-            std::vector<float> GetInverseBindMatrices(const Document& doc, const GLTFResourceReader& reader, const Accessor& skin);
-            std::vector<float> GetInverseBindMatrices(const Document& doc, const GLTFResourceReader& reader, const Skin& skin);
-
-            std::vector<float> GetTranslations(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<float> GetTranslations(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& accessor);
-
-            std::vector<float> GetRotations(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<float> GetRotations(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& accessor);
-
-            std::vector<float> GetScales(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<float> GetScales(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& accessor);
-
-            std::vector<float> GetMorphWeights(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<float> GetMorphWeights(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& accessor);
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/BufferBuilder.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/BufferBuilder.h
deleted file mode 100644
index 3e85f53..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/BufferBuilder.h
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/GLTF.h>
-#include <GLTFSDK/Document.h>
-
-#include <functional>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class Document;
-        class ResourceWriter;
-
-        struct AccessorDesc
-        {
-            AccessorDesc() = default;
-
-            AccessorDesc(AccessorType accessorType, ComponentType componentType, bool normalized = false, std::vector<float> minValues = {}, std::vector<float> maxValues = {}, size_t byteOffset = 0)
-                : accessorType(accessorType), componentType(componentType), normalized(normalized),
-                byteOffset(byteOffset), minValues(std::move(minValues)), maxValues(std::move(maxValues))
-            { }
-
-            bool IsValid() const { return accessorType != TYPE_UNKNOWN && componentType != COMPONENT_UNKNOWN; }
-
-            AccessorType accessorType;
-            ComponentType componentType;
-            bool normalized;
-            size_t byteOffset;
-            std::vector<float> minValues;
-            std::vector<float> maxValues;
-        };
-
-        class BufferBuilder final
-        {
-            typedef std::function<std::string(const BufferBuilder&)> FnGenId;
-
-        public:
-            BufferBuilder(std::unique_ptr<ResourceWriter>&& resourceWriter);
-            BufferBuilder(std::unique_ptr<ResourceWriter>&& resourceWriter,
-                FnGenId fnGenBufferId,
-                FnGenId fnGenBufferViewId,
-                FnGenId fnGenAccessorId);
-
-            const Buffer& AddBuffer(const char* bufferId = nullptr);
-
-            const BufferView& AddBufferView(Optional<BufferViewTarget> target = {});
-            const BufferView& AddBufferView(const void* data, size_t byteLength, Optional<size_t> byteStride = {}, Optional<BufferViewTarget> target = {});
-
-            template<typename T>
-            const BufferView& AddBufferView(const std::vector<T>& data, Optional<size_t> byteStride = {}, Optional<BufferViewTarget> target = {})
-            {
-                return AddBufferView(data.data(), data.size() * sizeof(T), byteStride, target);
-            }
-
-            const Accessor& AddAccessor(const void* data, size_t count, AccessorDesc accessorDesc);
-
-            template<typename T>
-            const Accessor& AddAccessor(const std::vector<T>& data, AccessorDesc accessorDesc)
-            {
-                const auto accessorTypeSize = Accessor::GetTypeCount(accessorDesc.accessorType);
-
-                if (data.size() % accessorTypeSize)
-                {
-                    throw InvalidGLTFException("vector size is not a multiple of accessor type size");
-                }
-
-                return AddAccessor(data.data(), data.size() / accessorTypeSize, std::move(accessorDesc));
-            }
-
-            void AddAccessors(const void* data, size_t count, size_t byteStride, const AccessorDesc* pDescs, size_t descCount, std::string* pOutIds = nullptr);
-
-            // This method moved from the .cpp to the header because
-            // When this library is built with VS2017 and used in an executable built with VS2019
-            // an unordered_map issue ( see https://docs.microsoft.com/en-us/cpp/overview/cpp-conformance-improvements?view=msvc-160 )
-            // makes the destruction to perform an underflow.
-            // To fix the issue, the code here is inlined so it gets compiled and linked with VS2019.
-            // So only 1 version of std::unordered_map binary code is generated.
-            void Output(Document& gltfDocument)
-            {
-                for (auto& buffer : m_buffers.Elements())
-                {
-                    gltfDocument.buffers.Append(std::move(buffer), AppendIdPolicy::ThrowOnEmpty);
-                }
-
-                m_buffers.Clear();
-
-                for (auto& bufferView : m_bufferViews.Elements())
-                {
-                    gltfDocument.bufferViews.Append(std::move(bufferView), AppendIdPolicy::ThrowOnEmpty);
-                }
-
-                m_bufferViews.Clear();
-
-                for (auto& accessor : m_accessors.Elements())
-                {
-                    gltfDocument.accessors.Append(std::move(accessor), AppendIdPolicy::ThrowOnEmpty);
-                }
-
-                m_accessors.Clear();
-            }
-
-            const Buffer&     GetCurrentBuffer() const;
-            const BufferView& GetCurrentBufferView() const;
-            const Accessor&   GetCurrentAccessor() const;
-
-            size_t GetBufferCount() const;
-            size_t GetBufferViewCount() const;
-            size_t GetAccessorCount() const;
-
-            ResourceWriter& GetResourceWriter();
-            const ResourceWriter& GetResourceWriter() const;
-
-        private:
-            const Accessor& AddAccessor(size_t count, AccessorDesc desc);
-
-            std::unique_ptr<ResourceWriter> m_resourceWriter;
-
-            IndexedContainer<Buffer>     m_buffers;
-            IndexedContainer<BufferView> m_bufferViews;
-            IndexedContainer<Accessor>   m_accessors;
-
-            FnGenId m_fnGenBufferId;
-            FnGenId m_fnGenBufferViewId;
-            FnGenId m_fnGenAccessorId;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Color.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Color.h
deleted file mode 100644
index 2cbfff6..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Color.h
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <cstdint>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        template<typename TColor>
-        struct ColorBase
-        {
-            using Super = ColorBase<TColor>;
-
-            static TColor Lerp(const TColor& start, const TColor& end, float amount)
-            {
-                return (start * (1.0f - amount)) + (end * amount);
-            }
-
-            friend TColor operator*(const TColor& lhs, const TColor& rhs)
-            {
-                TColor lhsCopy = lhs;
-
-                // Implemented using TColor::operator*=(const TColor&)
-                lhsCopy *= rhs;
-                return lhsCopy;
-            }
-
-            friend TColor operator*(TColor lhs, float rhs)
-            {
-                // Implemented using TColor::operator*=(float)
-                lhs *= rhs;
-                return lhs;
-            }
-
-            friend TColor operator*(float lhs, TColor rhs)
-            {
-                // Implemented using TColor::operator*=(float) - takes advantage of commutative nature of scalar/vector multiplication
-                rhs *= lhs;
-                return rhs;
-            }
-
-            friend TColor operator/(const TColor& lhs, const TColor& rhs)
-            {
-                TColor lhsCopy = lhs;
-
-                // Implemented using TColor::operator/=(const TColor&)
-                lhsCopy /= rhs;
-                return lhsCopy;
-            }
-
-            friend TColor operator/(TColor lhs, float rhs)
-            {
-                // Implemented using TColor::operator/=(float)
-                lhs /= rhs;
-                return lhs;
-            }
-
-            friend TColor operator/(float lhs, TColor rhs)
-            {
-                // Implemented using operator/(const TColor&, const TColor&)
-                return TColor::FromScalar(lhs) / rhs;
-            }
-
-            friend TColor operator+(const TColor& lhs, const TColor& rhs)
-            {
-                TColor lhsCopy = lhs;
-
-                // Implemented using TColor::operator+=(const TColor&)
-                lhsCopy += rhs;
-                return lhsCopy;
-            }
-
-            friend TColor operator+(TColor lhs, float rhs)
-            {
-                // Implemented using TColor::operator+=(float)
-                lhs += rhs;
-                return lhs;
-            }
-
-            friend TColor operator+(float lhs, TColor rhs)
-            {
-                // Implemented using TColor::operator+=(float) - takes advantage of commutative nature of scalar/vector addition
-                rhs += lhs;
-                return rhs;
-            }
-
-            friend TColor operator-(const TColor& lhs, const TColor& rhs)
-            {
-                TColor lhsCopy = lhs;
-
-                // Implemented using TColor::operator-=(const TColor&)
-                lhsCopy -= rhs;
-                return lhsCopy;
-            }
-
-            friend TColor operator-(TColor lhs, float rhs)
-            {
-                // Implemented using TColor::operator-=(float)
-                lhs -= rhs;
-                return lhs;
-            }
-
-            friend TColor operator-(float lhs, TColor rhs)
-            {
-                // Implemented using operator-(const TColor&, const TColor&)
-                return TColor::FromScalar(lhs) - rhs;
-            }
-        };
-
-        struct Color4; // Forward declaration required for Color3::AsColor4 to have a return type of Color4
-
-        struct Color3 : private ColorBase<Color3>
-        {
-            using Super::Lerp;
-
-            float r;
-            float g;
-            float b;
-
-            Color3(float r, float g, float b);
-            Color3(uint8_t r, uint8_t g, uint8_t b);
-
-            static Color3 FromScalar(float value);
-
-            Color3& operator*=(const Color3& rhs);
-            Color3& operator*=(float rhs);
-
-            Color3& operator/=(const Color3& rhs);
-            Color3& operator/=(float rhs);
-
-            Color3& operator+=(const Color3& rhs);
-            Color3& operator+=(float rhs);
-
-            Color3& operator-=(const Color3& rhs);
-            Color3& operator-=(float rhs);
-
-            Color3 ToGamma() const;
-            Color3 ToLinear() const;
-
-            Color4 AsColor4(float a = 1.0f) const;
-
-            uint32_t AsUint32RGBA() const;
-            uint32_t AsUint32BGRA() const;
-
-            static Color3 FromUint32RGBA(uint32_t color);
-            static Color3 FromUint32BGRA(uint32_t color);
-
-            static Color3 Clamp(const Color3& color, float lo, float hi);
-        };
-
-        bool operator==(const Color3& lhs, const Color3& rhs);
-        bool operator!=(const Color3& lhs, const Color3& rhs);
-
-        struct Color4 : private ColorBase<Color4>
-        {
-            using Super::Lerp;
-
-            float r;
-            float g;
-            float b;
-            float a;
-
-            Color4(float r, float g, float b, float a);
-            Color4(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
-
-            static Color4 FromScalar(float value);
-
-            Color4& operator*=(const Color4& rhs);
-            Color4& operator*=(float);
-
-            Color4& operator/=(const Color4& rhs);
-            Color4& operator/=(float);
-
-            Color4& operator+=(const Color4& rhs);
-            Color4& operator+=(float);
-
-            Color4& operator-=(const Color4& rhs);
-            Color4& operator-=(float);
-
-            Color3 AsColor3() const;
-
-            uint32_t AsUint32RGBA() const;
-            uint32_t AsUint32BGRA() const;
-
-            static Color4 FromUint32RGBA(uint32_t color);
-            static Color4 FromUint32BGRA(uint32_t color);
-
-            static Color4 Clamp(const Color4& color, float lo, float hi);
-        };
-
-        bool operator==(const Color4& lhs, const Color4& rhs);
-        bool operator!=(const Color4& lhs, const Color4& rhs);
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Constants.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Constants.h
deleted file mode 100644
index dcced8a..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Constants.h
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        const int GLB_HEADER_BYTE_SIZE = 20;
-        const int GLB2_HEADER_BYTE_SIZE = 12;
-        const int GLB_HEADER_MAGIC_STRING_SIZE = 4;
-        const int GLB_HEADER_VERSION_1 = 1;
-        const int GLB_HEADER_VERSION_2 = 2;
-        const int GLB_HEADER_FORMAT = 0;
-        const int GLB_CHUNK_ALIGNMENT_SIZE = 4;
-        const int GLB_BUFFER_OFFSET_ALIGNMENT = 4; // temporary, see comment on alignment padding in SaveBin
-        const int GLB_CHUNK_TYPE_SIZE = 4;
-
-        constexpr const char* MSFT_GLTF_EXPORTER_NAME = "Microsoft GLTF Exporter";
-        constexpr const char* GLB_HEADER_MAGIC_STRING = "glTF";
-        constexpr const char* GLTF_VERSION_2_0 = "2.0";
-        constexpr const char* GLB_CHUNK_TYPE_JSON = "JSON";
-        constexpr const char* GLB_CHUNK_TYPE_BIN = "BIN\0";
-
-        constexpr const char* GLTF_EXTENSION = "gltf";
-        constexpr const char* GLB_EXTENSION = "glb";
-        constexpr const char* BUFFER_EXTENSION = "bin";
-
-        constexpr const char* GLB_BUFFER_ID = "binary_glTF";
-        constexpr const char* EMPTY_URI = "data:,";
-
-        constexpr const char* MIMETYPE_PNG = "image/png";
-        constexpr const char* MIMETYPE_JPEG = "image/jpeg";
-
-        constexpr const char* FILE_EXT_PNG = "png";
-        constexpr const char* FILE_EXT_JPEG = "jpg";
-
-        constexpr const char* DEFAULT_BUFFER_ID = "buffer_default";
-
-        constexpr const char* BUFFERVIEW_INDICES_ID = "bufferView_indices";
-        constexpr const char* BUFFERVIEW_UV0_ID = "bufferView_uv0";
-        constexpr const char* BUFFERVIEW_UV1_ID = "bufferView_uv1";
-        constexpr const char* BUFFERVIEW_POSITIONS_NORMALS_ID = "bufferView_positions_normals";
-        constexpr const char* MESH_TRIANGLES_ID = "triangles";
-
-        constexpr const char* ACCESSOR_POSITION = "POSITION";
-        constexpr const char* ACCESSOR_NORMAL = "NORMAL";
-        constexpr const char* ACCESSOR_TANGENT = "TANGENT";
-        constexpr const char* ACCESSOR_TEXCOORD_0 = "TEXCOORD_0";
-        constexpr const char* ACCESSOR_TEXCOORD_1 = "TEXCOORD_1";
-        constexpr const char* ACCESSOR_COLOR_0 = "COLOR_0";
-        constexpr const char* ACCESSOR_JOINTS_0 = "JOINTS_0";
-        constexpr const char* ACCESSOR_WEIGHTS_0 = "WEIGHTS_0";
-
-        constexpr const char* TYPE_NAME_SCALAR = "SCALAR";
-        constexpr const char* TYPE_NAME_VEC2 = "VEC2";
-        constexpr const char* TYPE_NAME_VEC3 = "VEC3";
-        constexpr const char* TYPE_NAME_VEC4 = "VEC4";
-        constexpr const char* TYPE_NAME_MAT2 = "MAT2";
-        constexpr const char* TYPE_NAME_MAT3 = "MAT3";
-        constexpr const char* TYPE_NAME_MAT4 = "MAT4";
-
-        constexpr const char* COMPONENT_TYPE_NAME_BYTE = "BYTE";
-        constexpr const char* COMPONENT_TYPE_NAME_UNSIGNED_BYTE = "UNSIGNED_BYTE";
-        constexpr const char* COMPONENT_TYPE_NAME_SHORT = "SHORT";
-        constexpr const char* COMPONENT_TYPE_NAME_UNSIGNED_SHORT = "UNSIGNED_SHORT";
-        constexpr const char* COMPONENT_TYPE_NAME_UNSIGNED_INT = "UNSIGNED_INT";
-        constexpr const char* COMPONENT_TYPE_NAME_FLOAT = "FLOAT";
-
-        constexpr const char* ALPHAMODE_NAME_OPAQUE = "OPAQUE";
-        constexpr const char* ALPHAMODE_NAME_BLEND = "BLEND";
-        constexpr const char* ALPHAMODE_NAME_MASK = "MASK";
-
-        constexpr const char* TARGETPATH_NAME_TRANSLATION = "translation";
-        constexpr const char* TARGETPATH_NAME_ROTATION = "rotation";
-        constexpr const char* TARGETPATH_NAME_SCALE = "scale";
-        constexpr const char* TARGETPATH_NAME_WEIGHTS = "weights";
-
-        constexpr const char* INTERPOLATIONTYPE_NAME_LINEAR = "LINEAR";
-        constexpr const char* INTERPOLATIONTYPE_NAME_STEP = "STEP";
-        constexpr const char* INTERPOLATIONTYPE_NAME_CUBICSPLINE = "CUBICSPLINE";
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Deserialize.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Deserialize.h
deleted file mode 100644
index 257074e..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Deserialize.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Document.h>
-#include <GLTFSDK/Schema.h>
-
-namespace Microsoft 
-{
-    namespace glTF
-    {
-        // IgnoreByteOrderMark -> According to the spec, "JSON must use UTF-8 encoding without BOM". Specifying this flag will ignore the presence of a byte order mark rather than treating it as an error.
-        enum class DeserializeFlags
-        {
-            None = 0x0,
-            IgnoreByteOrderMark = 0x1
-        };
-
-        DeserializeFlags  operator| (DeserializeFlags lhs,  DeserializeFlags rhs);
-        DeserializeFlags& operator|=(DeserializeFlags& lhs, DeserializeFlags rhs);
-        DeserializeFlags  operator& (DeserializeFlags lhs,  DeserializeFlags rhs);
-        DeserializeFlags& operator&=(DeserializeFlags& lhs, DeserializeFlags rhs);
-
-        class ExtensionDeserializer;
-
-        Document Deserialize(const std::string& json, DeserializeFlags flags = DeserializeFlags::None, SchemaFlags schemaFlags = SchemaFlags::None);
-        Document Deserialize(const std::string& json, const ExtensionDeserializer& extensions, DeserializeFlags flags = DeserializeFlags::None, SchemaFlags schemaFlags = SchemaFlags::None);
-
-        Document Deserialize(std::istream& jsonStream, DeserializeFlags flags = DeserializeFlags::None, SchemaFlags schemaFlags = SchemaFlags::None);
-        Document Deserialize(std::istream& jsonStream, const ExtensionDeserializer& extensions, DeserializeFlags flags = DeserializeFlags::None, SchemaFlags schemaFlags = SchemaFlags::None);
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Document.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Document.h
deleted file mode 100644
index 3739519..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Document.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/GLTF.h>
-#include <GLTFSDK/IndexedContainer.h>
-
-#include <unordered_set>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class Document : public glTFProperty
-        {
-        public:
-            Document();
-            Document(Asset&& asset);
-
-            bool operator==(const Document& rhs) const;
-
-            bool IsExtensionUsed(const std::string& extension) const;
-            bool IsExtensionRequired(const std::string& extension) const;
-
-            bool HasDefaultScene() const;
-            const Scene& GetDefaultScene() const;
-            const Scene& SetDefaultScene(Scene&& scene, AppendIdPolicy policy = AppendIdPolicy::ThrowOnEmpty);
-
-            Asset asset;
-
-            IndexedContainer<const Accessor> accessors;
-            IndexedContainer<const Animation> animations;
-            IndexedContainer<const Buffer> buffers;
-            IndexedContainer<const BufferView> bufferViews;
-            IndexedContainer<const Camera> cameras;
-            IndexedContainer<const Image> images;
-            IndexedContainer<const Material> materials;
-            IndexedContainer<const Mesh> meshes;
-            IndexedContainer<const Node> nodes;
-            IndexedContainer<const Sampler> samplers;
-            IndexedContainer<const Scene> scenes;
-            IndexedContainer<const Skin> skins;
-            IndexedContainer<const Texture> textures;
-
-            std::unordered_set<std::string> extensionsUsed;
-            std::unordered_set<std::string> extensionsRequired;
-
-            std::string defaultSceneId;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Exceptions.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Exceptions.h
deleted file mode 100644
index dfb38f7..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Exceptions.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <stdexcept>
-#include <string>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        // Base class for all glTF SDK exceptions
-        class GLTFException : public std::runtime_error
-        {
-        public:
-            GLTFException(const std::string& msg) : std::runtime_error(msg) {}
-        };
-
-        // An operation was attempted that would cause a spec violation
-        class InvalidGLTFException : public GLTFException
-        {
-        public:
-            InvalidGLTFException(const std::string& msg) : GLTFException(msg) {}
-        };
-
-        // The glTF::Document is in a bad state
-        class DocumentException : public GLTFException
-        {
-        public:
-            DocumentException(const std::string& msg) : GLTFException(msg) {}
-        };
-
-        // The glTF failed validation
-        class ValidationException : public GLTFException
-        {
-        public:
-            ValidationException(const std::string& msg) : GLTFException(msg) {}
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Extension.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Extension.h
deleted file mode 100644
index 9dd6216..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Extension.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <memory>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class Extension
-        {
-        public:
-            virtual ~Extension() = default;
-
-            virtual std::unique_ptr<Extension> Clone() const = 0;
-            virtual bool IsEqual(const Extension& other) const = 0;
-
-            bool operator==(const Extension& rhs) const;
-            bool operator!=(const Extension& rhs) const;
-
-        protected:
-            Extension() = default;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/ExtensionHandlers.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/ExtensionHandlers.h
deleted file mode 100644
index c8d921b..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/ExtensionHandlers.h
+++ /dev/null
@@ -1,198 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/GLTF.h>
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <typeindex>
-#include <unordered_map>
-#include <utility>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        namespace Detail
-        {
-            using TypeKey = std::pair<std::type_index, std::type_index>;
-
-            template<typename T1, typename T2>
-            TypeKey MakeTypeKey()
-            {
-                return { typeid(T1), typeid(T2) };
-            }
-
-            template<typename T>
-            TypeKey MakeTypeKey(const Extension& extension)
-            {
-                return { typeid(extension), typeid(T) };
-            }
-
-            TypeKey MakeTypeKey(const Extension& extension, const glTFProperty& property);
-
-            using NameKey = std::pair<std::string, std::type_index>;
-
-            template<typename T>
-            NameKey MakeNameKey(const std::string& name)
-            {
-                return { name, typeid(T) };
-            }
-
-            NameKey MakeNameKey(const std::string& name, const glTFProperty& property);
-        }
-
-        template<typename TReturn, typename ...TArgs>
-        class ExtensionHandlers
-        {
-        public:
-            template<typename TExt, typename Fn>
-            void AddHandler(const std::string& name, Fn fn)
-            {
-                AddHandler<TExt, glTFPropertyAll>(name, fn);
-            }
-
-            template<typename TExt, typename TProp, typename Fn>
-            void AddHandler(const std::string& name, Fn fn)
-            {
-                static_assert(std::is_base_of<Extension, TExt>::value, "ExtensionHandlers::AddHandler: TExt template parameter must derive from Extension");
-                static_assert(std::is_base_of<glTFProperty, TProp>::value, "ExtensionHandlers::AddHandler: TProp template parameter must derive from glTFProperty");
-
-                auto resultName = nameToType.emplace(Detail::MakeNameKey<TProp>(name), typeid(TExt));
-
-                if (!resultName.second)
-                {
-                    throw GLTFException("A handler for the " + name + " extension already exists");
-                }
-
-                auto resultType = typeToName.emplace(Detail::MakeTypeKey<TExt, TProp>(), name);
-
-                if (!resultType.second)
-                {
-                    throw GLTFException("A handler for the " + name + " extension already exists");
-                }
-
-                // Wrap the passed callable type Fn so that the handler is passed a reference to TExt rather than Extension
-                auto fnConvert = [fn](std::add_lvalue_reference_t<const TArgs> ...args)
-                {
-                    return fn(Convert<TExt>(args)...);
-                };
-
-                auto resultHandler = handlers.emplace(Detail::MakeTypeKey<TExt, TProp>(), fnConvert);
-
-                if (!resultHandler.second)
-                {
-                    throw GLTFException("A handler for the " + name + " extension already exists");
-                }
-            }
-
-            template<typename TExt>
-            bool HasHandler() const
-            {
-                return HasHandler<TExt, glTFPropertyAll>();
-            }
-
-            template<typename TExt, typename TProp>
-            bool HasHandler() const
-            {
-                return typeToName.find(Detail::MakeTypeKey<TExt, TProp>()) != typeToName.end();
-            }
-
-            bool HasHandler(const std::string& name) const
-            {
-                return nameToType.find(Detail::MakeNameKey<glTFPropertyAll>(name)) != nameToType.end();
-            }
-
-            bool HasHandler(const std::string& name, const glTFProperty& property) const
-            {
-                return nameToType.find(Detail::MakeNameKey(name, property)) != nameToType.end();
-            }
-
-            typedef std::function<TReturn(std::add_lvalue_reference_t<const TArgs>...)> Func;
-
-        protected:
-            TReturn Process(const Detail::TypeKey& key, std::add_lvalue_reference_t<const TArgs> ...args) const
-            {
-                auto it = handlers.find(key);
-
-                if (it == handlers.end())
-                {
-                    throw GLTFException("No handler is registered for the specified type_index");
-                }
-
-                return it->second(args...);
-            }
-
-            // Called when the argument type inherits from Extension - converts the argument from Extension to the derived type TExt
-            template<typename TExt, typename TArg>
-            static auto Convert(const TArg& arg) -> std::enable_if_t< std::is_base_of<Extension, TArg>::value, const TExt&>
-            {
-                return dynamic_cast<const TExt&>(arg);
-            }
-
-            // Called when the argument type doesn't inherit from Extension - passes the argument through unchanged
-            template<typename TExt, typename TArg>
-            static auto Convert(const TArg& arg) -> std::enable_if_t<!std::is_base_of<Extension, TArg>::value, const TArg&>
-            {
-                return arg;
-            }
-
-            // Non-constructible sentinel type for adding a handler that operates on all glTFProperty derived types
-            struct glTFPropertyAll : glTFProperty
-            {
-                glTFPropertyAll() = delete;
-            };
-
-            struct Hash
-            {
-                template<typename T1, typename T2>
-                size_t operator()(const std::pair<T1, T2>& key) const
-                {
-                    // This method of combining hashes is from boost::hash_combine - https://www.boost.org/doc/libs/1_67_0/boost/container_hash/hash.hpp
-                    auto fnCombine = [](size_t& seed, size_t value)
-                    {
-                        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-                    };
-
-                    std::hash<T1> hash1;
-                    std::hash<T2> hash2;
-
-                    size_t hash = {};
-
-                    fnCombine(hash, hash1(std::get<0>(key)));
-                    fnCombine(hash, hash2(std::get<1>(key)));
-
-                    return hash;
-                }
-            };
-
-            std::unordered_map<Detail::TypeKey, Func, Hash> handlers;
-
-            std::unordered_map<Detail::TypeKey, std::string, Hash>     typeToName;
-            std::unordered_map<Detail::NameKey, std::type_index, Hash> nameToType;
-        };
-
-        struct ExtensionPair
-        {
-            std::string name;
-            std::string value;
-        };
-
-        class Document;
-
-        class ExtensionSerializer final : public ExtensionHandlers<std::string, Extension, Document, ExtensionSerializer>
-        {
-        public:
-            ExtensionPair Serialize(const Extension& extension, const glTFProperty& property, const Document& document) const;
-        };
-
-        class ExtensionDeserializer final : public ExtensionHandlers<std::unique_ptr<Extension>, std::string, ExtensionDeserializer>
-        {
-        public:
-            std::unique_ptr<Extension> Deserialize(const ExtensionPair& extensionPair, const glTFProperty& property) const;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/ExtensionsKHR.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/ExtensionsKHR.h
deleted file mode 100644
index 74f009d..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/ExtensionsKHR.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/ExtensionHandlers.h>
-#include <GLTFSDK/Optional.h>
-
-#include <memory>
-#include <string>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        namespace KHR
-        {
-            ExtensionSerializer   GetKHRExtensionSerializer();
-            ExtensionDeserializer GetKHRExtensionDeserializer();
-
-            namespace Materials
-            {
-                constexpr const char* PBRSPECULARGLOSSINESS_NAME = "KHR_materials_pbrSpecularGlossiness";
-
-                // KHR_materials_pbrSpecularGlossiness
-                struct PBRSpecularGlossiness : Extension, glTFProperty
-                {
-                    PBRSpecularGlossiness();
-
-                    Color4 diffuseFactor;
-                    TextureInfo diffuseTexture;
-                    Color3 specularFactor;
-                    float glossinessFactor;
-                    TextureInfo specularGlossinessTexture;
-
-                    std::unique_ptr<Extension> Clone() const override;
-                    bool IsEqual(const Extension& rhs) const override;
-                };
-
-                std::string SerializePBRSpecGloss(const PBRSpecularGlossiness& specGloss, const Document& gltfDocument, const ExtensionSerializer& extensionSerializer);
-                std::unique_ptr<Extension> DeserializePBRSpecGloss(const std::string& json, const ExtensionDeserializer& extensionDeserializer);
-
-                constexpr const char* UNLIT_NAME = "KHR_materials_unlit";
-
-                // KHR_materials_unlit
-                struct Unlit : Extension, glTFProperty
-                {
-                    std::unique_ptr<Extension> Clone() const override;
-                    bool IsEqual(const Extension& rhs) const override;
-                };
-
-                std::string SerializeUnlit(const Unlit& unlit, const Document& gltfDocument, const ExtensionSerializer& extensionSerializer);
-                std::unique_ptr<Extension> DeserializeUnlit(const std::string& json, const ExtensionDeserializer& extensionDeserializer);
-            }
-
-            namespace MeshPrimitives
-            {
-                constexpr const char* DRACOMESHCOMPRESSION_NAME = "KHR_draco_mesh_compression";
-
-                // KHR_draco_mesh_compression
-                struct DracoMeshCompression : Extension, glTFProperty
-                {
-                    std::string bufferViewId;
-
-                    std::unordered_map<std::string, uint32_t> attributes;
-
-                    std::unique_ptr<Extension> Clone() const override;
-                    bool IsEqual(const Extension& rhs) const override;
-                };
-
-                std::string SerializeDracoMeshCompression(const DracoMeshCompression& dracoMeshCompression, const Document& gltfDocument, const ExtensionSerializer& extensionSerializer);
-                std::unique_ptr<Extension> DeserializeDracoMeshCompression(const std::string& json, const ExtensionDeserializer& extensionDeserializer);
-            }
-
-            namespace TextureInfos
-            {
-                constexpr const char* TEXTURETRANSFORM_NAME = "KHR_texture_transform";
-
-                // KHR_texture_transform
-                struct TextureTransform : Extension, glTFProperty
-                {
-                    TextureTransform();
-                    TextureTransform(const TextureTransform&);
-
-                    Vector2 offset;
-                    float rotation;
-                    Vector2 scale;
-                    Optional<size_t> texCoord; // TexCoord is an optional property
-
-                    std::unique_ptr<Extension> Clone() const override;
-                    bool IsEqual(const Extension& rhs) const override;
-                };
-
-                std::string SerializeTextureTransform(const TextureTransform& textureTransform, const Document& gltfDocument, const ExtensionSerializer& extensionSerializer);
-                std::unique_ptr<Extension> DeserializeTextureTransform(const std::string& json, const ExtensionDeserializer& extensionDeserializer);
-            }
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/ExtrasDocument.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/ExtrasDocument.h
deleted file mode 100644
index 877a6f8..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/ExtrasDocument.h
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/RapidJsonUtils.h>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class ExtrasDocument
-        {
-        public:
-            ExtrasDocument() = default;
-
-            ExtrasDocument(const char* extras)
-            {
-                rapidjson::ParseResult result = m_document.Parse(extras);
-
-                if (result.IsError())
-                {
-                    throw GLTFException(std::string("Extras JSON parse error: ") + rapidjson::GetParseError_En(result.Code()));
-                }
-            }
-
-            template<typename T>
-            T GetValueOrDefault(T t = {}) const
-            {
-                return glTF::GetValueOrDefault<T>(m_document, std::move(t));
-            }
-
-            template<typename T>
-            T GetMemberValueOrDefault(const char* member, T t = {}) const
-            {
-                return glTF::GetMemberValueOrDefault<T>(m_document, member, std::move(t));
-            }
-
-            template<typename T>
-            T GetPointerValueOrDefault(const char* pointer, T t = {}) const
-            {
-                auto valuePtr = rapidjson::Pointer(pointer).Get(m_document, nullptr);
-
-                if (!valuePtr)
-                {
-                    return std::move(t);
-                }
-                return glTF::GetValueOrDefault<T>(*valuePtr, std::move(t));
-            }
-
-            template<typename T>
-            void SetValue(const T& t)
-            {
-                SetValue(m_document, t, m_document.GetAllocator());
-            }
-
-            template<typename T>
-            void SetMemberValue(const char* member, const T& t)
-            {
-                auto& allocator = m_document.GetAllocator();
-
-                if (m_document.IsNull())
-                {
-                    m_document.SetObject();
-                }
-
-                if (m_document.IsObject())
-                {
-                    auto it = m_document.FindMember(member);
-
-                    // If the member doesn't already exist then add it to the document with a null value
-                    if (it == m_document.MemberEnd())
-                    {
-                        it = m_document.AddMember(rapidjson::Value(member, allocator), rapidjson::Value(), allocator).FindMember(member);
-                    }
-
-                    SetValue(it->value, t, allocator);
-                }
-                else
-                {
-                    throw GLTFException("Extras JSON document has already been assigned an incompatible type");
-                }
-            }
-
-            template<typename T>
-            void SetPointerValue(const char* pointer, const T& t)
-            {
-                SetValue(rapidjson::Pointer(pointer).Create(m_document), t, m_document.GetAllocator());
-            }
-
-            const rapidjson::Document& GetDocument() const
-            {
-                return m_document;
-            }
-
-        private:
-            static void SwapValues(rapidjson::Value& valueOld, rapidjson::Value&& valueNew)
-            {
-                assert(!valueNew.IsNull());
-
-                if (valueOld.IsNull() ||
-                    valueOld.GetType() == valueNew.GetType())
-                {
-                    valueOld.Swap(valueNew);
-                }
-                else
-                {
-                    throw GLTFException("Extras JSON value has already been assigned an incompatible type");
-                }
-            }
-
-            static void SetValue(rapidjson::Value& valueOld, const char* str, rapidjson::Document::AllocatorType& allocator)
-            {
-                SwapValues(valueOld, rapidjson::Value(str, allocator));
-            }
-
-            template<typename T>
-            static void SetValue(rapidjson::Value& valueOld, const T& t, rapidjson::Document::AllocatorType&)
-            {
-                SwapValues(valueOld, rapidjson::Value(t));
-            }
-
-            rapidjson::Document m_document;
-        };
-
-        // Explicit specialization of SetValue for std::string (must be defined outside of the class definition)
-        template<>
-        inline void ExtrasDocument::SetValue<std::string>(rapidjson::Value& valueOld, const std::string& str, rapidjson::Document::AllocatorType& allocator)
-        {
-            SwapValues(valueOld, rapidjson::Value(str.c_str(), static_cast<rapidjson::SizeType>(str.length()), allocator));
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLBResourceReader.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/GLBResourceReader.h
deleted file mode 100644
index bfb6f32..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLBResourceReader.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/GLTFResourceReader.h>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class GLBResourceReader : public GLTFResourceReader
-        {
-        public:
-            GLBResourceReader(std::shared_ptr<const IStreamReader> streamReader, std::shared_ptr<std::istream> glbStream);
-            GLBResourceReader(std::unique_ptr<IStreamReaderCache> streamCache, std::shared_ptr<std::istream> glbStream);
-
-            std::shared_ptr<std::istream> GetBinaryStream(const Buffer& buffer) const override;
-            std::streampos                GetBinaryStreamPos(const Buffer& buffer) const override;
-
-            const std::string& GetJson() const;
-
-        private:
-            void Init();
-
-            std::string m_json;
-
-            std::shared_ptr<std::istream> m_buffer;
-            std::streamoff                m_bufferOffset;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLBResourceWriter.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/GLBResourceWriter.h
deleted file mode 100644
index 06f2a1e..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLBResourceWriter.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/GLTF.h>
-#include <GLTFSDK/GLTFResourceWriter.h>
-
-#include <memory>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class GLBResourceWriter : public GLTFResourceWriter
-        {
-        public:
-            GLBResourceWriter(std::shared_ptr<const IStreamWriter> streamWriter);
-            GLBResourceWriter(std::shared_ptr<const IStreamWriter> streamWriter, std::unique_ptr<std::iostream> tempBufferStream);
-            GLBResourceWriter(std::unique_ptr<IStreamWriterCache> streamCache);
-            GLBResourceWriter(std::unique_ptr<IStreamWriterCache> streamCache, std::unique_ptr<std::iostream> tempBufferStream);
-
-            void Flush(const std::string& manifest, const std::string& uri);
-            std::string GenerateBufferUri(const std::string& bufferId) const override;
-            std::ostream* GetBufferStream(const std::string& bufferId) override;
-
-        private:
-            std::shared_ptr<std::iostream> m_stream;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLTF.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/GLTF.h
deleted file mode 100644
index 0bc4b57..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLTF.h
+++ /dev/null
@@ -1,1358 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Color.h>
-#include <GLTFSDK/Constants.h>
-#include <GLTFSDK/Exceptions.h>
-#include <GLTFSDK/Extension.h>
-#include <GLTFSDK/IndexedContainer.h>
-#include <GLTFSDK/Math.h>
-#include <GLTFSDK/Optional.h>
-
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <typeindex>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        enum BufferViewTarget
-        {
-            ARRAY_BUFFER = 34962,
-            ELEMENT_ARRAY_BUFFER = 34963
-        };
-
-        enum ComponentType
-        {
-            COMPONENT_UNKNOWN = 0,
-            COMPONENT_BYTE = 5120,
-            COMPONENT_UNSIGNED_BYTE = 5121,
-            COMPONENT_SHORT = 5122,
-            COMPONENT_UNSIGNED_SHORT = 5123,
-            COMPONENT_UNSIGNED_INT = 5125,
-            COMPONENT_FLOAT = 5126
-        };
-
-        enum AccessorType
-        {
-            TYPE_UNKNOWN = 0,
-            TYPE_SCALAR,
-            TYPE_VEC2,
-            TYPE_VEC3,
-            TYPE_VEC4,
-            TYPE_MAT2,
-            TYPE_MAT3,
-            TYPE_MAT4
-        };
-
-        const std::unordered_map<std::string, AccessorType> AccessorTypes =
-        {
-            { TYPE_NAME_SCALAR, TYPE_SCALAR },
-            { TYPE_NAME_VEC2,   TYPE_VEC2 },
-            { TYPE_NAME_VEC3,   TYPE_VEC3 },
-            { TYPE_NAME_VEC4,   TYPE_VEC4 },
-            { TYPE_NAME_MAT2,   TYPE_MAT2 },
-            { TYPE_NAME_MAT3,   TYPE_MAT3 },
-            { TYPE_NAME_MAT4,   TYPE_MAT4 }
-        };
-
-        enum MeshMode
-        {
-            // No MESH_UNKNOWN because the default of 0 is a valid value in the spec
-            // prefix to avoid name conflicts
-            MESH_POINTS = 0,
-            MESH_LINES = 1,
-            MESH_LINE_LOOP = 2,
-            MESH_LINE_STRIP = 3,
-            MESH_TRIANGLES = 4,
-            MESH_TRIANGLE_STRIP = 5,
-            MESH_TRIANGLE_FAN = 6
-        };
-
-        enum AlphaMode
-        {
-            ALPHA_UNKNOWN = 0,
-            ALPHA_OPAQUE,
-            ALPHA_BLEND,
-            ALPHA_MASK
-        };
-
-        enum TargetPath
-        {
-            TARGET_UNKNOWN = 0,
-            TARGET_TRANSLATION,
-            TARGET_ROTATION,
-            TARGET_SCALE,
-            TARGET_WEIGHTS
-        };
-
-        enum InterpolationType
-        {
-            INTERPOLATION_UNKNOWN = 0,
-            INTERPOLATION_LINEAR,
-            INTERPOLATION_STEP,
-            INTERPOLATION_CUBICSPLINE
-        };
-
-        enum TransformationType
-        {
-            TRANSFORMATION_IDENTITY = 0,
-            TRANSFORMATION_MATRIX,
-            TRANSFORMATION_TRS
-        };
-
-        enum ProjectionType
-        {
-            PROJECTION_PERSPECTIVE,
-            PROJECTION_ORTHOGRAPHIC
-        };
-
-        inline AlphaMode ParseAlphaMode(const std::string& alphaMode)
-        {
-            if (alphaMode == ALPHAMODE_NAME_OPAQUE) {
-                return ALPHA_OPAQUE;
-            }
-            if (alphaMode == ALPHAMODE_NAME_BLEND) {
-                return ALPHA_BLEND;
-            }
-            if (alphaMode == ALPHAMODE_NAME_MASK) {
-                return ALPHA_MASK;
-            }
-
-            return ALPHA_UNKNOWN;
-        }
-
-        inline TargetPath ParseTargetPath(const std::string& targetPath)
-        {
-            if (targetPath == TARGETPATH_NAME_TRANSLATION)
-            {
-                return TARGET_TRANSLATION;
-            }
-            if (targetPath == TARGETPATH_NAME_ROTATION)
-            {
-                return TARGET_ROTATION;
-            }
-            if (targetPath == TARGETPATH_NAME_SCALE)
-            {
-                return TARGET_SCALE;
-            }
-            if (targetPath == TARGETPATH_NAME_WEIGHTS)
-            {
-                return TARGET_WEIGHTS;
-            }
-
-            return TARGET_UNKNOWN;
-        }
-
-        inline InterpolationType ParseInterpolationType(const std::string& interpolationType)
-        {
-            if (interpolationType == INTERPOLATIONTYPE_NAME_LINEAR)
-            {
-                return INTERPOLATION_LINEAR;
-            }
-            if (interpolationType == INTERPOLATIONTYPE_NAME_STEP)
-            {
-                return INTERPOLATION_STEP;
-            }
-            if (interpolationType == INTERPOLATIONTYPE_NAME_CUBICSPLINE)
-            {
-                return INTERPOLATION_CUBICSPLINE;
-            }
-
-            return INTERPOLATION_UNKNOWN;
-        }
-
-        struct glTFProperty
-        {
-            virtual ~glTFProperty() = default;
-
-            std::unordered_map<std::string, std::string> extensions;
-            std::string extras;
-
-            template<typename TExt, typename ...TArgs>
-            void SetExtension(TArgs&& ...args)
-            {
-                SetExtension(std::make_unique<TExt>(std::forward<TArgs>(args)...));
-            }
-
-            void SetExtension(std::unique_ptr<Extension>&& extension)
-            {
-                const auto& typeExpr = *extension; // Workaround for clang -Wpotentially-evaluated-expression
-                const auto& typeInfo = typeid(typeExpr);
-
-                registeredExtensions.emplace(typeInfo, std::move(extension));
-            }
-
-            template<typename T>
-            const T& GetExtension() const
-            {
-                auto it = registeredExtensions.find(typeid(T));
-                if (it != registeredExtensions.end())
-                {
-                    return static_cast<T&>(*it->second.get());
-                }
-
-                throw GLTFException(std::string("Could not find extension: ") + typeid(T).name());
-            }
-
-            template<typename T>
-            T& GetExtension()
-            {
-                auto it = registeredExtensions.find(typeid(T));
-                if (it != registeredExtensions.end())
-                {
-                    return static_cast<T&>(*it->second.get());
-                }
-
-                throw GLTFException(std::string("Could not find extension: ") + typeid(T).name());
-            }
-
-            std::vector<std::reference_wrapper<Extension>> GetExtensions() const
-            {
-                std::vector<std::reference_wrapper<Extension>> exts;
-
-                for (auto& registeredExt : registeredExtensions)
-                {
-                    exts.push_back(*registeredExt.second);
-                }
-
-                return exts;
-            }
-
-            template<typename T>
-            bool HasExtension() const
-            {
-                return registeredExtensions.find(typeid(T)) != registeredExtensions.end();
-            }
-
-            bool HasUnregisteredExtension(const std::string& name) const
-            {
-                return extensions.find(name) != extensions.end();
-            }
-
-            template<typename T>
-            void RemoveExtension()
-            {
-                registeredExtensions.erase(typeid(T));
-            }
-
-        protected:
-            glTFProperty() = default;
-
-            glTFProperty(const glTFProperty& other) : extensions(other.extensions), extras(other.extras)
-            {
-                for(const auto& ext : other.registeredExtensions)
-                {
-                    registeredExtensions.emplace(ext.first, ext.second->Clone());
-                }
-            }
-
-            glTFProperty& operator=(const glTFProperty& other)
-            {
-                if (this != &other)
-                {
-                    glTFProperty otherCopy(other);
-
-                    extensions = std::move(otherCopy.extensions);
-                    registeredExtensions = std::move(otherCopy.registeredExtensions);
-                    extras = std::move(otherCopy.extras);
-                }
-
-                return *this;
-            }
-
-            static bool Equals(const glTFProperty& lhs, const glTFProperty& rhs)
-            {
-                auto fnRegisteredExtensionsEquals = [](const glTFProperty& lhs, const glTFProperty& rhs)
-                {
-                    if (lhs.registeredExtensions.size() == rhs.registeredExtensions.size())
-                    {
-                        return std::all_of(
-                            lhs.registeredExtensions.begin(),
-                            lhs.registeredExtensions.end(),
-                            [&rhs](const std::pair<const std::type_index, std::unique_ptr<Extension>>& value)
-                        {
-                            auto it = rhs.registeredExtensions.find(value.first);
-
-                            if (it != rhs.registeredExtensions.end())
-                            {
-                                return *it->second == *value.second;
-                            }
-
-                            return false;
-                        });
-                    }
-
-                    return false;
-                };
-
-                return lhs.extensions == rhs.extensions
-                    && lhs.extras == rhs.extras
-                    && fnRegisteredExtensionsEquals(lhs, rhs);
-            }
-
-        private:
-            std::unordered_map<std::type_index, std::unique_ptr<Extension>> registeredExtensions;
-        };
-
-        struct glTFChildOfRootProperty : glTFProperty
-        {
-            std::string id;
-            std::string name;
-
-        protected:
-            glTFChildOfRootProperty() = default;
-            glTFChildOfRootProperty(std::string id, std::string name) : id(std::move(id)), name(std::move(name)) {}
-
-            static bool Equals(const glTFChildOfRootProperty& lhs, const glTFChildOfRootProperty& rhs)
-            {
-                return lhs.id == rhs.id
-                    && lhs.name == rhs.name
-                    && glTFProperty::Equals(lhs, rhs);
-            }
-        };
-
-        struct BufferView : glTFChildOfRootProperty
-        {
-            std::string bufferId;
-            size_t byteOffset = 0U;
-            size_t byteLength = 0U;
-            Optional<size_t> byteStride;
-            Optional<BufferViewTarget> target;
-
-            bool operator==(const BufferView& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->bufferId == rhs.bufferId
-                    && this->byteOffset == rhs.byteOffset
-                    && this->byteLength == rhs.byteLength
-                    && this->byteStride == rhs.byteStride
-                    && this->target == rhs.target;
-            }
-
-            bool operator!=(const BufferView& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct Accessor : glTFChildOfRootProperty
-        {
-            // TODO: Sparse is glTFProperty
-            struct Sparse
-            {
-                Sparse() :
-                    count(0U),
-                    indicesComponentType(COMPONENT_UNKNOWN),
-                    indicesByteOffset(0U),
-                    valuesByteOffset(0U)
-                {
-                }
-
-                size_t count;
-                // TODO: indices is glTFProperty
-                std::string indicesBufferViewId;
-                ComponentType indicesComponentType;
-                size_t indicesByteOffset;
-                // TODO: values is glTFProperty
-                std::string valuesBufferViewId;
-                size_t valuesByteOffset;
-
-                bool operator==(const Sparse& rhs) const
-                {
-                    return this->count == rhs.count
-                        && this->indicesBufferViewId == rhs.indicesBufferViewId
-                        && this->indicesComponentType == rhs.indicesComponentType
-                        && this->indicesByteOffset == rhs.indicesByteOffset
-                        && this->valuesBufferViewId == rhs.valuesBufferViewId
-                        && this->valuesByteOffset == rhs.valuesByteOffset;
-                }
-
-                bool operator!=(const Sparse& rhs) const
-                {
-                    return !operator==(rhs);
-                }
-            };
-
-            std::string bufferViewId;
-            size_t byteOffset = 0U;
-            ComponentType componentType = COMPONENT_UNKNOWN;
-            bool normalized = false;
-            size_t count = 0U;
-            AccessorType type = TYPE_UNKNOWN;
-
-            std::vector<float> max;
-            std::vector<float> min;
-
-            Sparse sparse;
-
-            // std::string -> AccessorType
-            static AccessorType ParseType(const std::string& type)
-            {
-                const auto result = AccessorTypes.find(type);
-                if (result != AccessorTypes.end())
-                {
-                    return result->second;
-                }
-                throw GLTFException("Unknown type " + type);
-            }
-
-            // AccessorType -> std::string
-            static std::string GetAccessorTypeName(AccessorType type)
-            {
-                switch (type)
-                {
-                case TYPE_SCALAR:
-                    return TYPE_NAME_SCALAR;
-                case TYPE_VEC2:
-                    return TYPE_NAME_VEC2;
-                case TYPE_VEC3:
-                    return TYPE_NAME_VEC3;
-                case TYPE_VEC4:
-                    return TYPE_NAME_VEC4;
-                case TYPE_MAT2:
-                    return TYPE_NAME_MAT2;
-                case TYPE_MAT3:
-                    return TYPE_NAME_MAT3;
-                case TYPE_MAT4:
-                    return TYPE_NAME_MAT4;
-                default:
-                    throw GLTFException("Unknown type " + std::to_string(type));
-                }
-            }
-
-            // count(AccessorType)
-            static uint8_t GetTypeCount(AccessorType type)
-            {
-                switch (type)
-                {
-                case TYPE_SCALAR:
-                    return 1;
-                case TYPE_VEC2:
-                    return 2;
-                case TYPE_VEC3:
-                    return 3;
-                case TYPE_VEC4:
-                case TYPE_MAT2:
-                    return 4;
-                case TYPE_MAT3:
-                    return 9;
-                case TYPE_MAT4:
-                    return 16;
-                default:
-                    throw GLTFException("Unknown type " + std::to_string(type));
-                }
-            }
-
-            // uint32_t -> ComponentType
-            static ComponentType GetComponentType(uint32_t value)
-            {
-                switch (value)
-                {
-                case COMPONENT_BYTE:
-                    return COMPONENT_BYTE;
-                case COMPONENT_UNSIGNED_BYTE:
-                    return COMPONENT_UNSIGNED_BYTE;
-                case COMPONENT_SHORT:
-                    return COMPONENT_SHORT;
-                case COMPONENT_UNSIGNED_SHORT:
-                    return COMPONENT_UNSIGNED_SHORT;
-                case COMPONENT_UNSIGNED_INT:
-                    return COMPONENT_UNSIGNED_INT;
-                case COMPONENT_FLOAT:
-                    return COMPONENT_FLOAT;
-                default:
-                    return COMPONENT_UNKNOWN;
-                }
-            }
-
-            // ComponentType -> std::string
-            static std::string GetComponentTypeName(ComponentType componentType)
-            {
-                switch (componentType)
-                {
-                case COMPONENT_BYTE:
-                    return COMPONENT_TYPE_NAME_BYTE;
-                case COMPONENT_UNSIGNED_BYTE:
-                    return COMPONENT_TYPE_NAME_UNSIGNED_BYTE;
-                case COMPONENT_SHORT:
-                    return COMPONENT_TYPE_NAME_SHORT;
-                case COMPONENT_UNSIGNED_SHORT:
-                    return COMPONENT_TYPE_NAME_UNSIGNED_SHORT;
-                case COMPONENT_UNSIGNED_INT:
-                    return COMPONENT_TYPE_NAME_UNSIGNED_INT;
-                case COMPONENT_FLOAT:
-                    return COMPONENT_TYPE_NAME_FLOAT;
-                default:
-                    throw GLTFException("Unknown componentType " + std::to_string(componentType));
-                }
-            }
-
-            // size(ComponentType)
-            static uint8_t GetComponentTypeSize(ComponentType componentType)
-            {
-                switch (componentType)
-                {
-                case COMPONENT_BYTE:
-                case COMPONENT_UNSIGNED_BYTE:
-                    return 1;
-                case COMPONENT_SHORT:
-                case COMPONENT_UNSIGNED_SHORT:
-                    return 2;
-                case COMPONENT_UNSIGNED_INT:
-                case COMPONENT_FLOAT:
-                    return 4;
-                default:
-                    throw GLTFException("Unknown componentType " + std::to_string(componentType));
-                }
-            }
-
-            size_t GetByteLength() const
-            {
-                return count * GetComponentTypeSize(componentType) * GetTypeCount(type);
-            }
-
-            bool operator==(const Accessor& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->bufferViewId == rhs.bufferViewId
-                    && this->byteOffset == rhs.byteOffset
-                    && this->componentType == rhs.componentType
-                    && this->normalized == rhs.normalized
-                    && this->count == rhs.count
-                    && this->type == rhs.type
-                    && this->max == rhs.max
-                    && this->min == rhs.min
-                    && this->sparse == rhs.sparse;
-            }
-
-            bool operator!=(const Accessor& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct MorphTarget
-        {
-            std::string positionsAccessorId;
-            std::string normalsAccessorId;
-            std::string tangentsAccessorId;
-            bool operator==(const MorphTarget& rhs) const
-            {
-                return this->positionsAccessorId == rhs.positionsAccessorId
-                    && this->normalsAccessorId == rhs.normalsAccessorId
-                    && this->tangentsAccessorId == rhs.tangentsAccessorId;
-            }
-
-            bool operator!=(const MorphTarget& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct MeshPrimitive : glTFProperty
-        {
-            std::unordered_map<std::string, std::string> attributes;
-
-            std::string indicesAccessorId;
-
-            std::string materialId;
-            MeshMode mode = MESH_TRIANGLES;
-            std::vector<MorphTarget> targets;
-
-            bool HasAttribute(const std::string& name) const
-            {
-                return attributes.find(name) != attributes.end();
-            }
-
-            const std::string& GetAttributeAccessorId(const std::string& name) const
-            {
-                auto it = attributes.find(name);
-
-                if (it != attributes.end())
-                {
-                    return it->second;
-                }
-
-                throw GLTFException("Mesh primitive has no attribute named " + name);
-            }
-
-            bool TryGetAttributeAccessorId(const std::string& name, std::string& accessorId) const
-            {
-                auto it = attributes.find(name);
-
-                if (it != attributes.end())
-                {
-                    accessorId = it->second;
-                    return true;
-                }
-
-                return false;
-            }
-
-            bool operator==(const MeshPrimitive& rhs) const
-            {
-                return glTFProperty::Equals(*this, rhs)
-                    && this->attributes == rhs.attributes
-                    && this->indicesAccessorId == rhs.indicesAccessorId
-                    && this->materialId == rhs.materialId
-                    && this->mode == rhs.mode
-                    && this->targets == rhs.targets;
-            }
-
-            bool operator!=(const MeshPrimitive& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct Mesh : glTFChildOfRootProperty
-        {
-            std::vector<MeshPrimitive> primitives;
-            std::vector<float> weights;
-
-            bool operator==(const Mesh& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->primitives == rhs.primitives
-                    && this->weights == rhs.weights;
-            }
-
-            bool operator!=(const Mesh& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct Buffer : glTFChildOfRootProperty
-        {
-            std::string uri;
-            size_t byteLength = 0U;
-
-            bool operator==(const Buffer& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->uri == rhs.uri
-                    && this->byteLength == rhs.byteLength;
-            }
-
-            bool operator!=(const Buffer& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct Asset : glTFProperty
-        {
-            std::string copyright;
-            std::string generator;
-            std::string version;
-            std::string minVersion;
-
-            Asset() : version(GLTF_VERSION_2_0)
-            {
-            }
-
-            bool operator==(const Asset& rhs) const
-            {
-                return glTFProperty::Equals(*this, rhs)
-                    && this->copyright == rhs.copyright
-                    && this->generator == rhs.generator
-                    && this->version == rhs.version
-                    && this->minVersion == rhs.minVersion;
-            }
-
-            bool operator!=(const Asset& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        enum class TextureType
-        {
-            BaseColor,
-            MetallicRoughness,
-            Normal,
-            Occlusion,
-            Emissive
-        };
-
-        struct TextureInfo : glTFProperty
-        {
-            std::string textureId;
-            size_t texCoord = 0U;
-
-            bool operator==(const TextureInfo& rhs) const
-            {
-                return TextureInfo::Equals(*this, rhs);
-            }
-
-            bool operator!=(const TextureInfo& rhs) const
-            {
-                return !operator==(rhs);
-            }
-
-        protected:
-            static bool Equals(const TextureInfo& lhs, const TextureInfo& rhs)
-            {
-                return lhs.textureId == rhs.textureId
-                    && lhs.texCoord == rhs.texCoord
-                    && glTFProperty::Equals(lhs, rhs);
-            }
-        };
-
-        // https://github.com/KhronosGroup/glTF/blob/2.0/specification/2.0/schema/material.schema.json
-        struct Material : glTFChildOfRootProperty
-        {
-            struct PBRMetallicRoughness : glTFProperty
-            {
-                PBRMetallicRoughness() :
-                    baseColorFactor(1.0f, 1.0f, 1.0f, 1.0f),
-                    metallicFactor(1.0f),
-                    roughnessFactor(1.0f)
-                {
-                }
-
-                Color4 baseColorFactor;
-                TextureInfo baseColorTexture;
-                float metallicFactor;
-                float roughnessFactor;
-                TextureInfo metallicRoughnessTexture;
-
-                bool operator==(const PBRMetallicRoughness& rhs) const
-                {
-                    return this->baseColorFactor == rhs.baseColorFactor
-                        && this->baseColorTexture == rhs.baseColorTexture
-                        && this->metallicFactor == rhs.metallicFactor
-                        && this->roughnessFactor == rhs.roughnessFactor
-                        && this->metallicRoughnessTexture == rhs.metallicRoughnessTexture;
-                }
-
-                bool operator!=(const PBRMetallicRoughness& rhs) const
-                {
-                    return !operator==(rhs);
-                }
-            };
-
-            struct NormalTextureInfo : TextureInfo
-            {
-                NormalTextureInfo() :
-                    scale(1.0f)
-                {
-                }
-
-                float scale;
-
-                bool operator==(const NormalTextureInfo& rhs) const
-                {
-                    return TextureInfo::Equals(*this, rhs)
-                        && this->scale == rhs.scale;
-                }
-
-                bool operator!=(const NormalTextureInfo& rhs) const
-                {
-                    return !operator==(rhs);
-                }
-            };
-
-            struct OcclusionTextureInfo : TextureInfo
-            {
-                OcclusionTextureInfo() :
-                    strength(1.0f)
-                {
-                }
-
-                float strength;
-
-                bool operator==(const OcclusionTextureInfo& rhs) const
-                {
-                    return TextureInfo::Equals(*this, rhs)
-                        && this->strength == rhs.strength;
-                }
-
-                bool operator!=(const OcclusionTextureInfo& rhs) const
-                {
-                    return !operator==(rhs);
-                }
-            };
-
-            Material() :
-                emissiveFactor(0.0f, 0.0f, 0.0f),
-                alphaMode(ALPHA_OPAQUE),
-                alphaCutoff(0.5f),
-                doubleSided(false)
-            {
-            }
-
-            PBRMetallicRoughness metallicRoughness;
-            NormalTextureInfo normalTexture;
-            OcclusionTextureInfo occlusionTexture;
-            TextureInfo emissiveTexture;
-            Color3 emissiveFactor;
-            AlphaMode alphaMode;
-            float alphaCutoff;
-            bool doubleSided;
-
-            std::vector<std::pair<std::string, TextureType>> GetTextures() const
-            {
-                return {
-                    { metallicRoughness.baseColorTexture.textureId, TextureType::BaseColor },
-                    { metallicRoughness.metallicRoughnessTexture.textureId, TextureType::MetallicRoughness },
-                    { normalTexture.textureId, TextureType::Normal },
-                    { occlusionTexture.textureId, TextureType::Occlusion },
-                    { emissiveTexture.textureId, TextureType::Emissive }
-                };
-            }
-
-            bool operator==(const Material& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->metallicRoughness == rhs.metallicRoughness
-                    && this->normalTexture == rhs.normalTexture
-                    && this->occlusionTexture == rhs.occlusionTexture
-                    && this->emissiveTexture == rhs.emissiveTexture
-                    && this->emissiveFactor == rhs.emissiveFactor
-                    && this->alphaMode == rhs.alphaMode
-                    && this->alphaCutoff == rhs.alphaCutoff
-                    && this->doubleSided == rhs.doubleSided;
-            }
-
-            bool operator!=(const Material& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        // Textures that references an Image
-        struct Texture : glTFChildOfRootProperty
-        {
-            std::string samplerId;
-            std::string imageId; // Corresponds to 'source' in the schema
-
-            bool operator==(const Texture& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->samplerId == rhs.samplerId
-                    && this->imageId == rhs.imageId;
-            }
-
-            bool operator!=(const Texture& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        // Images of any type (e.g. PNG) referenced by URI or embedded in the binary buffer. Also supports base64 encoded images.
-        struct Image : glTFChildOfRootProperty
-        {
-            std::string uri;
-            std::string mimeType;
-            std::string bufferViewId;
-
-            bool operator==(const Image& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->uri == rhs.uri
-                    && this->mimeType == rhs.mimeType
-                    && this->bufferViewId == rhs.bufferViewId;
-            }
-
-            bool operator!=(const Image& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct Projection : glTFProperty
-        {
-            float znear;
-
-            virtual ProjectionType GetProjectionType() const = 0;
-            virtual std::unique_ptr<Projection> Clone() const = 0;
-            
-            virtual bool IsValid() const = 0;
-
-            bool operator==(const Projection& rhs) const
-            {
-                return IsEqual(rhs);
-            }
-
-            bool operator!=(const Projection& rhs) const
-            {
-                return !operator==(rhs);
-            }
-
-        protected:
-            Projection(float znear) : znear(znear)
-            {
-            }
-
-            virtual bool IsEqual(const Projection& rhs) const
-            {
-                return glTFProperty::Equals(*this, rhs)
-                    && this->znear == rhs.znear;
-            }
-        };
-
-        struct Orthographic : Projection
-        {
-            float xmag;
-            float ymag;
-            float zfar;
-
-            Orthographic(float zfar, float znear, float xmag, float ymag) :
-                Projection(znear),
-                xmag(xmag),
-                ymag(ymag),
-                zfar(zfar)
-            {
-            }
-
-            bool IsValid() const override
-            {
-                return (zfar > znear)
-                    && (ymag != 0.0)
-                    && (xmag != 0.0);
-            }
-
-            ProjectionType GetProjectionType() const override
-            {
-                return PROJECTION_ORTHOGRAPHIC;
-            }
-
-            std::unique_ptr<Projection> Clone() const override
-            {
-                return std::make_unique<Orthographic>(*this);
-            }
-
-            bool IsEqual(const Projection& rhs) const override
-            {
-                if (const auto other = dynamic_cast<const Orthographic*>(&rhs))
-                {
-                    return Projection::IsEqual(rhs)
-                        && xmag == other->xmag
-                        && ymag == other->ymag
-                        && zfar == other->zfar;
-                }
-
-                return false;
-            }
-        };
-
-        struct Perspective : Projection
-        {
-            Optional<float> aspectRatio;
-            float yfov;
-            Optional<float> zfar;
-
-            Perspective(float znear, float yfov) :
-                Projection(znear),
-                aspectRatio(),
-                yfov(yfov),
-                zfar()
-            {
-            }
-
-            Perspective(float zfar, float znear, float aspectRatio, float yfov) :
-                Projection(znear),
-                aspectRatio(aspectRatio),
-                yfov(yfov),
-                zfar(zfar)
-            {
-            }
-
-            bool IsValid() const override
-            {
-                return !zfar.HasValue() || (zfar.Get() > znear);
-            }
-
-            bool IsFinite() const
-            {
-                return zfar.HasValue(); // If zfar is undefined the runtime must use an infinite projection matrix
-            }
-
-            bool HasCustomAspectRatio() const
-            {
-                return aspectRatio.HasValue(); // When aspectRatio is undefined the aspect ratio of the 'canvas' should be used
-            }
-
-            ProjectionType GetProjectionType() const override
-            {
-                return PROJECTION_PERSPECTIVE;
-            }
-
-            std::unique_ptr<Projection> Clone() const override
-            {
-                return std::make_unique<Perspective>(*this);
-            }
-
-            bool IsEqual(const Projection& rhs) const override
-            {
-                if (const auto other = dynamic_cast<const Perspective*>(&rhs))
-                {
-                    return Projection::IsEqual(rhs)
-                        && aspectRatio == other->aspectRatio
-                        && yfov == other->yfov
-                        && zfar == other->zfar;
-                }
-
-                return false;
-            }
-        };
-
-        struct Camera : glTFChildOfRootProperty
-        {
-            std::unique_ptr<Projection> projection;
-
-            Camera(std::unique_ptr<Projection> projection) :
-                glTFChildOfRootProperty(),
-                projection(std::move(projection))
-            {
-                if (!(this->projection))
-                {
-                    throw GLTFException("Cannot create camera with null projection");
-                }
-            }
-
-            Camera(std::string id, std::string name, std::unique_ptr<Projection> projection) :
-                glTFChildOfRootProperty(std::move(id), std::move(name)),
-                projection(std::move(projection))
-            {
-                if (!(this->projection))
-                {
-                    throw GLTFException("Cannot create camera with null projection");
-                }
-            }
-
-            Camera(const Camera& rhs) :
-                glTFChildOfRootProperty(rhs),
-                projection(rhs.projection->Clone())
-            {
-            }
-
-            const Perspective& GetPerspective() const
-            {
-                if (const auto ret = dynamic_cast<Perspective*>(projection.get()))
-                {
-                    return *ret;
-                }
-
-                throw GLTFException("Failed to cast projection to orthographic");
-            }
-
-            const Orthographic& GetOrthographic() const
-            {
-                if (const auto ret = dynamic_cast<Orthographic*>(projection.get()))
-                {
-                    return *ret;
-                }
-
-                throw GLTFException("Failed to cast projection to orthographic");
-            }
-
-            bool operator==(const Camera& rhs) const
-            {
-                if (!glTFChildOfRootProperty::Equals(*this, rhs))
-                {
-                    return false;
-                }
-
-                if (!projection || !rhs.projection)
-                {
-                    return !projection && !rhs.projection;
-                }
-
-                return *projection == *(rhs.projection);
-            }
-
-            bool operator!=(const Camera& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/node.schema.json
-        struct Node : glTFChildOfRootProperty
-        {
-            std::string cameraId;
-            std::vector<std::string> children;
-            std::string skinId;
-            Matrix4 matrix;
-            std::string meshId;
-            Quaternion rotation = Quaternion::IDENTITY;
-            Vector3 scale = Vector3::ONE;
-            Vector3 translation = Vector3::ZERO;
-            std::vector<float> weights;
-
-            bool IsEmpty() const
-            {
-                return children.empty() && meshId.empty() && skinId.empty();
-            }
-
-            // It is invalid to have both 'matrix' and any of 'translation'/'rotation'/'scale'
-            //   spec: "A node can have either a 'matrix' or any combination of 'translation'/'rotation'/'scale' (TRS) properties"
-            bool HasValidTransformType() const
-            {
-                return matrix == Matrix4::IDENTITY || HasIdentityTRS();
-            }
-
-            TransformationType GetTransformationType() const
-            {
-                if (matrix != Matrix4::IDENTITY)
-                {
-                    return TRANSFORMATION_MATRIX;
-                }
-
-                if (!HasIdentityTRS())
-                {
-                    return TRANSFORMATION_TRS;
-                }
-
-                return TRANSFORMATION_IDENTITY;
-            }
-
-            bool HasIdentityTRS() const
-            {
-                return translation == Vector3::ZERO
-                    && rotation == Quaternion::IDENTITY
-                    && scale == Vector3::ONE;
-            }
-
-            bool operator==(const Node& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->cameraId == rhs.cameraId
-                    && this->children == rhs.children
-                    && this->skinId == rhs.skinId
-                    && this->matrix == rhs.matrix
-                    && this->meshId == rhs.meshId
-                    && this->rotation == rhs.rotation
-                    && this->scale == rhs.scale
-                    && this->translation == rhs.translation
-                    && this->weights == rhs.weights;
-            }
-
-            bool operator!=(const Node& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct Scene : glTFChildOfRootProperty
-        {
-            std::vector<std::string> nodes;
-
-            bool operator==(const Scene& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->nodes == rhs.nodes;
-            }
-
-            bool operator!=(const Scene& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        enum MagFilterMode
-        {
-            MagFilter_NEAREST = 9728,
-            MagFilter_LINEAR = 9729,
-        };
-
-        enum MinFilterMode
-        {
-            MinFilter_NEAREST = 9728,
-            MinFilter_LINEAR = 9729,
-            MinFilter_NEAREST_MIPMAP_NEAREST = 9984,
-            MinFilter_LINEAR_MIPMAP_NEAREST = 9985,
-            MinFilter_NEAREST_MIPMAP_LINEAR = 9986,
-            MinFilter_LINEAR_MIPMAP_LINEAR = 9987
-        };
-
-        enum WrapMode
-        {
-            Wrap_REPEAT = 10497,
-            Wrap_CLAMP_TO_EDGE = 33071,
-            Wrap_MIRRORED_REPEAT = 33648
-        };
-
-        struct Sampler : glTFChildOfRootProperty
-        {
-            // The glTF spec doesn't define default values for magFilter and minFilter members. When
-            // filtering options are not defined implementations are free to select a suitable value
-            Optional<MagFilterMode> magFilter;
-            Optional<MinFilterMode> minFilter;
-            WrapMode wrapS = Wrap_REPEAT;
-            WrapMode wrapT = Wrap_REPEAT;
-
-            static MinFilterMode GetSamplerMinFilterMode(size_t readValue)
-            {
-                switch (readValue)
-                {
-                    case MinFilter_NEAREST:
-                        return MinFilter_NEAREST;
-                    case MinFilter_LINEAR:
-                        return MinFilter_LINEAR;
-                    case MinFilter_NEAREST_MIPMAP_NEAREST:
-                        return MinFilter_NEAREST_MIPMAP_NEAREST;
-                    case MinFilter_LINEAR_MIPMAP_NEAREST:
-                        return MinFilter_LINEAR_MIPMAP_NEAREST;
-                    case MinFilter_NEAREST_MIPMAP_LINEAR:
-                        return MinFilter_NEAREST_MIPMAP_LINEAR;
-                    case MinFilter_LINEAR_MIPMAP_LINEAR:
-                        return MinFilter_LINEAR_MIPMAP_LINEAR;
-                    default:
-                        throw InvalidGLTFException("Invalid sampler min filter value: " + std::to_string(readValue));
-                }
-            }
-
-            static MagFilterMode GetSamplerMagFilterMode(size_t readValue)
-            {
-                switch (readValue)
-                {
-                    case MagFilter_NEAREST:
-                        return MagFilter_NEAREST;
-                    case MagFilter_LINEAR:
-                        return MagFilter_LINEAR;
-                    default:
-                        throw InvalidGLTFException("Invalid sampler mag filter value: " + std::to_string(readValue));
-                }
-            }
-
-            static WrapMode GetSamplerWrapMode(size_t readValue)
-            { 
-                switch (readValue)
-                {
-                    case Wrap_CLAMP_TO_EDGE:
-                        return Wrap_CLAMP_TO_EDGE;
-                    case Wrap_MIRRORED_REPEAT:
-                        return Wrap_MIRRORED_REPEAT;
-                    case Wrap_REPEAT:
-                        return Wrap_REPEAT;
-                    default:
-                        throw InvalidGLTFException("Invalid sampler wrap value: " + std::to_string(readValue));
-                }
-            }
-
-            bool operator==(const Sampler& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->magFilter == rhs.magFilter
-                    && this->minFilter == rhs.minFilter
-                    && this->wrapS == rhs.wrapS
-                    && this->wrapT == rhs.wrapT;
-            }
-
-            bool operator!=(const Sampler& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct AnimationTarget : glTFProperty
-        {
-            std::string nodeId;
-            TargetPath path = TARGET_UNKNOWN;
-
-            bool operator==(const AnimationTarget& rhs) const
-            {
-                return glTFProperty::Equals(*this, rhs)
-                    && this->nodeId == rhs.nodeId
-                    && this->path == rhs.path;
-            }
-
-            bool operator!=(const AnimationTarget& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct AnimationChannel : glTFProperty
-        {
-            std::string id;
-            std::string samplerId;
-            AnimationTarget target;
-
-            bool operator==(const AnimationChannel& rhs) const
-            {
-                return glTFProperty::Equals(*this, rhs)
-                    && this->id == rhs.id
-                    && this->samplerId == rhs.samplerId
-                    && this->target == rhs.target;
-            }
-
-            bool operator!=(const AnimationChannel& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-        
-        struct AnimationSampler : glTFProperty
-        {
-            std::string id;
-            std::string inputAccessorId;
-            InterpolationType interpolation = INTERPOLATION_LINEAR;
-            std::string outputAccessorId;
-
-            bool operator==(const AnimationSampler& rhs) const
-            {
-                return glTFProperty::Equals(*this, rhs)
-                    && this->id == rhs.id
-                    && this->inputAccessorId == rhs.inputAccessorId
-                    && this->interpolation == rhs.interpolation
-                    && this->outputAccessorId == rhs.outputAccessorId;
-            }
-
-            bool operator!=(const AnimationSampler& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct Animation : glTFChildOfRootProperty
-        {
-            IndexedContainer<const AnimationChannel> channels;
-            IndexedContainer<const AnimationSampler> samplers;
-
-            bool operator==(const Animation& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->channels == rhs.channels
-                    && this->samplers == rhs.samplers;
-            }
-
-            bool operator!=(const Animation& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-
-        struct Skin : glTFChildOfRootProperty
-        {
-            std::string inverseBindMatricesAccessorId;
-            std::string skeletonId;
-            std::vector<std::string> jointIds;
-
-            bool operator==(const Skin& rhs) const
-            {
-                return glTFChildOfRootProperty::Equals(*this, rhs)
-                    && this->inverseBindMatricesAccessorId == rhs.inverseBindMatricesAccessorId
-                    && this->skeletonId == rhs.skeletonId
-                    && this->jointIds == rhs.jointIds;
-            }
-
-            bool operator!=(const Skin& rhs) const
-            {
-                return !operator==(rhs);
-            }
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLTFResourceReader.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/GLTFResourceReader.h
deleted file mode 100644
index 2fe7304..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLTFResourceReader.h
+++ /dev/null
@@ -1,402 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Document.h>
-#include <GLTFSDK/IStreamReader.h>
-#include <GLTFSDK/ResourceReaderUtils.h>
-#include <GLTFSDK/StreamCacheLRU.h>
-#include <GLTFSDK/StreamUtils.h>
-#include <GLTFSDK/Validation.h>
-
-#include <cassert>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class GLTFResourceReader
-        {
-        public:
-            GLTFResourceReader(std::shared_ptr<const IStreamReader> streamReader)
-                : GLTFResourceReader(MakeStreamReaderCache<StreamReaderCacheLRU>(std::move(streamReader), 16U))
-            {
-            }
-
-            GLTFResourceReader(std::unique_ptr<IStreamReaderCache> streamCache)
-                : m_streamReaderCache(std::move(streamCache))
-            {
-            }
-
-            GLTFResourceReader(GLTFResourceReader&&) = default;
-
-            virtual ~GLTFResourceReader() = default;
-
-            // TODO: return mimeType of image
-            std::vector<uint8_t> ReadBinaryData(const Document& document, const Image& image) const
-            {
-                std::vector<uint8_t> data;
-
-                std::string::const_iterator itBegin;
-                std::string::const_iterator itEnd;
-
-                if (image.uri.empty())
-                {
-                    if (image.bufferViewId.empty())
-                    {
-                        throw GLTFException("Invalid image, both uri and bufferView are unspecified");
-                    }
-
-                    data = ReadBinaryData<uint8_t>(document, document.bufferViews.Get(image.bufferViewId));
-                }
-                else if (IsUriBase64(image.uri, itBegin, itEnd))
-                {
-                    data = ReadBinaryDataUri<uint8_t>({ itBegin, itEnd });
-                }
-                else if (auto stream = m_streamReaderCache->Get(image.uri))
-                {
-                    data = StreamUtils::ReadBinaryFull<uint8_t>(*stream);
-                }
-                else
-                {
-                    throw GLTFException("Unable to read image data");
-                }
-
-                return data;
-            }
-
-            template<typename T>
-            std::vector<T> ReadBinaryData(const Document& gltfDocument, const Accessor& accessor) const
-            {
-                bool isValid;
-
-                switch (accessor.componentType)
-                {
-                case COMPONENT_BYTE:
-                    isValid = std::is_same<T, int8_t>::value;
-                    break;
-                case COMPONENT_UNSIGNED_BYTE:
-                    isValid = std::is_same<T, uint8_t>::value;
-                    break;
-                case COMPONENT_SHORT:
-                    isValid = std::is_same<T, int16_t>::value;
-                    break;
-                case COMPONENT_UNSIGNED_SHORT:
-                    isValid = std::is_same<T, uint16_t>::value;
-                    break;
-                case COMPONENT_UNSIGNED_INT:
-                    isValid = std::is_same<T, uint32_t>::value;
-                    break;
-                case COMPONENT_FLOAT:
-                    isValid = std::is_same<T, float>::value;
-                    break;
-                default:
-                    throw GLTFException("Unsupported accessor ComponentType");
-                }
-
-                if (!isValid)
-                {
-                    throw GLTFException("ReadAccessorData: Template type T does not match accessor ComponentType");
-                }
-
-                Validation::ValidateAccessor(gltfDocument, accessor);
-
-                if (accessor.sparse.count > 0U)
-                {
-                    return ReadSparseAccessor<T>(gltfDocument, accessor);
-                }
-
-                return ReadAccessor<T>(gltfDocument, accessor);
-            }
-
-            template<typename T>
-            std::vector<T> ReadBinaryData(const Document& document, const BufferView& bufferView) const
-            {
-                const Buffer& buffer = document.buffers.Get(bufferView.bufferId);
-
-                Validation::ValidateBufferView(bufferView, buffer);
-
-                auto count = bufferView.byteLength / sizeof(T);
-                assert(bufferView.byteLength % sizeof(T) == 0);
-
-                return ReadBinaryData<T>(buffer, bufferView.byteOffset, count);
-            }
-
-            std::vector<float> ReadFloatData(const Document& gltfDocument, const Accessor& accessor) const;
-
-        protected:
-            template<typename T>
-            std::vector<T> ReadAccessor(const Document& gltfDocument, const Accessor& accessor) const
-            {
-                const auto typeCount = Accessor::GetTypeCount(accessor.type);
-                const auto elementSize = sizeof(T) * typeCount;
-
-                std::vector<T> data;
-
-                const BufferView& bufferView = gltfDocument.bufferViews.Get(accessor.bufferViewId);
-                const Buffer& buffer = gltfDocument.buffers.Get(bufferView.bufferId);
-
-                const size_t offset = accessor.byteOffset + bufferView.byteOffset;
-
-                if (!bufferView.byteStride || bufferView.byteStride.Get() == elementSize)
-                {
-                    data = ReadBinaryData<T>(buffer, offset, accessor.count * typeCount);
-                }
-                else
-                {
-                    data = ReadBinaryDataInterleaved<T>(buffer, offset, accessor.count, typeCount, bufferView.byteStride.Get());
-                }
-
-                return data;
-            }
-
-            template<typename T>
-            std::vector<T> ReadSparseAccessor(const Document& gltfDocument, const Accessor& accessor) const
-            {
-                const auto typeCount = Accessor::GetTypeCount(accessor.type);
-                const auto elementSize = sizeof(T) * typeCount;
-
-                std::vector<T> baseData;
-
-                if (accessor.bufferViewId.empty())
-                {
-                    baseData.resize(typeCount * accessor.count, T());
-                }
-                else
-                {
-                    const BufferView& bufferView = gltfDocument.bufferViews.Get(accessor.bufferViewId);
-                    const Buffer& buffer = gltfDocument.buffers.Get(bufferView.bufferId);
-
-                    const size_t offset = accessor.byteOffset + bufferView.byteOffset;
-
-                    if (!bufferView.byteStride || bufferView.byteStride.Get() == elementSize)
-                    {
-                        baseData = ReadBinaryData<T>(buffer, offset, accessor.count * typeCount);
-                    }
-                    else
-                    {
-                        baseData = ReadBinaryDataInterleaved<T>(buffer, offset, accessor.count, typeCount, bufferView.byteStride.Get());
-                    }
-                }
-
-                switch (accessor.sparse.indicesComponentType)
-                {
-                case COMPONENT_UNSIGNED_BYTE:
-                    ReadSparseBinaryData<T, uint8_t>(gltfDocument, baseData, accessor);
-                    break;
-                case COMPONENT_UNSIGNED_SHORT:
-                    ReadSparseBinaryData<T, uint16_t>(gltfDocument, baseData, accessor);
-                    break;
-                case COMPONENT_UNSIGNED_INT:
-                    ReadSparseBinaryData<T, uint32_t>(gltfDocument, baseData, accessor);
-                    break;
-                default:
-                    throw GLTFException("Unsupported sparse indices ComponentType");
-                }
-
-                return baseData;
-            }
-
-            virtual std::shared_ptr<std::istream> GetBinaryStream(const Buffer& buffer) const
-            {
-                if (buffer.uri.empty())
-                {
-                    throw GLTFException("Buffer.uri was not specified.");
-                }
-
-                return m_streamReaderCache->Get(buffer.uri);
-            }
-
-            virtual std::streampos GetBinaryStreamPos(const Buffer&) const
-            {
-                return {};
-            }
-
-        private:
-            void ReadBinaryDataUri(Base64StringView encodedData, Base64BufferView decodedData, const std::streamoff* offsetOverride = nullptr) const
-            {
-                // The number of unwanted extra bytes that must be decoded for the specified byte offset
-                size_t offsetAdjustment = 0;
-
-                if (offsetOverride)
-                {
-                    if (*offsetOverride < 0)
-                    {
-                        throw GLTFException("Negative offsets are not supported");
-                    }
-
-                    auto byteCount = static_cast<size_t>(*offsetOverride);
-                    offsetAdjustment = ByteCountToCharCountRemainder(byteCount);
-                    const size_t offsetBegin = ByteCountToCharCount(byteCount);
-
-                    if (offsetBegin < encodedData.GetCharCount())
-                    {
-                        encodedData.itBegin += offsetBegin;
-                    }
-                    else
-                    {
-                        throw GLTFException("Offset position as a base64 character index is outside the input range");
-                    }
-                }
-
-                auto offsetByteCount = decodedData.bufferByteLength + offsetAdjustment;
-                size_t offsetEnd = ByteCountToCharCount(offsetByteCount);
-
-                switch (ByteCountToCharCountRemainder(offsetByteCount))
-                {
-                case 1U:
-                    offsetEnd += 2U;// Decode 2 more characters for 1 extra byte
-                    break;
-                case 2U:
-                    offsetEnd += 3U;// Decode 3 more characters for 2 extra bytes
-                    break;
-                }
-
-                if (offsetEnd <= encodedData.GetCharCount())
-                {
-                    encodedData.itEnd = encodedData.itBegin + offsetEnd;
-                }
-                else
-                {
-                    throw GLTFException("Offset position as a base64 character index is outside the input range");
-                }
-
-                Base64Decode(encodedData, decodedData, offsetAdjustment);
-            }
-
-            template<typename T>
-            std::vector<T> ReadBinaryDataUri(Base64StringView encodedData, const std::streamoff* offsetOverride = nullptr, const size_t* componentCountOverride = nullptr) const
-            {
-                size_t componentCount;
-
-                if (componentCountOverride)
-                {
-                    componentCount = *componentCountOverride;
-                }
-                else
-                {
-                    componentCount = encodedData.GetByteCount() / sizeof(T);
-                }
-
-                std::vector<T> decodedData(componentCount);
-                ReadBinaryDataUri(encodedData, Base64BufferView(decodedData), offsetOverride);
-                return decodedData;
-            }
-
-            template<typename T>
-            std::vector<T> ReadBinaryData(const Buffer& buffer, std::streamoff offset, size_t componentCount) const
-            {
-                std::vector<T> data;
-
-                std::string::const_iterator itBegin;
-                std::string::const_iterator itEnd;
-
-                if (IsUriBase64(buffer.uri, itBegin, itEnd))
-                {
-                    data = ReadBinaryDataUri<T>({ itBegin, itEnd }, &offset, &componentCount);
-                }
-                else
-                {
-                    data.resize(componentCount);
-
-                    auto bufferStream = GetBinaryStream(buffer);
-                    auto bufferStreamPos = GetBinaryStreamPos(buffer);
-
-                    bufferStream->seekg(bufferStreamPos);
-                    bufferStream->seekg(offset, std::ios_base::cur);
-
-                    StreamUtils::ReadBinary(*bufferStream, reinterpret_cast<char*>(data.data()), componentCount * sizeof(T));
-                }
-
-                return data;
-            }
-
-            template<typename T>
-            std::vector<T> ReadBinaryDataInterleaved(const Buffer& buffer, std::streamoff offset, size_t elementCount, uint8_t typeCount, size_t stride) const
-            {
-                const size_t elementSize = sizeof(T) * typeCount;
-                const size_t componentCount = elementCount * typeCount;
-
-                std::vector<T> data(componentCount);
-
-                std::string::const_iterator itBegin;
-                std::string::const_iterator itEnd;
-
-                if (IsUriBase64(buffer.uri, itBegin, itEnd))
-                {
-                    Base64StringView encodedData(itBegin, itEnd);
-
-                    for (size_t componentsRead = 0U; componentsRead < componentCount; componentsRead += typeCount, offset += stride)
-                    {
-                        ReadBinaryDataUri(encodedData, Base64BufferView(data.data() + componentsRead, elementSize), &offset);
-                    }
-                }
-                else
-                {
-                    auto bufferStream = GetBinaryStream(buffer);
-                    auto bufferStreamPos = GetBinaryStreamPos(buffer) + offset;
-
-                    for (size_t componentsRead = 0U; componentsRead < componentCount; componentsRead += typeCount)
-                    {
-                        bufferStream->seekg(bufferStreamPos);
-                        bufferStreamPos += stride;
-
-                        StreamUtils::ReadBinary(*bufferStream, reinterpret_cast<char*>(data.data() + componentsRead), elementSize);
-                    }
-                }
-
-                return data;
-            }
-
-            template<typename T, typename I>
-            void ReadSparseBinaryData(const Document& gltfDocument, std::vector<T>& baseData, const Accessor& accessor) const
-            {
-                const auto typeCount = Accessor::GetTypeCount(accessor.type);
-                const auto elementSize = sizeof(T) * typeCount;
-
-                const size_t count = accessor.sparse.count;
-
-                const BufferView& indicesBufferView = gltfDocument.bufferViews.Get(accessor.sparse.indicesBufferViewId);
-                const Buffer& indicesBuffer = gltfDocument.buffers.Get(indicesBufferView.bufferId);
-                const size_t indicesOffset = accessor.sparse.indicesByteOffset + indicesBufferView.byteOffset;
-
-                const BufferView& valuesBufferView = gltfDocument.bufferViews.Get(accessor.sparse.valuesBufferViewId);
-                const Buffer& valuesBuffer = gltfDocument.buffers.Get(valuesBufferView.bufferId);
-                const size_t valuesOffset = accessor.sparse.valuesByteOffset + valuesBufferView.byteOffset;
-
-                std::vector<I> indices;
-
-                if (!indicesBufferView.byteStride || indicesBufferView.byteStride.Get() == sizeof(I))
-                {
-                    indices = ReadBinaryData<I>(indicesBuffer, indicesOffset, count);
-                }
-                else
-                {
-                    indices = ReadBinaryDataInterleaved<I>(indicesBuffer, indicesOffset, count, 1U, indicesBufferView.byteStride.Get());
-                }
-
-                std::vector<T> values;
-
-                if (!valuesBufferView.byteStride || valuesBufferView.byteStride.Get() == elementSize)
-                {
-                    values = ReadBinaryData<T>(valuesBuffer, valuesOffset, count * typeCount);
-                }
-                else
-                {
-                    values = ReadBinaryDataInterleaved<T>(valuesBuffer, valuesOffset, count, typeCount, valuesBufferView.byteStride.Get());
-                }
-
-                for (size_t i = 0; i < indices.size(); i++)
-                {
-                    for (size_t j = 0; j < typeCount; j++)
-                    {
-                        baseData[indices[i] * typeCount + j] = values[i * typeCount + j];
-                    }
-                }
-            }
-
-            std::unique_ptr<IStreamReaderCache> m_streamReaderCache;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLTFResourceWriter.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/GLTFResourceWriter.h
deleted file mode 100644
index 9c706d4..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/GLTFResourceWriter.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/ResourceWriter.h>
-
-#include <memory>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class IStreamWriter;
-
-        class GLTFResourceWriter : public ResourceWriter
-        {
-        public:
-            GLTFResourceWriter(std::shared_ptr<const IStreamWriter> streamWriter);
-            GLTFResourceWriter(std::unique_ptr<IStreamWriterCache> streamCache);
-
-            std::string GenerateBufferUri(const std::string& bufferId) const override;
-            void SetUriPrefix(std::string uriPrefix);
-
-        protected:
-            std::ostream*  GetBufferStream(const std::string& bufferId) override;
-            std::streamoff GetBufferOffset(const std::string& bufferId) override;
-            void           SetBufferOffset(const std::string& bufferId, std::streamoff offset) override;
-
-        private:
-            std::string m_uriPrefix;
-
-            std::unordered_map<std::string, std::streamoff> m_streamOffsets;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/IStreamCache.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/IStreamCache.h
deleted file mode 100644
index a8a03cb..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/IStreamCache.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <istream>
-#include <memory>
-#include <ostream>
-#include <string>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        template<typename TStream>
-        class IStreamCache
-        {
-        public:
-            virtual ~IStreamCache() = default;
-
-            // Returns a stream from the cache
-            //
-            // Note: Calls to Get must always succeed and return a valid stream. For a given uri
-            // Implementations of IStreamCache must automatically populate the cache with a stream
-            // if one does not already exist
-            virtual TStream Get(const std::string& uri) = 0;
-
-            // Explicitly populate the cache with the specified stream
-            virtual TStream Set(const std::string& uri, TStream stream) = 0;
-        };
-
-        typedef IStreamCache<std::shared_ptr<std::istream>> IStreamReaderCache;
-        typedef IStreamCache<std::shared_ptr<std::ostream>> IStreamWriterCache;
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/IStreamReader.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/IStreamReader.h
deleted file mode 100644
index ea5b881..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/IStreamReader.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <istream>
-#include <memory>
-#include <string>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class IStreamReader
-        {
-        public:
-            virtual ~IStreamReader() = default;
-            virtual std::shared_ptr<std::istream> GetInputStream(const std::string& filename) const = 0;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/IStreamWriter.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/IStreamWriter.h
deleted file mode 100644
index beede29..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/IStreamWriter.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <memory>
-#include <ostream>
-#include <string>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class IStreamWriter
-        {
-        public:
-            virtual ~IStreamWriter() = default;
-            virtual std::shared_ptr<std::ostream> GetOutputStream(const std::string& filename) const = 0;
-        };
-    }
-}
\ No newline at end of file
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/IndexedContainer.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/IndexedContainer.h
deleted file mode 100644
index 23ca90e..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/IndexedContainer.h
+++ /dev/null
@@ -1,276 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Exceptions.h>
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        // Empty strings aren't valid ids. AppendIdPolicy enum values control what
-        // happens when the Append function encounters an element with an empty id
-        //
-        // ThrowOnEmpty    - A GLTFException is thrown when trying to Append an
-        //                   element with an empty id.
-        // GenerateOnEmpty - A unique id is generated and assigned to the element
-        //                   stored in the IndexedContainer. Use the reference
-        //                   returned by Append to determine the id generated.
-        enum class AppendIdPolicy
-        {
-            ThrowOnEmpty,
-            GenerateOnEmpty
-        };
-
-        template<typename T, bool = std::is_const<T>::value>
-        class IndexedContainer;
-
-        // Const template parameter T partial specialization
-        template<typename T>
-        class IndexedContainer<const T, true>
-        {
-        public:
-            const T& Front() const
-            {
-                return m_elements.front();
-            }
-
-            const T& Back() const
-            {
-                return m_elements.back();
-            }
-
-            const T& operator[](size_t index) const
-            {
-                if (index < m_elements.size())
-                {
-                    return m_elements[index]; // operator[] used rather than at() to avoid unnecessary bounds checking
-                }
-
-                throw GLTFException("index " + std::to_string(index) + " not in container");
-            }
-
-            const T& operator[](const std::string& key) const
-            {
-                return operator[](GetIndex(key));
-            }
-
-            bool operator==(const IndexedContainer& rhs) const
-            {
-                return (m_elements == rhs.m_elements);
-            }
-
-            bool operator!=(const IndexedContainer& rhs) const
-            {
-                return !(operator==(rhs));
-            }
-
-            const T& Append(const T& element, AppendIdPolicy policy = AppendIdPolicy::ThrowOnEmpty)
-            {
-                return Append(T(element), policy);
-            }
-
-            const T& Append(T&& element, AppendIdPolicy policy = AppendIdPolicy::ThrowOnEmpty)
-            {
-                const bool isEmptyId = element.id.empty();
-
-                if (isEmptyId)
-                {
-                    if (policy != AppendIdPolicy::GenerateOnEmpty)
-                    {
-                        throw GLTFException("key is an empty string");
-                    }
-
-                    element.id = std::to_string(m_elements.size());
-                }
-
-                while (!m_elementIndices.emplace(element.id, m_elements.size()).second)
-                {
-                    if (isEmptyId) // Can only be true if policy is GenerateOnEmpty
-                    {
-                        // If id policy is GenerateOnEmpty then postfix the auto-generated key with '+'
-                        // chars until a unique value is generated (i.e. the call to emplace succeeds)
-                        element.id += "+";
-                    }
-                    else
-                    {
-                        throw GLTFException("key " + element.id + " already exists in IndexedContainer");
-                    }
-                }
-
-                m_elements.push_back(std::move(element));
-                return m_elements.back();
-            }
-
-            void Clear()
-            {
-                m_elementIndices.clear();
-                m_elements.clear();
-            }
-
-            const std::vector<T>& Elements() const
-            {
-                return m_elements;
-            }
-
-            const T& Get(size_t index) const
-            {
-                return operator[](index);
-            }
-
-            const T& Get(const std::string& key) const
-            {
-                return operator[](key);
-            }
-
-            size_t GetIndex(const std::string& key) const
-            {
-                if (key.empty())
-                {
-                    throw GLTFException("Invalid key - cannot be empty");
-                }
-
-                auto it = m_elementIndices.find(key);
-
-                if (it == m_elementIndices.end())
-                {
-                    throw GLTFException("key " + key + " not in container");
-                }
-
-                return it->second;
-            }
-
-            bool Has(const std::string& key) const
-            {
-                return m_elementIndices.find(key) != m_elementIndices.end();
-            }
-
-            void Remove(const std::string& key)
-            {
-                const auto index = GetIndex(key);
-
-                m_elementIndices.erase(key);
-                m_elements.erase(m_elements.begin() + index);
-
-                for (auto& elementIndex : m_elementIndices)
-                {
-                    if (elementIndex.second > index)
-                    {
-                        elementIndex.second--;
-                    }
-                }
-            }
-
-            void Replace(const T& element)
-            {
-                Replace(T(element));
-            }
-
-            void Replace(T&& element)
-            {
-                const auto index = GetIndex(element.id);
-                m_elements[index] = std::move(element);
-            }
-
-            void Reserve(size_t capacity)
-            {
-                m_elements.reserve(capacity);
-                m_elementIndices.reserve(capacity);
-            }
-
-            size_t Size() const
-            {
-                return m_elements.size();
-            }
-
-        private:
-            std::vector<T> m_elements;
-            std::unordered_map<std::string, size_t> m_elementIndices;
-        };
-
-        // Mutable template parameter T partial specialization - Uses private inheritance to gain the const template parameter functionality without an is-a relationship
-        template<typename T>
-        class IndexedContainer<T, false> : private IndexedContainer<const T>
-        {
-            // IndexedContainer<const T> is a 'dependent base class' (because it is dependent on template parameter
-            // T). This means all inherited members must be qualified with 'this->' or 'IndexedContainer<const T>::'
-
-        public:
-            T& Front()
-            {
-                return const_cast<T&>(IndexedContainer<const T>::Front());
-            }
-
-            T& Back()
-            {
-                return const_cast<T&>(IndexedContainer<const T>::Back());
-            }
-
-            T& operator[](size_t index)
-            {
-                return const_cast<T&>(IndexedContainer<const T>::operator[](index));
-            }
-
-            T& operator[](const std::string& key)
-            {
-                return operator[](GetIndex(key));
-            }
-
-            bool operator==(const IndexedContainer& rhs) const
-            {
-                return IndexedContainer<const T>::operator==(rhs);
-            }
-
-            bool operator!=(const IndexedContainer& rhs) const
-            {
-                return !(operator==(rhs));
-            }
-
-            T& Append(const T& element, AppendIdPolicy policy = AppendIdPolicy::ThrowOnEmpty)
-            {
-                return Append(T(element), policy);
-            }
-
-            T& Append(T&& element, AppendIdPolicy policy = AppendIdPolicy::ThrowOnEmpty)
-            {
-                return const_cast<T&>(IndexedContainer<const T>::Append(std::move(element), policy));
-            }
-
-            std::vector<T>& Elements()
-            {
-                return const_cast<std::vector<T>&>(IndexedContainer<const T>::Elements());
-            }
-
-            T& Get(size_t index)
-            {
-                return operator[](index);
-            }
-
-            T& Get(const std::string& key)
-            {
-                return operator[](key);
-            }
-
-            // No using declaration for Append, operator== or operator!= as we don't
-            // want to make the base class versions of these functions publically
-            // accessible (the mutable versions replace rather than complement them)
-            using IndexedContainer<const T>::Front;
-            using IndexedContainer<const T>::Back;
-            using IndexedContainer<const T>::Clear;
-            using IndexedContainer<const T>::Elements;
-            using IndexedContainer<const T>::Get;
-            using IndexedContainer<const T>::GetIndex;
-            using IndexedContainer<const T>::Has;
-            using IndexedContainer<const T>::Remove;
-            using IndexedContainer<const T>::Replace;
-            using IndexedContainer<const T>::Reserve;
-            using IndexedContainer<const T>::Size;
-            using IndexedContainer<const T>::operator[];
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Math.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Math.h
deleted file mode 100644
index f48d15e..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Math.h
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <array>
-#include <cmath>
-#include <cstdint>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        struct Matrix4
-        {
-            Matrix4();
-
-            bool operator==(const Matrix4& other) const;
-            bool operator!=(const Matrix4& other) const;
-
-            std::array<float, 16> values;
-
-            static const Matrix4 IDENTITY;
-        };
-
-        struct Vector2
-        {
-            Vector2();
-            Vector2(float x, float y);
-
-            bool operator==(const Vector2& other) const;
-            bool operator!=(const Vector2& other) const;
-
-            float x;
-            float y;
-
-            static const Vector2 ZERO;
-            static const Vector2 ONE;
-        };
-
-        struct Vector3
-        {
-            Vector3();
-            Vector3(float x, float y, float z);
-
-            bool operator==(const Vector3& other) const;
-            bool operator!=(const Vector3& other) const;
-
-            float x;
-            float y;
-            float z;
-
-            static const Vector3 ZERO;
-            static const Vector3 ONE;
-        };
-
-        struct Quaternion
-        {
-            Quaternion();
-            Quaternion(float x, float y, float z, float w);
-
-            bool operator==(const Quaternion& other) const;
-            bool operator!=(const Quaternion& other) const;
-
-            float x;
-            float y;
-            float z;
-            float w;
-
-            static const Quaternion IDENTITY;
-        };
-
-        namespace Math
-        {
-            template<class T>
-            const T& Clamp(const T& v, const T& lo, const T& hi) {
-                return std::min(hi, std::max(v, lo));
-            }
-
-            // https://en.wikipedia.org/wiki/SRGB#The_reverse_transformation
-            inline float ToLinear(float value)
-            {
-                if (value < 0.04045f)
-                {
-                    return value / 12.92f;
-                }
-
-                return powf((value + 0.055f) / 1.055f, 2.4f);
-            }
-
-            // https://en.wikipedia.org/wiki/SRGB#The_forward_transformation_.28CIE_XYZ_to_sRGB.29
-            inline float ToGamma(float value)
-            {
-                if (value <= 0.0031308f)
-                {
-                    return value * 12.92f;
-                }
-
-                return 1.055f * powf(value, 1.0f / 2.4f) - 0.055f;
-            }
-
-            inline float ByteToFloat(uint8_t value)
-            {
-                return value / 255.0f;
-            }
-
-            inline uint8_t FloatToByte(float value)
-            {
-                return static_cast<uint8_t>(value * 255.0f + 0.5f);
-            }
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/MeshPrimitiveUtils.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/MeshPrimitiveUtils.h
deleted file mode 100644
index 7b518b8..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/MeshPrimitiveUtils.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <vector>
-
-#include <GLTFSDK/GLTF.h>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class Document;
-        class GLTFResourceReader;
-
-        namespace MeshPrimitiveUtils
-        {
-            std::vector<uint16_t> GetIndices16(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<uint16_t> GetIndices16(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-
-            std::vector<uint32_t> GetIndices32(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<uint32_t> GetIndices32(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-
-            std::vector<uint16_t> GetTriangulatedIndices16(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-            std::vector<uint32_t> GetTriangulatedIndices32(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-
-            std::vector<uint16_t> GetSegmentedIndices16(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-            std::vector<uint32_t> GetSegmentedIndices32(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-
-            std::vector<float> GetPositions(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<float> GetPositions(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-            std::vector<float> GetPositions(const Document& doc, const GLTFResourceReader& reader, const MorphTarget& morphTarget);
-
-            std::vector<float> GetNormals(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<float> GetNormals(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-            std::vector<float> GetNormals(const Document& doc, const GLTFResourceReader& reader, const MorphTarget& morphTarget);
-
-            std::vector<float> GetTangents(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<float> GetTangents(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-            std::vector<float> GetTangents(const Document& doc, const GLTFResourceReader& reader, const MorphTarget& morphTarget);
-            std::vector<float> GetMorphTangents(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-
-            std::vector<float> GetTexCoords(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<float> GetTexCoords_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-            std::vector<float> GetTexCoords_1(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-
-            std::vector<uint32_t> GetColors(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<uint32_t> GetColors_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-
-            std::vector<uint32_t> GetJointIndices32(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<uint32_t> GetJointIndices32_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-
-            std::vector<uint64_t> GetJointIndices64(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<uint64_t> GetJointIndices64_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-
-            std::vector<uint32_t> GetJointWeights32(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor);
-            std::vector<uint32_t> GetJointWeights32_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive);
-
-            std::vector<uint16_t> ReverseTriangulateIndices16(const uint16_t* indices, size_t indexCount, MeshMode mode);
-            std::vector<uint32_t> ReverseTriangulateIndices32(const uint32_t* indices, size_t indexCount, MeshMode mode);
-
-            std::vector<uint16_t> ReverseTriangulateIndices16(const std::vector<uint16_t>& indices, MeshMode mode);
-            std::vector<uint32_t> ReverseTriangulateIndices32(const std::vector<uint32_t>& indices, MeshMode mode);
-
-            std::vector<uint16_t> ReverseSegmentIndices16(const uint16_t* indices, size_t indexCount, MeshMode mode);
-            std::vector<uint32_t> ReverseSegmentIndices32(const uint32_t* indices, size_t indexCount, MeshMode mode);
-
-            std::vector<uint16_t> ReverseSegmentIndices16(const std::vector<uint16_t>& indices, MeshMode mode);
-            std::vector<uint32_t> ReverseSegmentIndices32(const std::vector<uint32_t>& indices, MeshMode mode);
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/MicrosoftGeneratorVersion.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/MicrosoftGeneratorVersion.h
deleted file mode 100644
index 350c479..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/MicrosoftGeneratorVersion.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string>
-#include <tuple>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class MicrosoftGeneratorVersion
-        {
-        public:
-            MicrosoftGeneratorVersion(const std::string& version);
-
-            bool operator==(const MicrosoftGeneratorVersion& other) const;
-            bool operator<(const MicrosoftGeneratorVersion& other) const;
-            bool operator>(const MicrosoftGeneratorVersion& other) const;
-            bool operator<=(const MicrosoftGeneratorVersion& other) const;
-            bool operator>=(const MicrosoftGeneratorVersion& other) const;
-            bool operator!=(const MicrosoftGeneratorVersion& other) const;
-
-            bool IsMicrosoftGenerator() const;
-            bool IsPrerelease() const;
-
-        private:
-            std::tuple<unsigned long, unsigned long, unsigned long, unsigned long> m_version;
-            unsigned long m_prereleaseVersion;
-            bool m_isPrerelease;
-            bool m_isMicrosoftGenerator;
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Optional.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Optional.h
deleted file mode 100644
index e867c88..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Optional.h
+++ /dev/null
@@ -1,198 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include "Exceptions.h"
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        template<typename T>
-        class Optional final
-        {
-        public:
-            Optional() : isConstructed(false)
-            {
-            }
-
-            Optional(T&& t) : isConstructed(true)
-            {
-                new (this->GetStorage()) T(std::move(t)); // In-place new;
-            }
-
-            Optional(const T& t) : isConstructed(true)
-            {
-                new (this->GetStorage()) T(t); // In-place new;
-            }
-
-            Optional(Optional<T>&& other) : isConstructed(false)
-            {
-                if (other.isConstructed)
-                {
-                    Swap(other);
-                }
-            }
-
-            Optional(const Optional& other) : isConstructed(other.isConstructed)
-            {
-                if (other.isConstructed)
-                {
-                    new (this->GetStorage()) T(other.Get()); // In-place new;
-                }
-            }
-
-            ~Optional()
-            {
-                Reset();
-            }
-
-            T& Get()
-            {
-                if (isConstructed)
-                {
-                    return *static_cast<T*>(this->GetStorage());
-                }
-                else
-                {
-                    throw GLTFException("Optional has no value");
-                }
-            }
-
-            const T& Get() const
-            {
-                if (isConstructed)
-                {
-                    return *static_cast<const T*>(this->GetStorage());
-                }
-                else
-                {
-                    throw GLTFException("Optional has no value");
-                }
-            }
-
-            bool HasValue() const noexcept
-            {
-                return isConstructed;
-            }
-
-            void Reset()
-            {
-                if (isConstructed)
-                {
-                    Get().~T(); // In-place delete;
-                }
-
-                isConstructed = false;
-            }
-
-            void Swap(Optional& other)
-            {
-                Swap(*this, other);
-            }
-
-            static void Swap(Optional& lhs, Optional& rhs)
-            {
-                if (lhs && rhs)
-                {
-                    std::swap(lhs.Get(), rhs.Get());
-                }
-                else if (lhs)
-                {
-                    new (rhs.GetStorage()) T(std::move(lhs.Get()));
-                    rhs.isConstructed = true;
-                    lhs.Reset();
-                }
-                else if (rhs)
-                {
-                    new (lhs.GetStorage()) T(std::move(rhs.Get()));
-                    lhs.isConstructed = true;
-                    rhs.Reset();
-                }
-            }
-
-            Optional& operator=(Optional&& other)
-            {
-                if (this != &other)
-                {
-                    Optional(std::move(other)).Swap(*this);
-                }
-
-                return *this;
-            }
-
-            Optional& operator=(const Optional& other)
-            {
-                if (this != &other)
-                {
-                    Optional(other).Swap(*this);
-                }
-
-                return *this;
-            }
-
-            Optional& operator=(T&& t)
-            {
-                if (isConstructed)
-                {
-                    Get() = std::move(t);
-                }
-                else
-                {
-                    new (this->GetStorage()) T(std::move(t)); // In-place new;
-                    isConstructed = true;
-                }
-
-                return *this;
-            }
-
-            Optional& operator=(const T& t)
-            {
-                if (isConstructed)
-                {
-                    Get() = t;
-                }
-                else
-                {
-                    new (this->GetStorage()) T(t); // In-place new;
-                    isConstructed = true;
-                }
-
-                return *this;
-            }
-
-            explicit operator bool() const noexcept
-            {
-                return HasValue();
-            }
-
-        private:
-            void* GetStorage()
-            {
-                return storage;
-            }
-
-            const void* GetStorage() const
-            {
-                return storage;
-            }
-
-            alignas(alignof(T)) unsigned char storage[sizeof(T)];
-
-            bool isConstructed;
-        };
-
-        template<typename T>
-        bool operator==(const Optional<T>& lhs, const Optional<T>& rhs)
-        {
-            return (!lhs && !rhs) || ((lhs && rhs) && (lhs.Get() == rhs.Get()));
-        }
-
-        template<typename T>
-        bool operator!=(const Optional<T>& lhs, const Optional<T>& rhs)
-        {
-            return !(lhs == rhs);
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/PBRUtils.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/PBRUtils.h
deleted file mode 100644
index 3105c7d..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/PBRUtils.h
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Color.h>
-#include <GLTFSDK/ExtensionsKHR.h>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        namespace Detail
-        {
-            template<typename TColor>
-            TColor DIELECTRIC_SPECULAR = TColor(0.04f, 0.04f, 0.04f);
-
-            template<typename TColor>
-            TColor BLACK = TColor(0.0f, 0.0f, 0.0f);
-
-            template<typename TColor>
-            inline float GetMaxComponent(const TColor& color)
-            {
-                // Access the color channels using R/G/B functions - this uses ADL to locate the functions in the same namespace as TColor
-                const auto r = R(color);
-                const auto g = G(color);
-                const auto b = B(color);
-
-                return std::max(std::max(r, g), b);
-            }
-
-            // http://www.itu.int/rec/R-REC-BT.601
-            // http://www.itu.int/dms_pubrec/itu-r/rec/bt/R-REC-BT.601-7-201103-I!!PDF-E.pdf
-            constexpr const float R_BRIGHTNESS_COEFF = 0.299f;
-            constexpr const float G_BRIGHTNESS_COEFF = 0.587f;
-            constexpr const float B_BRIGHTNESS_COEFF = 0.114f;
-
-            template<typename TColor>
-            inline float GetPerceivedBrightness(const TColor& color)
-            {
-                const TColor value = TColor(R_BRIGHTNESS_COEFF, G_BRIGHTNESS_COEFF, B_BRIGHTNESS_COEFF) * (color * color);
-
-                // Access the color channels using R/G/B functions - this uses ADL to locate the functions in the same namespace as TColor
-                const auto r = R(value);
-                const auto g = G(value);
-                const auto b = B(value);
-
-                return std::sqrt(r + g + b);
-            }
-
-            float SolveMetallic(float dielectricSpecular, float diffuse, float specular, float oneMinusSpecularStrength);
-        }
-
-        template<typename TColor>
-        struct SpecularGlossinessValueTypeless
-        {
-            SpecularGlossinessValueTypeless() :
-                diffuse(1.0f, 1.0f, 1.0f),
-                opacity(1.0f),
-                specular(1.0f, 1.0f, 1.0f),
-                glossiness(1.0f)
-            {
-            }
-
-            explicit SpecularGlossinessValueTypeless(const KHR::Materials::PBRSpecularGlossiness& sg) :
-                diffuse(sg.diffuseFactor.r, sg.diffuseFactor.g, sg.diffuseFactor.b),
-                opacity(sg.diffuseFactor.a),
-                specular(sg.specularFactor.r, sg.specularFactor.g, sg.specularFactor.b),
-                glossiness(sg.glossinessFactor)
-            {
-            }
-
-            TColor diffuse;
-            float opacity;
-            TColor specular;
-            float glossiness;
-        };
-
-        using SpecularGlossinessValue = SpecularGlossinessValueTypeless<Color3>;
-
-        template<typename TColor>
-        struct MetallicRoughnessValueTypeless
-        {
-            MetallicRoughnessValueTypeless() :
-                base(1.0f, 1.0f, 1.0f),
-                opacity(1.0f),
-                metallic(1.0f),
-                roughness(1.0f)
-            {
-            }
-
-            explicit MetallicRoughnessValueTypeless(const Material::PBRMetallicRoughness& mr) :
-                base(mr.baseColorFactor.r, mr.baseColorFactor.g, mr.baseColorFactor.b),
-                opacity(mr.baseColorFactor.a),
-                metallic(mr.metallicFactor),
-                roughness(mr.roughnessFactor)
-            {
-            }
-
-            TColor base;
-            float opacity;
-            float metallic;
-            float roughness;
-        };
-
-        using MetallicRoughnessValue = MetallicRoughnessValueTypeless<Color3>;
-
-        template<typename TColor>
-        inline MetallicRoughnessValueTypeless<TColor> SGToMR(const SpecularGlossinessValueTypeless<TColor>& sg)
-        {
-            using namespace Detail;
-
-            const float oneMinusSpecularStrength = 1.0f - GetMaxComponent(sg.specular);
-            const float dielectricSpecularRed = R(DIELECTRIC_SPECULAR<TColor>);
-
-            const auto brightnessDiffuse = GetPerceivedBrightness(sg.diffuse);
-            const auto brightnessSpecular = GetPerceivedBrightness(sg.specular);
-
-            const float metallic = SolveMetallic(dielectricSpecularRed, brightnessDiffuse, brightnessSpecular, oneMinusSpecularStrength);
-            const float oneMinusMetallic = 1.0f - metallic;
-
-            const TColor baseColorFromDiffuse = sg.diffuse * (oneMinusSpecularStrength / (1.0f - dielectricSpecularRed) / std::max((oneMinusMetallic), std::numeric_limits<float>::epsilon()));
-            const TColor baseColorFromSpecular = (sg.specular - (DIELECTRIC_SPECULAR<TColor> * (oneMinusMetallic))) * (1.0f / std::max(metallic, std::numeric_limits<float>::epsilon()));
-            const TColor baseColor = TColor::Clamp(TColor::Lerp(baseColorFromDiffuse, baseColorFromSpecular, metallic * metallic), 0.0f, 1.0f);
-
-            MetallicRoughnessValueTypeless<TColor> mr;
-            mr.base = baseColor;
-            mr.opacity = sg.opacity;
-            mr.metallic = metallic;
-            mr.roughness = 1.0f - sg.glossiness;
-            return mr;
-        }
-
-        MetallicRoughnessValue SGToMR(const SpecularGlossinessValue& sg);
-
-        template<typename TColor>
-        inline SpecularGlossinessValueTypeless<TColor> MRToSG(const MetallicRoughnessValueTypeless<TColor>& mr)
-        {
-            using namespace Detail;
-
-            const auto specular = TColor::Lerp(DIELECTRIC_SPECULAR<TColor>, mr.base, mr.metallic);
-            const float oneMinusSpecularStrength = 1.0f - GetMaxComponent(specular);
-            const auto diffuse = oneMinusSpecularStrength < std::numeric_limits<float>::epsilon()
-                ? BLACK<TColor>
-                : mr.base * ((1.0f - R(DIELECTRIC_SPECULAR<TColor>)) * (1.0f - mr.metallic) / oneMinusSpecularStrength);
-
-            SpecularGlossinessValueTypeless<TColor> sg;
-            sg.diffuse = diffuse;
-            sg.opacity = mr.opacity;
-            sg.specular = specular;
-            sg.glossiness = 1.0f - mr.roughness;
-            return sg;
-        }
-
-        SpecularGlossinessValue MRToSG(const MetallicRoughnessValue& mr);
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/RapidJsonUtils.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/RapidJsonUtils.h
deleted file mode 100644
index f70968e..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/RapidJsonUtils.h
+++ /dev/null
@@ -1,407 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#if defined(RAPIDJSON_NAMESPACE) || defined(RAPIDJSON_NAMESPACE_BEGIN) || defined(RAPIDJSON_NAMESPACE_END)
-#error GLTFSDK: another library has likely included rapidjson first and predefined rapidjson namespace macros \
-This could result in compiling or linking with a different version of rapidjson than we expect. \
-This is know to cause runtime errors if different versions of rapidjson are included in the same namespace. \
-GLTFSDK code should only include rapidjson using this header. \
-If this is being included from another library then it is important to separate the code in that library from our own use of rapidjson. \
-Please do not include their headers and this header in the same cpp file.
-#endif
-
-
-#define RAPIDJSON_NAMESPACE Microsoft::glTF::rapidjson
-#define RAPIDJSON_NAMESPACE_BEGIN  namespace Microsoft { namespace glTF { namespace rapidjson {
-#define RAPIDJSON_NAMESPACE_END }}}
-
-// Adding iterative parse flag to prevent stack overflow issue
-#define RAPIDJSON_PARSE_DEFAULT_FLAGS RAPIDJSON_NAMESPACE::ParseFlag::kParseIterativeFlag
-
-// RapidJSON uses constant if expressions to support multiple platforms
-#pragma warning(push)
-#pragma warning(disable:4127)
-#include "../../rapidjson/schema.h"
-#pragma warning(pop)
-
-// This file is used as a catch-all for including rapidjson headers in the SDK. 
-// If desired header not found below, please add it and include this file instead of the header directly
-#include "../../rapidjson/document.h"
-#include "../../rapidjson/error/en.h"
-#include "../../rapidjson/istreamwrapper.h"
-#include "../../rapidjson/pointer.h"
-#include "../../rapidjson/prettywriter.h"
-#include "../../rapidjson/stringbuffer.h"
-
-#include <GLTFSDK/Color.h>
-#include <GLTFSDK/Exceptions.h>
-#include <GLTFSDK/IndexedContainer.h>
-#include <GLTFSDK/Math.h>
-
-#include <vector>
-#include <string>
-#include <istream>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        // Other platforms may define size_t as unsigned long and the rapidjson doesn't support that very well.
-        // We create a type below which is uint32_t if unsigned long is the same sizeof, or uint64_t if it is not.
-        // Then we use this to type-convert size_t to a type that rapidjson can take directly.
-        constexpr const bool IsUnsignedLongSizeofUInt32 = sizeof(unsigned long) == sizeof(uint32_t);
-        typedef std::conditional<IsUnsignedLongSizeofUInt32, uint32_t, uint64_t>::type UnsignedLongKnownSizeType;
-        typedef std::conditional<std::is_same<std::size_t, unsigned long>::value, UnsignedLongKnownSizeType, std::size_t>::type KnownSizeType;
-
-        template<typename T>
-        std::string GetMemberValueAsString(const rapidjson::Value& v, const char* memberName)
-        {
-            auto it = v.FindMember(memberName);
-
-            if (it != v.MemberEnd())
-            {
-                return std::to_string(it->value.Get<T>());
-            }
-            else
-            {
-                return {};
-            }
-        }
-
-        template<>
-        inline std::string GetMemberValueAsString<std::size_t>(const rapidjson::Value& v, const char* memberName)
-        {
-            auto it = v.FindMember(memberName);
-
-            if (it != v.MemberEnd())
-            {
-                return std::to_string(it->value.Get<KnownSizeType>());
-            }
-            else
-            {
-                return {};
-            }
-        }
-
-        inline bool TryFindMember(const char* name, const rapidjson::Value& v, rapidjson::Value::ConstMemberIterator& value)
-        {
-            rapidjson::Value::ConstMemberIterator it = v.FindMember(name);
-            value = it;
-            return it != v.MemberEnd();
-        }
-
-        inline rapidjson::Value::ConstMemberIterator FindRequiredMember(const char* name, const rapidjson::Value& v)
-        {
-            const rapidjson::Value::ConstMemberIterator it = v.FindMember(name);
-            if (it == v.MemberEnd())
-            {
-                throw InvalidGLTFException("The member " + std::string(name) + " was not found");
-            }
-            return it;
-        }
-
-        template<typename T>
-        T GetValueOrDefault(const rapidjson::Value& v, T t = {})
-        {
-            return v.Is<T>() ? v.Get<T>() : std::move(t);
-        }
-
-        template<>
-        inline std::string GetValueOrDefault<std::string>(const rapidjson::Value& v, std::string str)
-        {
-            return v.Is<const char*>() ? v.GetString() : std::move(str);
-        }
-
-        template<>
-        inline float GetValueOrDefault<float>(const rapidjson::Value& v, float defaultValue)
-        {
-            return v.IsNumber() ? v.GetFloat() : defaultValue;
-        }
-
-        inline std::string Serialize(const rapidjson::Value& v)
-        {
-            rapidjson::StringBuffer stringBuffer;
-            rapidjson::Writer<rapidjson::StringBuffer> writer(stringBuffer);
-            v.Accept(writer);
-            return stringBuffer.GetString();
-        }
-
-        template<>
-        inline std::size_t GetValueOrDefault<std::size_t>(const rapidjson::Value& v, std::size_t t)
-        {
-            return v.Is<KnownSizeType>() ? v.Get<KnownSizeType>() : std::move(t);
-        }
-
-        template<typename T>
-        T GetMemberValueOrDefault(const rapidjson::Value& v, const char* memberName, T t = {})
-        {
-            auto it = v.FindMember(memberName);
-            if (it != v.MemberEnd())
-            {
-                return GetValueOrDefault<T>(it->value, std::move(t));
-            }
-            return std::move(t);
-        }
-
-        inline KnownSizeType ToKnownSizeType(std::size_t v)
-        {
-            return static_cast<KnownSizeType>(v);
-        }
-
-        template <typename T>
-        T GetValue(const rapidjson::Value& v)
-        {
-            return v.Get<T>();
-        }
-
-        template <>
-        inline std::size_t GetValue<std::size_t>(const rapidjson::Value& v)
-        {
-            return static_cast<std::size_t>(v.Get<KnownSizeType>());
-        }
-
-        namespace RapidJsonUtils
-        {
-            inline rapidjson::Value ToStringValue(const std::string& str, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value v;
-                v.SetString(str.c_str(), static_cast<uint32_t>(str.length()), a);
-                return v;
-            }
-
-            inline rapidjson::GenericStringRef<char> ToStringRef(const std::string& str)
-            {
-                return rapidjson::StringRef(str.c_str());
-            }
-
-            inline rapidjson::Value ToFloatValue(const float f)
-            {
-                rapidjson::Value v;
-                v.SetFloat(f);
-                return v;
-            }
-
-            inline std::vector<float> ToFloatArray(const rapidjson::Value& v, const std::string& key)
-            {
-                std::vector<float> result;
-                const auto& it = v.FindMember(key.c_str());
-                if (it != v.MemberEnd())
-                {
-                    for (rapidjson::Value::ConstValueIterator ait = it->value.Begin(); ait != it->value.End(); ++ait)
-                    {
-                        result.push_back(static_cast<float>(ait->GetDouble()));
-                    }
-                }
-                return result;
-            }
-
-            template<typename T>
-            inline rapidjson::Value ToJsonArray(const std::vector<T>& v, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value vArray(rapidjson::kArrayType);
-                for (size_t i = 0; i < v.size(); ++i)
-                {
-                    vArray.PushBack(v[i], a);
-                }
-                return vArray;
-            }
-
-            inline rapidjson::Value ToJsonArray(const std::vector<size_t>& v, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value vArray(rapidjson::kArrayType);
-                for (size_t i = 0; i < v.size(); ++i)
-                {
-                    vArray.PushBack(ToKnownSizeType(v[i]), a);
-                }
-                return vArray;
-            }
-
-            inline rapidjson::Value ToJsonArray(const std::vector<std::string>& v, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value vArray(rapidjson::kArrayType);
-                for (size_t i = 0; i < v.size(); ++i)
-                {
-                    vArray.PushBack(ToStringValue(v[i], a), a);
-                }
-                return vArray;
-            }
-
-            template<typename T, std::size_t N>
-            inline rapidjson::Value ToJsonArray(const std::array<T, N>& v, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value vArray(rapidjson::kArrayType);
-                for (size_t i = 0; i < v.size(); ++i)
-                {
-                    vArray.PushBack(v[i], a);
-                }
-                return vArray;
-            }
-
-            inline glTF::rapidjson::Value ToJsonArray(const Vector2& v, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value vArray(rapidjson::kArrayType);
-                vArray.PushBack(v.x, a);
-                vArray.PushBack(v.y, a);
-                return vArray;
-            }
-
-            inline rapidjson::Value ToJsonArray(const Vector3& v, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value vArray(rapidjson::kArrayType);
-                vArray.PushBack(v.x, a);
-                vArray.PushBack(v.y, a);
-                vArray.PushBack(v.z, a);
-                return vArray;
-            }
-
-            inline rapidjson::Value ToJsonArray(const Quaternion& v, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value vArray(rapidjson::kArrayType);
-                vArray.PushBack(v.x, a);
-                vArray.PushBack(v.y, a);
-                vArray.PushBack(v.z, a);
-                vArray.PushBack(v.w, a);
-                return vArray;
-            }
-
-            inline rapidjson::Value ToJsonArray(const Color4& v, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value vArray(rapidjson::kArrayType);
-                vArray.PushBack(v.r, a);
-                vArray.PushBack(v.g, a);
-                vArray.PushBack(v.b, a);
-                vArray.PushBack(v.a, a);
-                return vArray;
-            }
-
-            inline rapidjson::Value ToJsonArray(const Color3& v, rapidjson::Document::AllocatorType& a)
-            {
-                rapidjson::Value vArray(rapidjson::kArrayType);
-                vArray.PushBack(v.r, a);
-                vArray.PushBack(v.g, a);
-                vArray.PushBack(v.b, a);
-                return vArray;
-            }
-
-            inline void AddMember(rapidjson::Value& v, const std::string& key, const std::string& value, rapidjson::Document::AllocatorType& a)
-            {
-                v.AddMember(ToStringValue(key, a), ToStringValue(value, a), a);
-            }
-
-            inline void AddOptionalMember(const std::string& name, rapidjson::Value& v, const std::string& source, rapidjson::Document::AllocatorType& a)
-            {
-                if (!source.empty())
-                {
-                    v.AddMember(ToStringValue(name, a), ToStringValue(source, a), a);
-                }
-            }
-
-            // Adds a member called `name` to the `v` object if the `id` string is not empty.
-            // The value of the member is the index of the object identified by `id` on `container`.
-            template <typename T>
-            inline void AddOptionalMemberIndex(const std::string& name, rapidjson::Value& v, const std::string& id, const IndexedContainer<const T>& container, rapidjson::Document::AllocatorType& a)
-            {
-                if (!id.empty())
-                {
-                    v.AddMember(ToStringValue(name, a), rapidjson::Value(ToKnownSizeType(container.GetIndex(id))), a);
-                }
-            }
-
-            // Adds a member called `name` to the `v` object if the `id` string is not empty.
-            // The member is an object with a single member called `childName`, and its value
-            // is the index of the object identified by `id` on `container`.
-            template <typename T>
-            inline void AddOptionalMemberIndexChild(const std::string& name, const std::string& childName, rapidjson::Value& v, const std::string& id, const IndexedContainer<const T>& container, rapidjson::Document::AllocatorType& a)
-            {
-                if (!id.empty())
-                {
-                    rapidjson::Value child(rapidjson::kObjectType);
-                    {
-                        child.AddMember(ToStringValue(childName, a), rapidjson::Value(ToKnownSizeType(container.GetIndex(id))), a);
-                    }
-                    v.AddMember(ToStringValue(name, a), child, a);
-                }
-            }
-
-            template <typename T>
-            inline void AddArrayMember(rapidjson::Value& v, const std::string& key, const std::vector<T>& list, rapidjson::Document::AllocatorType& a)
-            {
-                if (list.size() > 0)
-                {
-                    v.AddMember(ToStringValue(key, a), ToJsonArray<T>(list, a), a);
-                }
-            }
-
-            inline rapidjson::Value& FindOrAddMember(rapidjson::Value& v, const std::string& memberName, rapidjson::Document::AllocatorType& a)
-            {
-                auto it = v.FindMember(memberName.c_str());
-                if (it == v.MemberEnd())
-                {
-                    rapidjson::Value newValue(rapidjson::kObjectType);
-                    v.AddMember(ToStringValue(memberName, a), newValue, a);
-                    it = v.FindMember(ToStringValue(memberName, a));
-                }
-                return it->value;
-            }
-
-            inline rapidjson::Document CreateDocumentFromString(const std::string& json)
-            {
-                rapidjson::Document document;
-
-                if (document.Parse(json.c_str()).HasParseError())
-                {
-                    // The input is not valid JSON.
-                    throw GLTFException("The document is invalid due to bad JSON formatting");
-                }
-
-                return document;
-            }
-
-            inline rapidjson::Document CreateDocumentFromEncodedString(const std::string& json)
-            {
-                rapidjson::MemoryStream memoryStream(json.c_str(), json.size());
-                rapidjson::EncodedInputStream<rapidjson::UTF8<>, rapidjson::MemoryStream> encodedStream(memoryStream);
-                rapidjson::Document document;
-
-                if (document.ParseStream<rapidjson::kParseDefaultFlags, rapidjson::UTF8<>>(encodedStream).HasParseError())
-                {
-                    // The input is not valid JSON.
-                    throw GLTFException("The document is invalid due to bad JSON formatting");
-                }
-
-                return document;
-            }
-
-            inline rapidjson::Document CreateDocumentFromStream(std::istream& jsonStream)
-            {
-                rapidjson::IStreamWrapper streamWrapper(jsonStream);
-                rapidjson::Document document;
-
-                if (document.ParseStream(streamWrapper).HasParseError())
-                {
-                    // The input is not valid JSON.
-                    throw GLTFException("The document is invalid due to bad JSON formatting");
-                }
-
-                return document;
-            }
-
-            inline rapidjson::Document CreateDocumentFromEncodedStream(std::istream& jsonStream)
-            {
-                rapidjson::IStreamWrapper streamWrapper(jsonStream);
-                rapidjson::EncodedInputStream<rapidjson::UTF8<>, rapidjson::IStreamWrapper> encodedStream(streamWrapper);
-                rapidjson::Document document;
-
-                if (document.ParseStream<rapidjson::kParseDefaultFlags, rapidjson::UTF8<>>(streamWrapper).HasParseError())
-                {
-                    // The input is not valid JSON.
-                    throw GLTFException("The document is invalid due to bad JSON formatting");
-                }
-
-                return document;
-            }
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/ResourceReaderUtils.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/ResourceReaderUtils.h
deleted file mode 100644
index b02a7c4..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/ResourceReaderUtils.h
+++ /dev/null
@@ -1,239 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Exceptions.h>
-
-#include <string>
-#include <vector>
-#include <cmath>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        // Documentation for RFC2397 base64 encoding:
-        // https://en.wikipedia.org/wiki/Base64
-        // https://tools.ietf.org/html/rfc2397
-
-        constexpr char characterSet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-        constexpr size_t CharCountToByteCount(size_t charCount)
-        {
-            return (charCount * 3U) / 4U;
-        }
-
-        constexpr size_t ByteCountToCharCount(size_t byteCount)
-        {
-            return (byteCount / 3U) * 4U;
-        }
-
-        constexpr size_t ByteCountToCharCountRemainder(size_t byteCount)
-        {
-            return byteCount % 3U;
-        }
-
-        // Note: intended to be used as a pass-by-value function parameter
-        struct Base64StringView
-        {
-            Base64StringView(std::string::const_iterator itBegin_, std::string::const_iterator itEnd_) :
-                itBegin(itBegin_),
-                itEnd(itEnd_)
-            {
-                // Ignore trailing '=' characters
-                while ((itBegin != itEnd) && (*(itEnd - 1) == '='))
-                {
-                    --itEnd;
-                }
-            }
-
-            explicit Base64StringView(const std::string& string) : Base64StringView(string.begin(), string.end())
-            {
-            }
-
-            size_t GetCharCount() const
-            {
-                return std::distance(itBegin, itEnd);
-            }
-
-            size_t GetByteCount() const
-            {
-                return CharCountToByteCount(GetCharCount());
-            }
-
-            std::string::const_iterator begin() const
-            {
-                return itBegin;
-            }
-
-            std::string::const_iterator end() const
-            {
-                return itEnd;
-            }
-
-            std::string::const_iterator itBegin;
-            std::string::const_iterator itEnd;
-        };
-
-        // Note: intended to be used as a pass-by-value function parameter
-        struct Base64BufferView
-        {
-            Base64BufferView(void* buffer, size_t bufferByteLength) :
-                buffer(buffer),
-                bufferByteLength(bufferByteLength)
-            {
-            }
-
-            template<typename T>
-            explicit Base64BufferView(std::vector<T>& decodedDataBuffer) : Base64BufferView(decodedDataBuffer.data(), decodedDataBuffer.size() * sizeof(T))
-            {
-            }
-
-            void* const  buffer;
-            const size_t bufferByteLength;
-        };
-
-        inline std::vector<uint8_t> GetDecodeTable()
-        {
-            std::vector<uint8_t> decodeTable(128, std::numeric_limits<uint8_t>::max());
-
-            static constexpr size_t characterSetCount = std::extent<decltype(characterSet)>::value - 1U;
-
-            for (size_t i = 0; i < characterSetCount; ++i)
-            {
-                decodeTable[static_cast<size_t>(characterSet[i])] = static_cast<uint8_t>(i);
-            }
-
-            return decodeTable;
-        }
-
-        inline void Base64Decode(Base64StringView encodedData, Base64BufferView decodedData, size_t bytesToSkip)
-        {
-            if (encodedData.GetByteCount() != (decodedData.bufferByteLength + bytesToSkip))
-            {
-                throw GLTFException("The specified decode buffer's size is incorrect");
-            }
-
-            static const std::vector<uint8_t> decodeTable = GetDecodeTable();
-
-            uint32_t block = 0U;
-            uint32_t blockBits = 0U;
-
-            uint8_t* decodedBytePtr = static_cast<uint8_t*>(decodedData.buffer);
-
-            for (const auto encodedChar : encodedData)
-            {
-                // For platforms where char is unsigned (encodedChar < 0) results in a tautology warning.
-                // Only do that test on platforms where char is signed.
-                if ((std::numeric_limits<char>::is_signed && (static_cast<signed char>(encodedChar) < 0)) || (static_cast<size_t>(encodedChar) >= decodeTable.size()))
-                {
-                    throw GLTFException("Invalid base64 character");
-                }
-
-                const auto decodedChar = decodeTable[encodedChar];
-
-                if (decodedChar == std::numeric_limits<uint8_t>::max())
-                {
-                    throw GLTFException("Invalid base64 character");
-                }
-
-                // Each character of a base64 string encodes 6 bits of data so left shift any remaining
-                // bits to accomodate another character's worth of data before performing a bitwise OR
-                block <<= 6U;
-                block |= decodedChar & 0x3F;
-
-                // Keep track of how many bits of the 'block' variable are currently used
-                blockBits += 6U;
-
-                // If there are 8 or more bits stored in 'block' then write a single byte to the output buffer
-                if (blockBits >= 8U)
-                {
-                    blockBits -= 8U;
-
-                    if (bytesToSkip > 0)
-                    {
-                        bytesToSkip--;
-                    }
-                    else
-                    {
-                        // Right shift the decoded data stored in 'block' so that the byte of
-                        // data to be written to the output buffer occupies the low-order byte
-                        *(decodedBytePtr++) = (block >> blockBits) & 0xFF;
-                    }
-
-                    // Generate a bitmask that discards only the byte just written to the output buffer during the bitwise AND
-                    block &= (1 << blockBits) - 1;
-                }
-            }
-        }
-
-        inline std::vector<uint8_t> Base64Decode(const Base64StringView& encodedData)
-        {
-            std::vector<uint8_t> decodedDataBuffer(encodedData.GetByteCount());
-
-            Base64BufferView decodedData(decodedDataBuffer);
-            Base64Decode(encodedData, decodedData, 0);
-
-            return decodedDataBuffer;
-        }
-
-        inline std::vector<uint8_t> Base64Decode(const std::string& encodedData)
-        {
-            return Base64Decode(Base64StringView(encodedData));
-        }
-
-        inline bool IsUriBase64(const std::string& uri, std::string::const_iterator& itBegin, std::string::const_iterator& itEnd)
-        {
-            // A valid base64 data URI must begin with "data:"
-            // and contain ";base64," somewhere in the string
-
-            static const char dataPrefix[] = "data:";
-            constexpr size_t dataPrefixLength = std::extent<decltype(dataPrefix)>::value - 1;
-
-            static const char base64Indicator[] = ";base64,";
-            constexpr size_t base64IndicatorLength = std::extent<decltype(base64Indicator)>::value - 1;
-
-            if (uri.compare(0, dataPrefixLength, dataPrefix) == 0)
-            {
-                const size_t findIndex = uri.find(base64Indicator);
-
-                if (findIndex != std::string::npos)
-                {
-                    itBegin = uri.begin() + findIndex + base64IndicatorLength;
-                    itEnd = uri.end();
-
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        inline bool IsUriBase64(const std::string& uri)
-        {
-            std::string::const_iterator itBegin;
-            std::string::const_iterator itEnd;
-
-            return IsUriBase64(uri, itBegin, itEnd);
-        }
-
-        // Conversions of normalized component types to/from floats are explicitly defined in the 2.0 spec
-        inline float ComponentToFloat(const float w)   { return w; }
-        inline float ComponentToFloat(const int8_t w)  { return std::max(static_cast<float>(w) / 127.0f, -1.0f); }
-        inline float ComponentToFloat(const uint8_t w) { return static_cast<float>(w) / 255.0f; }
-        inline float ComponentToFloat(const int16_t w) { return std::max(static_cast<float>(w) / 32767.0f, -1.0f); }
-        inline float ComponentToFloat(const uint16_t w){ return static_cast<float>(w) / 65535.0f; }
-
-        template<typename T>
-        inline T FloatToComponent(const float f)
-        {
-            static_assert(std::is_same<float, T>::value, "Microsoft::glTF::FloatToComponent: expecting float template type");
-            return f;
-        }
-        template<> inline int8_t   FloatToComponent<int8_t>(const float f)  { return static_cast<int8_t>(std::round(f*127.0f)); }
-        template<> inline uint8_t  FloatToComponent<uint8_t>(const float f) { return static_cast<uint8_t>(std::round(f*255.0f)); }
-        template<> inline int16_t  FloatToComponent<int16_t>(const float f) { return static_cast<int16_t>(std::round(f*32767.0f)); }
-        template<> inline uint16_t FloatToComponent<uint16_t>(const float f){ return static_cast<uint16_t>(std::round(f*65535.0f)); }
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/ResourceWriter.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/ResourceWriter.h
deleted file mode 100644
index be85cec..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/ResourceWriter.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Document.h>
-#include <GLTFSDK/GLTF.h>
-#include <GLTFSDK/IStreamCache.h>
-#include <GLTFSDK/StreamUtils.h>
-
-#include <memory>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        // The task of populating a glTF document with valid Buffer, BufferView
-        // and Accessor instances is the responsibility of other, higher-level,
-        // APIs (e.g. BufferBuilder).
-        class ResourceWriter
-        {
-        public:
-            virtual ~ResourceWriter();
-
-            virtual std::string GenerateBufferUri(const std::string& bufferId) const = 0;
-
-            void Write(const BufferView& bufferView, const void* data);
-            void Write(const BufferView& bufferView, const void* data, const Accessor& accessor);
-
-            template<typename T>
-            void Write(const BufferView& bufferView, const std::vector<T>& data)
-            {
-                const auto byteLength = data.size() * sizeof(T);
-
-                if (byteLength != bufferView.byteLength)
-                {
-                    throw InvalidGLTFException("The given vector's size in bytes doesn't equal bufferView.byteLength");
-                }
-
-                Write(bufferView, data.data());
-            }
-
-            template<typename T>
-            void Write(const BufferView& bufferView, const std::vector<T>& data, const Accessor& accessor)
-            {
-                const auto byteLength = data.size() * sizeof(T);
-
-                if (byteLength != accessor.GetByteLength())
-                {
-                    throw InvalidGLTFException("The given vector's size in bytes doesn't equal the accessor's byte length");
-                }
-
-                Write(bufferView, data.data(), accessor);
-            }
-
-            // Writes data to an output stream without referencing a Buffer, BufferView or
-            // Accessor. Useful for outputting image data to an external resource (in this
-            // case the Image instance must use the uri property).
-            void WriteExternal(const std::string& uri, const void* data, size_t byteLength) const;
-
-            void WriteExternal(const std::string& uri, const std::string& data) const;
-
-            template<typename T>
-            void WriteExternal(const std::string& uri, const std::vector<T>& data) const
-            {
-                WriteExternal(uri, data.data(), data.size() * sizeof(T));
-            }
-
-        protected:
-            ResourceWriter(std::unique_ptr<IStreamWriterCache> streamWriter);
-
-            virtual std::ostream*  GetBufferStream(const std::string& bufferId) = 0;
-            virtual std::streamoff GetBufferOffset(const std::string& bufferId) = 0;
-            virtual void           SetBufferOffset(const std::string& bufferId, std::streamoff offset) = 0;
-
-            std::unique_ptr<IStreamWriterCache> m_streamWriterCache;
-
-        private:
-            void WriteImpl(const BufferView& bufferView, const void* data, std::streamoff totalOffset, size_t totalByteLength);
-        };
-    }
-}
\ No newline at end of file
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Schema.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Schema.h
deleted file mode 100644
index c6abdcb..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Schema.h
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string>
-#include <memory>
-#include <unordered_map>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        constexpr const char SCHEMA_URI_GLTF[] = "glTF.schema.json";
-        constexpr const char SCHEMA_URI_GLTFID[] = "glTFid.schema.json";
-        constexpr const char SCHEMA_URI_GLTFCHILDOFROOTPROPERTY[] = "glTFChildOfRootProperty.schema.json";
-        constexpr const char SCHEMA_URI_GLTFPROPERTY[] = "glTFProperty.schema.json";
-        constexpr const char SCHEMA_URI_BUFFER[] = "buffer.schema.json";
-        constexpr const char SCHEMA_URI_BUFFERVIEW[] = "bufferView.schema.json";
-        constexpr const char SCHEMA_URI_ACCESSOR[] = "accessor.schema.json";
-        constexpr const char SCHEMA_URI_ACCESSORSPARSE[] = "accessor.sparse.schema.json";
-        constexpr const char SCHEMA_URI_ACCESSORSPARSEVALUES[] = "accessor.sparse.values.schema.json";
-        constexpr const char SCHEMA_URI_ACCESSORSPARSEINDICES[] = "accessor.sparse.indices.schema.json";
-        constexpr const char SCHEMA_URI_ASSET[] = "asset.schema.json";
-        constexpr const char SCHEMA_URI_SCENE[] = "scene.schema.json";
-        constexpr const char SCHEMA_URI_NODE[] = "node.schema.json";
-        constexpr const char SCHEMA_URI_MESH[] = "mesh.schema.json";
-        constexpr const char SCHEMA_URI_MESHPRIMITIVE[] = "mesh.primitive.schema.json";
-        constexpr const char SCHEMA_URI_SKIN[] = "skin.schema.json";
-        constexpr const char SCHEMA_URI_CAMERA[] = "camera.schema.json";
-        constexpr const char SCHEMA_URI_CAMERAORTHOGRAPHIC[] = "camera.orthographic.schema.json";
-        constexpr const char SCHEMA_URI_CAMERAPERSPECTIVE[] = "camera.perspective.schema.json";
-        constexpr const char SCHEMA_URI_MATERIAL[] = "material.schema.json";
-        constexpr const char SCHEMA_URI_MATERIALNORMALTEXTUREINFO[] = "material.normalTextureInfo.schema.json";
-        constexpr const char SCHEMA_URI_MATERIALOCCLUSIONTEXTUREINFO[] = "material.occlusionTextureInfo.schema.json";
-        constexpr const char SCHEMA_URI_MATERIALPBRMETALLICROUGHNESS[] = "material.pbrMetallicRoughness.schema.json";
-        constexpr const char SCHEMA_URI_TEXTURE[] = "texture.schema.json";
-        constexpr const char SCHEMA_URI_TEXTUREINFO[] = "textureInfo.schema.json";
-        constexpr const char SCHEMA_URI_IMAGE[] = "image.schema.json";
-        constexpr const char SCHEMA_URI_SAMPLER[] = "sampler.schema.json";
-        constexpr const char SCHEMA_URI_ANIMATION[] = "animation.schema.json";
-        constexpr const char SCHEMA_URI_ANIMATIONSAMPLER[] = "animation.sampler.schema.json";
-        constexpr const char SCHEMA_URI_ANIMATIONCHANNEL[] = "animation.channel.schema.json";
-        constexpr const char SCHEMA_URI_ANIMATIONCHANNELTARGET[] = "animation.channel.target.schema.json";
-        constexpr const char SCHEMA_URI_EXTENSION[] = "extension.schema.json";
-        constexpr const char SCHEMA_URI_EXTRAS[] = "extras.schema.json";
-
-        const std::unordered_map<std::string, std::string>& GetDefaultSchemaUriMap();
-
-        enum class SchemaFlags : uint64_t
-        {
-            None = 0x0,
-            DisableSchemaRoot = 0x1, // Disables all schema validation
-            DisableSchemaId = 0x2,
-            DisableSchemaChildOfRoot = 0x4,
-            DisableSchemaProperty = 0x8,
-            DisableSchemaBuffer = 0x10,
-            DisableSchemaBufferView = 0x20,
-            DisableSchemaAccessor = 0x40,
-            DisableSchemaAccessorSparse = 0x80,
-            DisableSchemaAccessorSparseValues = 0x80,
-            DisableSchemaAccessorSparseIndices = 0x100,
-            DisableSchemaAsset = 0x200,
-            DisableSchemaScene = 0x400,
-            DisableSchemaNode = 0x800,
-            DisableSchemaMesh = 0x1000,
-            DisableSchemaMeshPrimitive = 0x2000,
-            DisableSchemaSkin = 0x4000,
-            DisableSchemaCamera = 0x8000,
-            DisableSchemaCameraOrthographic = 0x10000,
-            DisableSchemaCameraPerspective = 0x20000,
-            DisableSchemaMaterial = 0x40000,
-            DisableSchemaMaterialNormalTextureInfo = 0x80000,
-            DisableSchemaMaterialOcclusionTextureInfo = 0x100000,
-            DisableSchemaMaterialPBRMetallicRoughness = 0x200000,
-            DisableSchemaTexture = 0x400000,
-            DisableSchemaTextureInfo = 0x800000,
-            DisableSchemaImage = 0x1000000,
-            DisableSchemaSampler = 0x2000000,
-            DisableSchemaAnimation = 0x4000000,
-            DisableSchemaAnimationSampler = 0x8000000,
-            DisableSchemaAnimationChannel = 0x10000000,
-            DisableSchemaAnimationChannelTarget = 0x20000000,
-            DisableSchemaExtension = 0x40000000,
-            DisableSchemaExtras = 0x80000000
-        };
-
-        SchemaFlags  operator| (SchemaFlags lhs,  SchemaFlags rhs);
-        SchemaFlags& operator|=(SchemaFlags& lhs, SchemaFlags rhs);
-        SchemaFlags  operator& (SchemaFlags lhs,  SchemaFlags rhs);
-        SchemaFlags& operator&=(SchemaFlags& lhs, SchemaFlags rhs);
-
-        std::unique_ptr<const class ISchemaLocator> GetDefaultSchemaLocator(SchemaFlags schemaFlags);
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/SchemaValidation.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/SchemaValidation.h
deleted file mode 100644
index f3d19e5..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/SchemaValidation.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/RapidJsonUtils.h>
-
-#include <memory>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class ISchemaLocator
-        {
-        public:
-            virtual ~ISchemaLocator() = default;
-            virtual const char* GetSchemaContent(const std::string& uri) const = 0;
-        };
-
-        void ValidateDocumentAgainstSchema(const rapidjson::Document& d, const std::string& schemaUri, std::unique_ptr<const ISchemaLocator> schemaLocator);
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Serialize.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Serialize.h
deleted file mode 100644
index 76b753c..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Serialize.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string>
-
-namespace Microsoft 
-{
-    namespace glTF
-    {
-        enum class SerializeFlags
-        {
-            None = 0x0,
-            Pretty = 0x1
-        };
-
-        SerializeFlags  operator| (SerializeFlags lhs,  SerializeFlags rhs);
-        SerializeFlags& operator|=(SerializeFlags& lhs, SerializeFlags rhs);
-        SerializeFlags  operator& (SerializeFlags lhs,  SerializeFlags rhs);
-        SerializeFlags& operator&=(SerializeFlags& lhs, SerializeFlags rhs);
-
-        class Document;
-        class ExtensionSerializer;
-
-        std::string Serialize(const Document& gltfDocument, SerializeFlags flags = SerializeFlags::None);
-        std::string Serialize(const Document& gltfDocument, const ExtensionSerializer& extensionHandler, SerializeFlags flags = SerializeFlags::None);
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/StreamCache.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/StreamCache.h
deleted file mode 100644
index 6b8f0e3..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/StreamCache.h
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Exceptions.h>
-#include <GLTFSDK/IStreamCache.h>
-#include <GLTFSDK/IStreamReader.h>
-#include <GLTFSDK/IStreamWriter.h>
-
-#include <functional>
-#include <unordered_map>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        template<typename TStream>
-        class StreamCache : public IStreamCache<TStream>
-        {
-        public:
-            template<typename Fn>
-            StreamCache(Fn fnGenerate) : m_cacheMap(), m_cacheFn(fnGenerate)
-            {
-            }
-
-            TStream Get(const std::string& uri) override
-            {
-                auto it = m_cacheMap.find(uri);
-
-                if (it == m_cacheMap.end())
-                {
-                    // Populate the cache with a new entry for 'uri' (acquired by calling the user supplied functor m_cacheFn)
-                    return Set(uri, m_cacheFn(uri));
-                }
-                else
-                {
-                    return it->second;
-                }
-            }
-
-            TStream Set(const std::string& uri, TStream stream) override
-            {
-                return m_cacheMap[uri] = std::move(stream);
-            }
-
-            bool Has(const std::string& uri)
-            {
-                return m_cacheMap.find(uri) != m_cacheMap.end();
-            }
-
-            void Erase(const std::string& uri)
-            {
-                auto it = m_cacheMap.find(uri);
-
-                if (it != m_cacheMap.end())
-                {
-                    m_cacheMap.erase(it);
-                }
-                else
-                {
-                    throw GLTFException("Passed key doesn't exist in the stream cache");
-                }
-            }
-
-            size_t Size() const
-            {
-                return m_cacheMap.size();
-            }
-
-        protected:
-            std::unordered_map<std::string, TStream> m_cacheMap;
-
-        private:
-            std::function<TStream(const std::string&)> m_cacheFn;
-        };
-
-        typedef StreamCache<std::shared_ptr<std::istream>> StreamReaderCache;
-        typedef StreamCache<std::shared_ptr<std::ostream>> StreamWriterCache;
-
-        template<typename TStreamCache, typename ...TArgs>
-        std::unique_ptr<TStreamCache> MakeStreamReaderCache(std::shared_ptr<const IStreamReader> streamReader, TArgs&& ...args)
-        {
-            static_assert(std::is_base_of<IStreamReaderCache, TStreamCache>::value, "Template parameter TStreamCache must derive from IStreamReaderCache");
-
-            return std::make_unique<TStreamCache>([streamReaderLocal = std::move(streamReader)](const std::string& uri)
-            {
-                return streamReaderLocal->GetInputStream(uri);
-            }, std::forward<TArgs>(args)...);
-        }
-
-        template<typename TStreamCache, typename ...TArgs>
-        std::unique_ptr<TStreamCache> MakeStreamWriterCache(std::shared_ptr<const IStreamWriter> streamWriter, TArgs&& ...args)
-        {
-            static_assert(std::is_base_of<IStreamWriterCache, TStreamCache>::value, "Template parameter TStreamCache must derive from IStreamWriterCache");
-
-            return std::make_unique<TStreamCache>([streamWriterLocal = std::move(streamWriter)](const std::string& uri)
-            {
-                return streamWriterLocal->GetOutputStream(uri);
-            }, std::forward<TArgs>(args)...);
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/StreamCacheLRU.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/StreamCacheLRU.h
deleted file mode 100644
index 3102483..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/StreamCacheLRU.h
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/StreamCache.h>
-
-#include <list>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        // Adds 'Least Recently Used' (LRU) eviction functionality via a composition relationship with the StreamCache class
-        template<typename TStream>
-        class StreamCacheLRU : public IStreamCache<TStream>
-        {
-        public:
-            template<typename Fn>
-            StreamCacheLRU(Fn fnGenerate, size_t cacheMaxSize = std::numeric_limits<size_t>::max()) :
-                cacheMaxSize(cacheMaxSize),
-                m_cache([fnGenerate, this](const std::string& uri) { return Update(uri, fnGenerate(uri)); }),
-                m_cacheList()
-            {
-                if (cacheMaxSize == 0U)
-                {
-                    throw GLTFException("LRU max cache size must be greater than zero");
-                }
-            }
-
-            TStream Get(const std::string& uri) override
-            {
-                auto it = m_cache.Get(uri);
-
-                // Sanity check that the list and cache sizes match
-                if (m_cache.Size() != m_cacheList.size())
-                {
-                    throw GLTFException("Size mismatch between cache map and list");
-                }
-
-                // Ensure the returned stream and uri are now the 'most recently used'
-                if (it != m_cacheList.begin())
-                {
-                    m_cacheList.splice(m_cacheList.begin(), m_cacheList, it);
-                }
-
-                return it->second;
-            }
-
-            TStream Set(const std::string& uri, TStream stream) override
-            {
-                // If the cache already contains an entry for 'uri' then remove it from the LRU list
-                // before calling Update, otherwise the list will contain duplicate enties for 'uri'
-                if (m_cache.Has(uri))
-                {
-                    m_cacheList.erase(m_cache.Get(uri));
-                }
-
-                // Update the LRU list then the cache with the new stream
-                auto it = m_cache.Set(uri, Update(uri, std::move(stream)));
-
-                // Sanity check that the list and cache sizes match
-                if (m_cache.Size() != m_cacheList.size())
-                {
-                    throw GLTFException("Size mismatch between cache map and list");
-                }
-
-                return it->second;
-            }
-
-            size_t Size() const
-            {
-                return m_cache.Size();
-            }
-
-            const size_t cacheMaxSize;
-
-        private:
-            typedef std::list<std::pair<std::string, TStream>> StreamCacheLRUList;
-
-            typename StreamCacheLRUList::iterator Update(const std::string& uri, TStream&& stream)
-            {
-                // Add the stream and uri to the front of the LRU list then erase the
-                // least recently used entry from the cache and LRU list if necessary
-                m_cacheList.emplace_front(uri, std::move(stream));
-
-                // Remove the LRU stream from the cache if the cache's size equals the maximum size - stream has yet to be added to the cache
-                if (m_cache.Size() == cacheMaxSize)
-                {
-                    m_cache.Erase(m_cacheList.back().first);
-                }
-
-                // Remove the LRU stream from the LRU list if the list's size exceeds the maximum size - stream has already been added to the LRU list
-                if (m_cacheList.size() > cacheMaxSize)
-                {
-                    m_cacheList.pop_back();
-                }
-
-                return m_cacheList.begin();
-            }
-
-            StreamCache<typename StreamCacheLRUList::iterator> m_cache;
-            StreamCacheLRUList m_cacheList;
-        };
-
-        typedef StreamCacheLRU<std::shared_ptr<std::istream>> StreamReaderCacheLRU;
-        typedef StreamCacheLRU<std::shared_ptr<std::ostream>> StreamWriterCacheLRU;
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/StreamUtils.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/StreamUtils.h
deleted file mode 100644
index 04c07ed..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/StreamUtils.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <istream>
-#include <ostream>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        class StreamUtils
-        {
-        public:
-            template<typename T>
-            static size_t WriteBinary(std::ostream& stream, const T& value)
-            {
-                return WriteBinary(stream, &value, sizeof(value));
-            }
-
-            static size_t WriteBinary(std::ostream& stream, const std::string& str)
-            {
-                return WriteBinary(stream, str.c_str(), str.length());
-            }
-
-            template<typename T>
-            static size_t WriteBinary(std::ostream& stream, const std::vector<T>& values)
-            {
-                return WriteBinary(stream, values.data(), values.size() * sizeof(T));
-            }
-
-            template<typename T>
-            static size_t WriteBinary(std::ostream& stream, const T* data, size_t size)
-            {
-                if (!stream.good())
-                {
-                    throw std::runtime_error("The output stream is not in a good state.");
-                }
-
-                stream.write(reinterpret_cast<const char *>(data), size);
-
-                if (stream.fail())
-                {
-                    throw std::runtime_error("Unable to write to buffer.");
-                }
-
-                return size;
-            }
-
-            template<typename T>
-            static T ReadBinary(std::istream& stream)
-            {
-                T value;
-                ReadBinary(stream, reinterpret_cast<char*>(&value), sizeof(T));
-                return value;
-            }
-
-            template<typename T>
-            static std::vector<T> ReadBinaryFull(std::istream& stream)
-            {
-                if (stream.fail())
-                {
-                    throw std::runtime_error("Cannot read the binary data");
-                }
-
-                stream.seekg(0, std::ios::end);
-                auto size = static_cast<size_t>(stream.tellg());
-                stream.seekg(0, std::ios::beg);
-
-                std::vector<T> data(size);
-                ReadBinary(stream, reinterpret_cast<char*>(data.data()), size);
-                return data;
-            }
-
-            static void ReadBinary(std::istream& stream, char* data, size_t size)
-            {
-                stream.read(data, size);
-
-                if (stream.fail())
-                {
-                    throw std::runtime_error("Cannot read the binary data");
-                }
-            }
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Traverse.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Traverse.h
deleted file mode 100644
index ecf2671..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Traverse.h
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Document.h>
-
-#include <queue>
-#include <stack>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        enum TraversalAlgorithm
-        {
-            DepthFirst,
-            BreadthFirst
-        };
-
-        namespace Detail
-        {
-            template<typename Fn>
-            void TraverseDepthFirst(const Node& node, const Document& gltfDocument, Fn& fn)
-            {
-                struct StackValue
-                {
-                    StackValue(const Node& node, const Node* nodeParent = nullptr) :
-                        m_node(node),
-                        m_nodeParent(nodeParent),
-                        m_childIndex(0UL),
-                        m_childCount(node.children.size())
-                    {
-                    }
-
-                    bool HasChildren() const
-                    {
-                        return m_childIndex < m_childCount;
-                    }
-
-                    const Node& m_node;
-                    const Node* const m_nodeParent;
-
-                    size_t m_childIndex;
-                    const size_t m_childCount;
-
-                    bool m_visited = false;
-                };
-
-                typedef std::stack<StackValue> Stack;
-
-                Stack stack;
-                stack.emplace(node);
-
-                do
-                {
-                    auto& currentNodeValue = stack.top();
-                    auto& currentNode = currentNodeValue.m_node;
-
-                    if (!currentNodeValue.m_visited)
-                    {
-                        currentNodeValue.m_visited = true;
-                        fn(currentNode, currentNodeValue.m_nodeParent);
-                    }
-
-                    if (currentNodeValue.HasChildren())
-                    {
-                        stack.emplace(gltfDocument.nodes.Get(currentNode.children[currentNodeValue.m_childIndex++]), &currentNode);
-                    }
-                    else
-                    {
-                        stack.pop();
-                    }
-                } while (!stack.empty());
-            }
-
-            template<typename Fn>
-            void TraverseBreadthFirst(const Node& node, const Document& gltfDocument, Fn& fn)
-            {
-                struct QueueValue
-                {
-                    QueueValue(const Node& node, const Node* nodeParent = nullptr) :
-                        m_node(node),
-                        m_nodeParent(nodeParent)
-                    {
-                    }
-
-                    const Node& m_node;
-                    const Node* const m_nodeParent;
-                };
-
-                typedef std::queue<QueueValue> Queue;
-
-                Queue queue;
-                queue.emplace(node);
-
-                do
-                {
-                    auto& currentNodeValue = queue.front();
-                    auto& currentNode = currentNodeValue.m_node;
-
-                    fn(currentNode, currentNodeValue.m_nodeParent);
-
-                    for (const auto& childId : currentNode.children)
-                    {
-                        queue.emplace(gltfDocument.nodes[childId], &currentNode);
-                    }
-
-                    queue.pop();
-                } while (!queue.empty());
-            }
-
-            // Used for tag dispatching - call TraverseDepthFirst or TraverseBreadthFirst without an if-statement
-            template<TraversalAlgorithm>
-            struct TraversalAlgorithmTag {};
-
-            template<typename Fn>
-            void TraverseNode(TraversalAlgorithmTag<DepthFirst>, const Node& node, const Document& gltfDocument, Fn& fn)
-            {
-                TraverseDepthFirst(node, gltfDocument, fn);
-            }
-
-            template<typename Fn>
-            void TraverseNode(TraversalAlgorithmTag<BreadthFirst>, const Node& node, const Document& gltfDocument, Fn& fn)
-            {
-                TraverseBreadthFirst(node, gltfDocument, fn);
-            }
-        }
-
-        const size_t DefaultSceneIndex = std::numeric_limits<size_t>::max();
-
-        template<TraversalAlgorithm Algorithm = DepthFirst, typename Fn>
-        void Traverse(const Document& gltfDocument, size_t sceneIndex, Fn&& fn)
-        {
-            // The fn parameter is a forwarding reference (can be a rvalue or lvalue). This copy is necessary
-            // as TraverseNode's fn parameter is a non-const reference (which can only be bound to an lvalue)
-            Fn fnCopy = std::forward<Fn>(fn);
-
-            const Scene& scene = (sceneIndex == DefaultSceneIndex) ?
-                gltfDocument.GetDefaultScene() :
-                gltfDocument.scenes[sceneIndex];
-
-            for (const auto& nodeId : scene.nodes)
-            {
-                Detail::TraverseNode(Detail::TraversalAlgorithmTag<Algorithm>(), gltfDocument.nodes.Get(nodeId), gltfDocument, fnCopy);
-            }
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Validation.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Validation.h
deleted file mode 100644
index 900e790..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Validation.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Document.h>
-
-#include <set>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        namespace Validation
-        {
-            void Validate(const Document& doc);
-            void ValidateAccessors(const Document& doc);
-            void ValidateMeshes(const Document& doc);
-            void ValidateMeshPrimitive(const Document& doc, const MeshPrimitive& primitive);
-            void ValidateMeshPrimitiveAttributeAccessors(const Document& doc, const std::unordered_map<std::string, std::string>& attributes, const size_t vertexCount);
-            void ValidateAccessorTypes(const Accessor& accessor, const std::string& accessorName,
-                const std::set<AccessorType>& accessorTypes, const std::set<ComponentType>& componentTypes);
-            void ValidateAccessor(const Document& doc, const Accessor& accessor);
-            void ValidateBufferView(const BufferView& buffer_view, const Buffer& buffer);
-
-            bool SafeAddition(size_t a, size_t b, size_t& result);
-            bool SafeMultiplication(size_t a, size_t b, size_t& result);
-        };
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Version.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Version.h
deleted file mode 100644
index 2572f7b..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Version.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <tuple>
-#include <string>
-
-#include <cstdint>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        struct Version
-        {
-            uint32_t major;
-            uint32_t minor;
-
-            constexpr Version(uint32_t major, uint32_t minor) : major(major), minor(minor)
-            {
-            }
-
-            constexpr Version(const std::tuple<uint32_t, uint32_t>& version) : Version(std::get<0>(version), std::get<1>(version))
-            {
-            }
-
-            explicit Version(const char* version);
-            explicit Version(const std::string& version);
-
-            std::string AsString() const;
-
-            bool operator==(const Version& rhs) const;
-            bool operator!=(const Version& rhs) const;
-
-            static std::tuple<uint32_t, uint32_t> AsTuple(const char* version);
-        };
-
-        namespace Versions
-        {
-            constexpr Version v2_0 = { 2U, 0U };
-        }
-
-        bool IsMinVersionRequirementSatisfied(const Version& minVersion, std::initializer_list<Version> supported = { Versions::v2_0 });
-        bool IsMinVersionRequirementSatisfied(const std::string& minVersion, std::initializer_list<Version> supported = { Versions::v2_0 });
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/GLTFSDK/Visitor.h b/thirdparty/GLTFSDK/Inc/GLTFSDK/Visitor.h
deleted file mode 100644
index 0f14a90..0000000
--- a/thirdparty/GLTFSDK/Inc/GLTFSDK/Visitor.h
+++ /dev/null
@@ -1,398 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <GLTFSDK/Traverse.h>
-
-#include <set>
-#include <typeindex>
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        // Enumeration used to track if a particular entity has been visited or not
-        enum class VisitState
-        {
-            New,
-            Duplicate
-        };
-
-        // Namespace contains implementation details of the Visit function - not part of the public API
-        namespace Detail
-        {
-            // When the callable object can be invokable there will be two equally valid function
-            // overloads to choose from. These tag structs are used to ensure that the 'do nothing'
-            // overload is never the 'best' candidate function during overload resolution.
-            struct Priority2 {};
-            struct Priority1 : Priority2 {};
-
-            // The function overload called when 'callable' object fn can be invoked with the argument types TArgs...
-            template<typename Fn, typename ...TArgs>
-            auto TryInvokeImpl(Priority1, Fn&& fn, TArgs&& ...args) -> decltype(std::declval<Fn>()(std::declval<TArgs>()...))
-            {
-                return fn(std::forward<TArgs>(args)...);
-            }
-
-            // The 'do nothing' overload called if the 'callable' object invoked with the argument types is not well formed
-            template<typename Fn, typename ...TArgs>
-            auto TryInvokeImpl(Priority2, Fn&&, TArgs&& ...) -> void
-            {
-            }
-
-            // TryInvoke will invoke the 'callable' object fn only if the type Fn, when invoked with the argument
-            // types TArgs..., is a well formed expression. Otherwise TryInvoke evaluates to an empty function call.
-            template<typename Fn, typename ...TArgs>
-            void TryInvoke(Fn&& fn, TArgs&& ...args)
-            {
-                TryInvokeImpl(Priority1(), std::forward<Fn>(fn), std::forward<TArgs>(args)...);
-            }
-
-            // Helper class for keeping track of which entities have been previously visited
-            class VisitStateSet
-            {
-            public:
-                template<typename T>
-                VisitState GetVisitState(const T& t) const
-                {
-                    return visitStateSet.find({ typeid(T), std::stoul(t.id) }) == visitStateSet.end() ?
-                        VisitState::New :
-                        VisitState::Duplicate;
-                }
-
-                template<typename T>
-                VisitState SetVisitState(const T& t)
-                {
-                    // Attempt to insert a unique identifier for the entity instance into the container by
-                    // combining the type information (resolved at compile time) and glTF index property.
-                    const auto result = visitStateSet.emplace(typeid(T), std::stoul(t.id));
-
-                    // If the insertion succeeded then the entity hasn't yet been visited. Otherwise
-                    // it is a 'duplicate' reference to an object that has already been visited.
-                    return result.second ?
-                        VisitState::New :
-                        VisitState::Duplicate;
-                }
-
-            private:
-                std::set<std::pair<std::type_index, size_t>> visitStateSet;
-            };
-
-            // Gets the 'raw' type of a template parameter so it can be inherited from
-            template<typename Fn>
-            using CombineInvokableBase = std::remove_cv_t<std::remove_reference_t<Fn>>;
-
-            // Wrapper type that is used to combine multiple 'callable' objects (e.g. lambda or
-            // function objects) into a single callable type with multiple function call operators.
-            // This is done by defining a new type deriving from all of the input callable types.
-            //
-            // Inspired by the 'overloaded' type used in the example code at:
-            //
-            // http://en.cppreference.com/w/cpp/utility/variant/visit
-            //
-            // but modified to work with C++14 as using statements are not valid pack expansion
-            // loci until C++17.
-            template<typename Fn, typename ...FArgs>
-            struct CombineInvokable : CombineInvokable<Fn>, CombineInvokable<FArgs...>
-            {
-                CombineInvokable(Fn fn, FArgs ...fargs) :
-                    CombineInvokable<Fn>(std::forward<Fn>(fn)),
-                    CombineInvokable<FArgs...>(std::forward<FArgs>(fargs)...)
-                {
-                }
-
-                using CombineInvokable<Fn>::operator();
-                using CombineInvokable<FArgs...>::operator();
-            };
-
-            // Specialization for the single type case - inherits from, and also copies, the passed 'callable' object
-            template<typename Fn>
-            struct CombineInvokable<Fn> : CombineInvokableBase<Fn>
-            {
-                CombineInvokable(Fn fn) : CombineInvokableBase<Fn>(std::forward<Fn>(fn))
-                {
-                }
-
-                using CombineInvokableBase<Fn>::operator();
-            };
-        }
-
-        class VisitDefaultAction
-        {
-        public:
-            VisitDefaultAction(const Document& gltfDocument, Detail::VisitStateSet& visitStateSet) : gltfDocument(gltfDocument), visitStateSet(visitStateSet)
-            {
-            }
-
-            // There is no Visit() overload for MeshPrimitive as it lacks an 'id'
-            // member variable and therefore cannot have its visit state tracked
-
-            virtual void Visit(const Mesh& mesh) const = 0;
-            virtual void Visit(const Material& material) const = 0;
-            virtual void Visit(const Texture& texture, TextureType textureType) const = 0;
-            virtual void Visit(const Image& image) const = 0;
-            virtual void Visit(const Sampler& sampler) const = 0;
-            virtual void Visit(const Skin& skin) const = 0;
-            virtual void Visit(const Camera& camera) const = 0;
-
-            const Document& gltfDocument;
-
-        protected:
-            Detail::VisitStateSet& visitStateSet;
-        };
-
-        template<typename Fn>
-        class VisitDefaultActionImpl : public VisitDefaultAction
-        {
-        public:
-            VisitDefaultActionImpl(const Document& gltfDocument, Detail::VisitStateSet& visitStateSet, Fn& fn) : VisitDefaultAction(gltfDocument, visitStateSet), fn(fn)
-            {
-            }
-
-            void Visit(const Mesh& mesh) const override
-            {
-                VisitImpl(gltfDocument, visitStateSet, fn, mesh);
-            }
-
-            void Visit(const Material& material) const override
-            {
-                VisitImpl(gltfDocument, visitStateSet, fn, material);
-            }
-
-            void Visit(const Texture& texture, TextureType textureType) const override
-            {
-                VisitImpl(gltfDocument, visitStateSet, fn, texture, textureType);
-            }
-
-            void Visit(const Image& image) const override
-            {
-                VisitImpl(gltfDocument, visitStateSet, fn, image);
-            }
-
-            void Visit(const Sampler& sampler) const override
-            {
-                VisitImpl(gltfDocument, visitStateSet, fn, sampler);
-            }
-
-            void Visit(const Skin& skin) const override
-            {
-                VisitImpl(gltfDocument, visitStateSet, fn, skin);
-            }
-
-            void Visit(const Camera& camera) const override
-            {
-                VisitImpl(gltfDocument, visitStateSet, fn, camera);
-            }
-
-        private:
-            Fn& fn;
-        };
-
-        template<typename Fn>
-        void VisitImpl(const Document& gltfDocument, Detail::VisitStateSet& visitStateSet, Fn& fn, const Mesh& mesh)
-        {
-            const VisitState visitStateMesh = visitStateSet.GetVisitState(mesh);
-
-            Detail::TryInvoke(fn, mesh, visitStateMesh);
-            Detail::TryInvoke(fn, mesh, visitStateMesh, VisitDefaultActionImpl<Fn>(gltfDocument, visitStateSet, fn));
-
-            visitStateSet.SetVisitState(mesh);
-
-            for (const auto& meshPrimitive : mesh.primitives)
-            {
-                if (!meshPrimitive.materialId.empty())
-                {
-                    VisitImpl(gltfDocument, visitStateSet, fn, gltfDocument.materials.Get(meshPrimitive.materialId));
-                }
-
-                // The 'visit state' used here is that of the parent mesh, not the mesh
-                // primitive, as a mesh primitive is defined inline and has no id property
-                Detail::TryInvoke(fn, meshPrimitive, visitStateMesh);
-                Detail::TryInvoke(fn, meshPrimitive, visitStateMesh, VisitDefaultActionImpl<Fn>(gltfDocument, visitStateSet, fn));
-            }
-        }
-
-        template<typename Fn>
-        void VisitImpl(const Document& gltfDocument, Detail::VisitStateSet& visitStateSet, Fn& fn, const Material& material)
-        {
-            const VisitState visitStateMaterial = visitStateSet.GetVisitState(material);
-
-            Detail::TryInvoke(fn, material, visitStateMaterial);
-            Detail::TryInvoke(fn, material, visitStateMaterial, VisitDefaultActionImpl<Fn>(gltfDocument, visitStateSet, fn));
-
-            visitStateSet.SetVisitState(material);
-
-            for (const auto& textureInfo : material.GetTextures())
-            {
-                const auto& textureId = textureInfo.first;
-
-                if (!textureId.empty())
-                {
-                    VisitImpl(gltfDocument, visitStateSet, fn, gltfDocument.textures.Get(textureId), textureInfo.second);
-                }
-            }
-        }
-
-        template<typename Fn>
-        void VisitImpl(const Document& gltfDocument, Detail::VisitStateSet& visitStateSet, Fn& fn, const Texture& texture, TextureType textureType)
-        {
-            const VisitState visitStateTexture = visitStateSet.GetVisitState(texture);
-
-            // Note that the texture 'callback' also includes a 'type' parameter
-            Detail::TryInvoke(fn, texture, textureType, visitStateTexture);
-            Detail::TryInvoke(fn, texture, textureType, visitStateTexture, VisitDefaultActionImpl<Fn>(gltfDocument, visitStateSet, fn));
-
-            visitStateSet.SetVisitState(texture);
-
-            if (!texture.imageId.empty())
-            {
-                VisitImpl(gltfDocument, visitStateSet, fn, gltfDocument.images.Get(texture.imageId));
-            }
-
-            if (!texture.samplerId.empty())
-            {
-                VisitImpl(gltfDocument, visitStateSet, fn, gltfDocument.samplers.Get(texture.samplerId));
-            }
-        }
-
-        template<typename Fn>
-        void VisitImpl(const Document& gltfDocument, Detail::VisitStateSet& visitStateSet, Fn& fn, const Image& image)
-        {
-            const VisitState visitStateImage = visitStateSet.GetVisitState(image);
-
-            Detail::TryInvoke(fn, image, visitStateImage);
-            Detail::TryInvoke(fn, image, visitStateImage, VisitDefaultActionImpl<Fn>(gltfDocument, visitStateSet, fn));
-
-            visitStateSet.SetVisitState(image);
-        }
-
-        template<typename Fn>
-        void VisitImpl(const Document& gltfDocument, Detail::VisitStateSet& visitStateSet, Fn& fn, const Sampler& sampler)
-        {
-            const VisitState visitStateSampler = visitStateSet.GetVisitState(sampler);
-
-            Detail::TryInvoke(fn, sampler, visitStateSampler);
-            Detail::TryInvoke(fn, sampler, visitStateSampler, VisitDefaultActionImpl<Fn>(gltfDocument, visitStateSet, fn));
-
-            visitStateSet.SetVisitState(sampler);
-        }
-
-        template<typename Fn>
-        void VisitImpl(const Document& gltfDocument, Detail::VisitStateSet& visitStateSet, Fn& fn, const Skin& skin)
-        {
-            const VisitState visitStateSkin = visitStateSet.GetVisitState(skin);
-
-            Detail::TryInvoke(fn, skin, visitStateSkin);
-            Detail::TryInvoke(fn, skin, visitStateSkin, VisitDefaultActionImpl<Fn>(gltfDocument, visitStateSet, fn));
-
-            visitStateSet.SetVisitState(skin);
-        }
-
-        template<typename Fn>
-        void VisitImpl(const Document& gltfDocument, Detail::VisitStateSet& visitStateSet, Fn& fn, const Camera& camera)
-        {
-            const VisitState visitStateCamera = visitStateSet.GetVisitState(camera);
-
-            Detail::TryInvoke(fn, camera, visitStateCamera);
-            Detail::TryInvoke(fn, camera, visitStateCamera, VisitDefaultActionImpl<Fn>(gltfDocument, visitStateSet, fn));
-
-            visitStateSet.SetVisitState(camera);
-        }
-
-        // Visit - implements a variant of the visitor pattern.
-        //
-        // Applies the visitor object 'fn' to each of the entities in the passed glTF document. The order in which
-        // entities are visited is controlled by the Algorithm template parameter. The traversal algorithm can be
-        // either depth-first or breadth-first search.
-        //
-        // The visitor object can be any callable type, such as a function pointer, functor or lambda. The visitor
-        // does not need to explicitly implement any interface but will only be called if it exactly matches the
-        // expected function signature for a given glTF entity. The signatures for each entity are as follows:
-        //
-        // Node          -> visitor.operator()(const Node&, const Node*)
-        // Mesh          -> visitor.operator()(const Mesh&, VisitState, const VisitDefaultAction&)
-        // MeshPrimitive -> visitor.operator()(const MeshPrimitive&, VisitState, const VisitDefaultAction&)
-        // Material      -> visitor.operator()(const Material&, VisitState, const VisitDefaultAction&)
-        // Texture       -> visitor.operator()(const Texture&, TextureType, VisitState, const VisitDefaultAction&)
-        // Image         -> visitor.operator()(const Image&, VisitState, const VisitDefaultAction&)
-        // Sampler       -> visitor.operator()(const Sampler&, VisitState, const VisitDefaultAction&)
-        // Skin          -> visitor.operator()(const Skin&, VisitState, const VisitDefaultAction&)
-        // Camera        -> visitor.operator()(const Camera&, VisitState, const VisitDefaultAction&)
-        //
-        // All of the 'callbacks' are optional - it is even acceptable to call Visit with a type that matches none
-        // of the expected function signatures.
-        //
-        // Example:
-        //
-        // struct MyVisitor
-        // {
-        //     void operator()(const Node& node, const Node* nodeParent)
-        //     {
-        //         if (!nodeParent)
-        //         {
-        //             std::cout << "Visited a root node!";
-        //         }
-        //     }
-        // };
-        //
-        // Visit(document, DefaultSceneIndex, MyVisitor());
-        //
-        template<TraversalAlgorithm Algorithm = DepthFirst, typename Fn>
-        void Visit(const Document& gltfDocument, size_t sceneIndex, Fn&& fn)
-        {
-            Detail::VisitStateSet visitStateSet;
-
-            Traverse<Algorithm>(gltfDocument, sceneIndex,
-                [&gltfDocument, &visitStateSet, fn = std::forward<Fn>(fn)](const Node& node, const Node* nodeParent) mutable
-            {
-                // Ensure that the scene hierarchy is a tree rather than a DAG
-                if (visitStateSet.SetVisitState(node) == VisitState::New)
-                {
-                    Detail::TryInvoke(fn, node, nodeParent);
-                }
-                else
-                {
-                    throw InvalidGLTFException("Node " + node.id + " has already been visited. This is not allowed - nodes may only have a single parent.");
-                }
-
-                if (!node.meshId.empty())
-                {
-                    VisitImpl(gltfDocument, visitStateSet, fn, gltfDocument.meshes.Get(node.meshId));
-                }
-
-                if (!node.skinId.empty())
-                {
-                    VisitImpl(gltfDocument, visitStateSet, fn, gltfDocument.skins.Get(node.skinId));
-                }
-
-                if (!node.cameraId.empty())
-                {
-                    VisitImpl(gltfDocument, visitStateSet, fn, gltfDocument.cameras.Get(node.cameraId));
-                }
-            });
-        }
-
-        // Visit - implements a variant of the visitor pattern.
-        //
-        // Overload that accepts multiple 'callable' objects. Can be used with multiple lambda functions.
-        //
-        // Example:
-        //
-        // Visit(document, DefaultSceneIndex,
-        //     [](const Node& node, const Node* nodeParent)
-        // {
-        //     std::cout << "Visited a node!";
-        // },
-        //     [](const Mesh& mesh, VisitState vs)
-        // {
-        //     std::cout << "Visited a mesh!";
-        // });
-        //
-        template<TraversalAlgorithm Algorithm = DepthFirst, typename ...FArgs>
-        void Visit(const Document& gltfDocument, size_t sceneIndex, FArgs&& ...fargs)
-        {
-            Visit<Algorithm>(gltfDocument, sceneIndex, Detail::CombineInvokable<FArgs...>(std::forward<FArgs>(fargs)...));
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/Inc/SchemaJson.h b/thirdparty/GLTFSDK/Inc/SchemaJson.h
deleted file mode 100644
index b477121..0000000
--- a/thirdparty/GLTFSDK/Inc/SchemaJson.h
+++ /dev/null
@@ -1,1624 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-// WARNING: This header file was automatically generated
-// by GenerateSchemaJsonHeader.ps1.
-// Modifying this code by hand is not recommended.
-
-#pragma once
-
-#include <string>
-
-#include <unordered_map>
-
-namespace Microsoft {
-
-  namespace glTF {
-
-    class SchemaJson {
-
-      public:
-
-      static const char* const accessor_schema_json;
-
-      static const char* const accessor_sparse_indices_schema_json;
-
-      static const char* const accessor_sparse_schema_json;
-
-      static const char* const accessor_sparse_values_schema_json;
-
-      static const char* const animation_channel_schema_json;
-
-      static const char* const animation_channel_target_schema_json;
-
-      static const char* const animation_sampler_schema_json;
-
-      static const char* const animation_schema_json;
-
-      static const char* const asset_schema_json;
-
-      static const char* const buffer_schema_json;
-
-      static const char* const bufferView_schema_json;
-
-      static const char* const camera_orthographic_schema_json;
-
-      static const char* const camera_perspective_schema_json;
-
-      static const char* const camera_schema_json;
-
-      static const char* const extension_schema_json;
-
-      static const char* const extras_schema_json;
-
-      static const char* const glTF_schema_json;
-
-      static const char* const glTFChildOfRootProperty_schema_json;
-
-      static const char* const glTFid_schema_json;
-
-      static const char* const glTFProperty_schema_json;
-
-      static const char* const image_schema_json;
-
-      static const char* const material_normalTextureInfo_schema_json;
-
-      static const char* const material_occlusionTextureInfo_schema_json;
-
-      static const char* const material_pbrMetallicRoughness_schema_json;
-
-      static const char* const material_schema_json;
-
-      static const char* const mesh_primitive_schema_json;
-
-      static const char* const mesh_schema_json;
-
-      static const char* const node_schema_json;
-
-      static const char* const sampler_schema_json;
-
-      static const char* const scene_schema_json;
-
-      static const char* const skin_schema_json;
-
-      static const char* const texture_schema_json;
-
-      static const char* const textureInfo_schema_json;
-
-      static const std::unordered_map<std::string, std::string> GLTF_SCHEMA_MAP;
-
-    }; // end class SchemaJson scope
-
-    const char* const SchemaJson::material_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Material",
-            "type": "object",
-            "description": "The material appearance of a primitive.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "name": { },
-                "extensions": { },
-                "extras": { },
-                "pbrMetallicRoughness": {
-                    "allOf": [ { "$ref": "material.pbrMetallicRoughness.schema.json" } ],
-                    "description": "A set of parameter values that are used to define the metallic-roughness material model from Physically-Based Rendering (PBR) methodology. When not specified, all the default values of `pbrMetallicRoughness` apply."
-                },
-                "normalTexture": {
-                    "allOf": [ { "$ref": "material.normalTextureInfo.schema.json" } ],
-                    "description": "The normal map texture.",
-                    "gltf_detailedDescription": "A tangent space normal map. The texture contains RGB components in linear space. Each texel represents the XYZ components of a normal vector in tangent space. Red [0 to 255] maps to X [-1 to 1]. Green [0 to 255] maps to Y [-1 to 1]. Blue [128 to 255] maps to Z [1/255 to 1]. The normal vectors use OpenGL conventions where +X is right and +Y is up. +Z points toward the viewer. In GLSL, this vector would be unpacked like so: `float3 normalVector = tex2D(<sampled normal map texture value>, texCoord) * 2 - 1`. Client implementations should normalize the normal vectors before using them in lighting equations."
-                },
-                "occlusionTexture": {
-                    "allOf": [ { "$ref": "material.occlusionTextureInfo.schema.json" } ],
-                    "description": "The occlusion map texture.",
-                    "gltf_detailedDescription": "The occlusion map texture. The occlusion values are sampled from the R channel. Higher values indicate areas that should receive full indirect lighting and lower values indicate no indirect lighting. These values are linear. If other channels are present (GBA), they are ignored for occlusion calculations."
-                },
-                "emissiveTexture": {
-                    "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-                    "description": "The emissive map texture.",
-                    "gltf_detailedDescription": "The emissive map controls the color and intensity of the light being emitted by the material. This texture contains RGB components in sRGB color space. If a fourth component (A) is present, it is ignored."
-                },
-                "emissiveFactor": {
-                    "type": "array",
-                    "items": {
-                        "type": "number",
-                        "minimum": 0.0,
-                        "maximum": 1.0
-                    },
-                    "minItems": 3,
-                    "maxItems": 3,
-                    "default": [ 0.0, 0.0, 0.0 ],
-                    "description": "The emissive color of the material.",
-                    "gltf_detailedDescription": "The RGB components of the emissive color of the material. These values are linear. If an emissiveTexture is specified, this value is multiplied with the texel values."
-                },
-                "alphaMode": {
-                    "default": "OPAQUE",
-                    "description": "The alpha rendering mode of the material.",
-                    "gltf_detailedDescription": "The material's alpha rendering mode enumeration specifying the interpretation of the alpha value of the main factor and texture.",
-                    "anyOf": [
-                        {
-                            "enum": [ "OPAQUE" ],
-                            "description": "The alpha value is ignored and the rendered output is fully opaque."
-                        },
-                        {
-                            "enum": [ "MASK" ],
-                            "description": "The rendered output is either fully opaque or fully transparent depending on the alpha value and the specified alpha cutoff value."
-                        },
-                        {
-                            "enum": [ "BLEND" ],
-                            "description": "The alpha value is used to composite the source and destination areas. The rendered output is combined with the background using the normal painting operation (i.e. the Porter and Duff over operator)."
-                        },
-                        {
-                            "type": "string"
-                        }
-                    ]
-                },
-                "alphaCutoff": {
-                    "type": "number",
-                    "minimum": 0.0,
-                    "default": 0.5,
-                    "description": "The alpha cutoff value of the material.",
-                    "gltf_detailedDescription": "Specifies the cutoff threshold when in `MASK` mode. If the alpha value is greater than or equal to this value then it is rendered as fully opaque, otherwise, it is rendered as fully transparent. A value greater than 1.0 will render the entire material as fully transparent. This value is ignored for other modes."
-                },
-                "doubleSided": {
-                    "type": "boolean",
-                    "default": false,
-                    "description": "Specifies whether the material is double sided.",
-                    "gltf_detailedDescription": "Specifies whether the material is double sided. When this value is false, back-face culling is enabled. When this value is true, back-face culling is disabled and double sided lighting is enabled. The back-face must have its normals reversed before the lighting equation is evaluated."
-                }
-            },
-             "dependencies" : {
-                "alphaCutoff" : ["alphaMode"]
-            }
-        }
-        )rawstring";
-
-    const char* const SchemaJson::glTFChildOfRootProperty_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "glTF Child of Root Property",
-            "type": "object",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "name": {
-                    "type": "string",
-                    "description": "The user-defined name of this object.",
-                    "gltf_detailedDescription": "The user-defined name of this object.  This is not necessarily unique, e.g., an accessor and a buffer could have the same name, or two accessors could even have the same name."
-                }
-            }
-        }
-        )rawstring";
-
-    const char* const SchemaJson::image_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Image",
-            "type": "object",
-            "description": "Image data used to create a texture. Image can be referenced by URI or `bufferView` index. `mimeType` is required in the latter case.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "uri": {
-                    "type": "string",
-                    "description": "The uri of the image.",
-                    "format": "uriref",
-                    "gltf_detailedDescription": "The uri of the image.  Relative paths are relative to the .gltf file.  Instead of referencing an external file, the uri can also be a data-uri.  The image format must be jpg or png.",
-                    "gltf_uriType": "image"
-                },
-                "mimeType": {
-                    "anyOf": [
-                        {
-                            "enum": [ "image/jpeg" ]
-                        },
-                        {
-                            "enum": [ "image/png" ]
-                        },
-                        {
-                            "type": "string"
-                        }
-                    ],
-                    "description": "The image's MIME type."
-                },
-                "bufferView": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the bufferView that contains the image. Use this instead of the image's uri property."
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "dependencies": {
-                "bufferView": [ "mimeType" ]
-            },
-            "oneOf": [
-                { "required": [ "uri" ] },
-                { "required": [ "bufferView" ] }
-            ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::animation_sampler_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Animation Sampler",
-            "type": "object",
-            "description": "Combines input and output accessors with an interpolation algorithm to define a keyframe graph (but not its target).",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "input": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of an accessor containing keyframe input values, e.g., time.",
-                    "gltf_detailedDescription": "The index of an accessor containing keyframe input values, e.g., time. That accessor must have componentType `FLOAT`. The values represent time in seconds with `time[0] >= 0.0`, and strictly increasing values, i.e., `time[n + 1] > time[n]`."
-                },
-                "interpolation": {
-                    "description": "Interpolation algorithm.",
-                    "default": "LINEAR",
-                    "gltf_detailedDescription": "Interpolation algorithm.",
-                    "anyOf": [
-                        {
-                            "enum": [ "LINEAR" ],
-                            "description": "The animated values are linearly interpolated between keyframes. When targeting a rotation, spherical linear interpolation (slerp) should be used to interpolate quaternions. The number output of elements must equal the number of input elements."
-                        },
-                        {
-                            "enum": [ "STEP" ],
-                            "description": "The animated values remain constant to the output of the first keyframe, until the next keyframe. The number of output elements must equal the number of input elements."
-                        },
-                        {
-                            "enum": [ "CUBICSPLINE" ],
-                            "description": "The animation's interpolation is computed using a cubic spline with specified tangents. The number of output elements must equal three times the number of input elements. For each input element, the output stores three elements, an in-tangent, a spline vertex, and an out-tangent. There must be at least two keyframes when using this interpolation."
-                        },
-                        {
-                            "type": "string"
-                        }
-                    ]
-                },
-                "output": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of an accessor, containing keyframe output values.",
-                    "gltf_detailedDescription": "The index of an accessor containing keyframe output values. When targeting translation or scale paths, the `accessor.componentType` of the output values must be `FLOAT`. When targeting rotation or morph weights, the `accessor.componentType` of the output values must be `FLOAT` or normalized integer. For weights, each output element stores `SCALAR` values with a count equal to the number of morph targets."
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "input", "output" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::sampler_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Sampler",
-            "type": "object",
-            "description": "Texture sampler properties for filtering and wrapping modes.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "magFilter": {
-                    "description": "Magnification filter.",
-                    "gltf_detailedDescription": "Magnification filter.  Valid values correspond to WebGL enums: `9728` (NEAREST) and `9729` (LINEAR).",
-                    "gltf_webgl": "`texParameterf()` with pname equal to TEXTURE_MAG_FILTER",
-                    "anyOf": [
-                        {
-                            "enum": [ 9728 ],
-                            "description": "NEAREST"
-                        },
-                        {
-                            "enum": [ 9729 ],
-                            "description": "LINEAR"
-                        },
-                        {
-                            "type": "integer"
-                        }
-                    ]
-                },
-                "minFilter": {
-                    "description": "Minification filter.",
-                    "gltf_detailedDescription": "Minification filter.  All valid values correspond to WebGL enums.",
-                    "gltf_webgl": "`texParameterf()` with pname equal to TEXTURE_MIN_FILTER",
-                    "anyOf": [
-                        {
-                            "enum": [ 9728 ],
-                            "description": "NEAREST"
-                        },
-                        {
-                            "enum": [ 9729 ],
-                            "description": "LINEAR"
-                        },
-                        {
-                            "enum": [ 9984 ],
-                            "description": "NEAREST_MIPMAP_NEAREST"
-                        },
-                        {
-                            "enum": [ 9985 ],
-                            "description": "LINEAR_MIPMAP_NEAREST"
-                        },
-                        {
-                            "enum": [ 9986 ],
-                            "description": "NEAREST_MIPMAP_LINEAR"
-                        },
-                        {
-                            "enum": [ 9987 ],
-                            "description": "LINEAR_MIPMAP_LINEAR"
-                        },
-                        {
-                            "type": "integer"
-                        }
-                    ]
-                },
-                "wrapS": {
-                    "description": "s wrapping mode.",
-                    "default": 10497,
-                    "gltf_detailedDescription": "S (U) wrapping mode.  All valid values correspond to WebGL enums.",
-                    "gltf_webgl": "`texParameterf()` with pname equal to TEXTURE_WRAP_S",
-                    "anyOf": [
-                        {
-                            "enum": [ 33071 ],
-                            "description": "CLAMP_TO_EDGE"
-                        },
-                        {
-                            "enum": [ 33648 ],
-                            "description": "MIRRORED_REPEAT"
-                        },
-                        {
-                            "enum": [ 10497 ],
-                            "description": "REPEAT"
-                        },
-                        {
-                            "type": "integer"
-                        }
-                    ]
-                },
-                "wrapT": {
-                    "description": "t wrapping mode.",
-                    "default": 10497,
-                    "gltf_detailedDescription": "T (V) wrapping mode.  All valid values correspond to WebGL enums.",
-                    "gltf_webgl": "`texParameterf()` with pname equal to TEXTURE_WRAP_T",
-                    "anyOf": [
-                        {
-                            "enum": [ 33071 ],
-                            "description": "CLAMP_TO_EDGE"
-                        },
-                        {
-                            "enum": [ 33648 ],
-                            "description": "MIRRORED_REPEAT"
-                        },
-                        {
-                            "enum": [ 10497 ],
-                            "description": "REPEAT"
-                        },
-                        {
-                            "type": "integer"
-                        }
-                    ]
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "gltf_webgl": "`texParameterf()`"
-        }
-        )rawstring";
-
-    const char* const SchemaJson::extension_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Extension",
-            "type": "object",
-            "description": "Dictionary object with extension-specific objects.",
-            "properties": {
-            },
-            "additionalProperties": {
-                "type": "object"
-            }
-        }
-        )rawstring";
-
-    const char* const SchemaJson::buffer_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Buffer",
-            "type": "object",
-            "description": "A buffer points to binary geometry, animation, or skins.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "uri": {
-                    "type": "string",
-                    "description": "The uri of the buffer.",
-                    "format": "uriref",
-                    "gltf_detailedDescription": "The uri of the buffer.  Relative paths are relative to the .gltf file.  Instead of referencing an external file, the uri can also be a data-uri.",
-                    "gltf_uriType": "application"
-                },
-                "byteLength": {
-                    "type": "integer",
-                    "description": "The length of the buffer in bytes.",
-                    "minimum": 1
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "byteLength" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::node_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Node",
-            "type": "object",
-            "description": "A node in the node hierarchy.  When the node contains `skin`, all `mesh.primitives` must contain `JOINTS_0` and `WEIGHTS_0` attributes.  A node can have either a `matrix` or any combination of `translation`/`rotation`/`scale` (TRS) properties. TRS properties are converted to matrices and postmultiplied in the `T * R * S` order to compose the transformation matrix; first the scale is applied to the vertices, then the rotation, and then the translation. If none are provided, the transform is the identity. When a node is targeted for animation (referenced by an animation.channel.target), only TRS properties may be present; `matrix` will not be present.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "camera": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the camera referenced by this node."
-                },
-                "children": {
-                    "type": "array",
-                    "description": "The indices of this node's children.",
-                    "items": {
-                        "$ref": "glTFid.schema.json"
-                    },
-                    "uniqueItems": true,
-                    "minItems": 1
-                },
-                "skin": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the skin referenced by this node."
-                },
-                "matrix": {
-                    "type": "array",
-                    "description": "A floating-point 4x4 transformation matrix stored in column-major order.",
-                    "items": {
-                        "type": "number"
-                    },
-                    "minItems": 16,
-                    "maxItems": 16,
-                    "default": [ 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 ],
-                    "gltf_detailedDescription": "A floating-point 4x4 transformation matrix stored in column-major order.",
-                    "gltf_webgl": "`uniformMatrix4fv()` with the transpose parameter equal to false"
-                },
-                "mesh": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the mesh in this node."
-                },
-                "rotation": {
-                    "type": "array",
-                    "description": "The node's unit quaternion rotation in the order (x, y, z, w), where w is the scalar.",
-                    "items": {
-                        "type": "number",
-                        "minimum": -1.0,
-                        "maximum": 1.0
-                    },
-                    "minItems": 4,
-                    "maxItems": 4,
-                    "default": [ 0.0, 0.0, 0.0, 1.0 ]
-                },
-                "scale": {
-                    "type": "array",
-                    "description": "The node's non-uniform scale, given as the scaling factors along the x, y, and z axes.",
-                    "items": {
-                        "type": "number"
-                    },
-                    "minItems": 3,
-                    "maxItems": 3,
-                    "default": [ 1.0, 1.0, 1.0 ]
-                },
-                "translation": {
-                    "type": "array",
-                    "description": "The node's translation along the x, y, and z axes.",
-                    "items": {
-                        "type": "number"
-                    },
-                    "minItems": 3,
-                    "maxItems": 3,
-                    "default": [ 0.0, 0.0, 0.0 ]
-                },
-                "weights": {
-                    "type": "array",
-                    "description": "The weights of the instantiated Morph Target. Number of elements must match number of Morph Targets of used mesh.",
-                    "minItems": 1,
-                    "items": {
-                        "type": "number"
-                    }
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "dependencies": {
-                "weights": [ "mesh" ],
-                "skin": [ "mesh" ]
-            },
-            "not": {
-                "anyOf": [
-                    { "required": [ "matrix", "translation" ] },
-                    { "required": [ "matrix", "rotation" ] },
-                    { "required": [ "matrix", "scale" ] }
-                ]
-            }
-        }
-        )rawstring";
-
-    const char* const SchemaJson::accessor_sparse_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Accessor Sparse",
-            "type": "object",
-            "description": "Sparse storage of attributes that deviate from their initialization value.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "count": {
-                    "type": "integer",
-                    "description": "Number of entries stored in the sparse array.",
-                    "minimum": 1,
-                    "gltf_detailedDescription": "The number of attributes encoded in this sparse accessor."
-                },
-                "indices": {
-                    "allOf": [ { "$ref": "accessor.sparse.indices.schema.json" } ],
-                    "description": "Index array of size `count` that points to those accessor attributes that deviate from their initialization value. Indices must strictly increase."
-                },
-                "values": {
-                    "allOf": [ { "$ref": "accessor.sparse.values.schema.json" } ],
-                    "description": "Array of size `count` times number of components, storing the displaced accessor attributes pointed by `indices`. Substituted values must have the same `componentType` and number of components as the base accessor."
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "count", "indices", "values" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::asset_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Asset",
-            "type": "object",
-            "description": "Metadata about the glTF asset.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "copyright": {
-                    "type": "string",
-                    "description": "A copyright message suitable for display to credit the content creator."
-                },
-                "generator": {
-                    "type": "string",
-                    "description": "Tool that generated this glTF model.  Useful for debugging."
-                },
-                "version": {
-                    "type": "string",
-                    "description": "The glTF version that this asset targets.",
-                    "pattern": "^[0-9]+\\.[0-9]+$"
-                },
-                "minVersion": {
-                    "type": "string",
-                    "description": "The minimum glTF version that this asset targets.",
-                    "pattern": "^[0-9]+\\.[0-9]+$"
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "version" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::animation_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Animation",
-            "type": "object",
-            "description": "A keyframe animation.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "channels": {
-                    "type": "array",
-                    "description": "An array of channels, each of which targets an animation's sampler at a node's property. Different channels of the same animation can't have equal targets.",
-                    "items": {
-                        "$ref": "animation.channel.schema.json"
-                    },
-                    "minItems": 1
-                },
-                "samplers": {
-                    "type": "array",
-                    "description": "An array of samplers that combines input and output accessors with an interpolation algorithm to define a keyframe graph (but not its target).",
-                    "items": {
-                        "$ref": "animation.sampler.schema.json"
-                    },
-                    "minItems": 1
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "channels", "samplers" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::camera_orthographic_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Camera Orthographic",
-            "type": "object",
-            "description": "An orthographic camera containing properties to create an orthographic projection matrix.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "xmag": {
-                    "type": "number",
-                    "description": "The floating-point horizontal magnification of the view. Must not be zero."
-                },
-                "ymag": {
-                    "type": "number",
-                    "description": "The floating-point vertical magnification of the view. Must not be zero."
-                },
-                "zfar": {
-                    "type": "number",
-                    "description": "The floating-point distance to the far clipping plane. `zfar` must be greater than `znear`.",
-                    "minimum": 0.0,
-                    "exclusiveMinimum": true
-                },
-                "znear": {
-                    "type": "number",
-                    "description": "The floating-point distance to the near clipping plane.",
-                    "minimum": 0.0
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "xmag", "ymag", "zfar", "znear" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::animation_channel_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Animation Channel",
-            "type": "object",
-            "description": "Targets an animation's sampler at a node's property.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "sampler": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of a sampler in this animation used to compute the value for the target.",
-                    "gltf_detailedDescription": "The index of a sampler in this animation used to compute the value for the target, e.g., a node's translation, rotation, or scale (TRS)."
-                },
-                "target": {
-                    "allOf": [ { "$ref": "animation.channel.target.schema.json" } ],
-                    "description": "The index of the node and TRS property to target."
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "sampler", "target" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::accessor_sparse_values_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Accessor Sparse Values",
-            "type": "object",
-            "description": "Array of size `accessor.sparse.count` times number of components storing the displaced accessor attributes pointed by `accessor.sparse.indices`.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "bufferView": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the bufferView with sparse values. Referenced bufferView can't have ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER target."
-                },
-                "byteOffset": {
-                    "type": "integer",
-                    "description": "The offset relative to the start of the bufferView in bytes. Must be aligned.",
-                    "minimum": 0,
-                    "default": 0
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "bufferView" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::accessor_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Accessor",
-            "type": "object",
-            "description": "A typed view into a bufferView.  A bufferView contains raw binary data.  An accessor provides a typed view into a bufferView or a subset of a bufferView similar to how WebGL's `vertexAttribPointer()` defines an attribute in a buffer.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "bufferView": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the bufferView.",
-                    "gltf_detailedDescription": "The index of the bufferView. When not defined, accessor must be initialized with zeros; `sparse` property or extensions could override zeros with actual values."
-                },
-                "byteOffset": {
-                    "type": "integer",
-                    "description": "The offset relative to the start of the bufferView in bytes.",
-                    "minimum": 0,
-                    "default": 0,
-                    "gltf_detailedDescription": "The offset relative to the start of the bufferView in bytes.  This must be a multiple of the size of the component datatype.",
-                    "gltf_webgl": "`vertexAttribPointer()` offset parameter"
-                },
-                "componentType": {
-                    "description": "The datatype of components in the attribute.",
-                    "gltf_detailedDescription": "The datatype of components in the attribute.  All valid values correspond to WebGL enums.  The corresponding typed arrays are `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Uint32Array`, and `Float32Array`, respectively.  5125 (UNSIGNED_INT) is only allowed when the accessor contains indices, i.e., the accessor is only referenced by `primitive.indices`.",
-                    "gltf_webgl": "`vertexAttribPointer()` type parameter",
-                    "anyOf": [
-                        {
-                            "enum": [ 5120 ],
-                            "description": "BYTE"
-                        },
-                        {
-                            "enum": [ 5121 ],
-                            "description": "UNSIGNED_BYTE"
-                        },
-                        {
-                            "enum": [ 5122 ],
-                            "description": "SHORT"
-                        },
-                        {
-                            "enum": [ 5123 ],
-                            "description": "UNSIGNED_SHORT"
-                        },
-                        {
-                            "enum": [ 5125 ],
-                            "description": "UNSIGNED_INT"
-                        },
-                        {
-                            "enum": [ 5126 ],
-                            "description": "FLOAT"
-                        },
-                        {
-                            "type": "integer"
-                        }
-                    ]
-                },
-                "normalized": {
-                    "type": "boolean",
-                    "description": "Specifies whether integer data values should be normalized.",
-                    "default": false,
-                    "gltf_detailedDescription": "Specifies whether integer data values should be normalized (`true`) to [0, 1] (for unsigned types) or [-1, 1] (for signed types), or converted directly (`false`) when they are accessed. This property is defined only for accessors that contain vertex attributes or animation output data.",
-                    "gltf_webgl": "`vertexAttribPointer()` normalized parameter"
-                },
-                "count": {
-                    "type": "integer",
-                    "description": "The number of attributes referenced by this accessor.",
-                    "minimum": 1,
-                    "gltf_detailedDescription": "The number of attributes referenced by this accessor, not to be confused with the number of bytes or number of components."
-                },
-                "type": {
-                    "description": "Specifies if the attribute is a scalar, vector, or matrix.",
-                    "anyOf": [
-                        {
-                            "enum": [ "SCALAR" ]
-                        },
-                        {
-                            "enum": [ "VEC2" ]
-                        },
-                        {
-                            "enum": [ "VEC3" ]
-                        },
-                        {
-                            "enum": [ "VEC4" ]
-                        },
-                        {
-                            "enum": [ "MAT2" ]
-                        },
-                        {
-                            "enum": [ "MAT3" ]
-                        },
-                        {
-                            "enum": [ "MAT4" ]
-                        },
-                        {
-                            "type": "string"
-                        }
-                    ]
-                },
-                "max": {
-                    "type": "array",
-                    "description": "Maximum value of each component in this attribute.",
-                    "items": {
-                        "type": "number"
-                    },
-                    "minItems": 1,
-                    "maxItems": 16,
-                    "gltf_detailedDescription": "Maximum value of each component in this attribute.  Array elements must be treated as having the same data type as accessor's `componentType`. Both min and max arrays have the same length.  The length is determined by the value of the type property; it can be 1, 2, 3, 4, 9, or 16.\n\n`normalized` property has no effect on array values: they always correspond to the actual values stored in the buffer. When accessor is sparse, this property must contain max values of accessor data with sparse substitution applied."
-                },
-                "min": {
-                    "type": "array",
-                    "description": "Minimum value of each component in this attribute.",
-                    "items": {
-                        "type": "number"
-                    },
-                    "minItems": 1,
-                    "maxItems": 16,
-                    "gltf_detailedDescription": "Minimum value of each component in this attribute.  Array elements must be treated as having the same data type as accessor's `componentType`. Both min and max arrays have the same length.  The length is determined by the value of the type property; it can be 1, 2, 3, 4, 9, or 16.\n\n`normalized` property has no effect on array values: they always correspond to the actual values stored in the buffer. When accessor is sparse, this property must contain min values of accessor data with sparse substitution applied."
-                },
-                "sparse": {
-                    "allOf": [ { "$ref": "accessor.sparse.schema.json" } ],
-                    "description": "Sparse storage of attributes that deviate from their initialization value."
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "dependencies": {
-                "byteOffset": [ "bufferView" ]
-            },
-            "required": [ "componentType", "count", "type" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::skin_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Skin",
-            "type": "object",
-            "description": "Joints and matrices defining a skin.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "inverseBindMatrices": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the accessor containing the floating-point 4x4 inverse-bind matrices.  The default is that each matrix is a 4x4 identity matrix, which implies that inverse-bind matrices were pre-applied."
-                },
-                "skeleton": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the node used as a skeleton root. When undefined, joints transforms resolve to scene root."
-                },
-                "joints": {
-                    "type": "array",
-                    "description": "Indices of skeleton nodes, used as joints in this skin.",
-                    "items": {
-                        "$ref": "glTFid.schema.json"
-                    },
-                    "uniqueItems": true,
-                    "minItems": 1,
-                    "gltf_detailedDescription": "Indices of skeleton nodes, used as joints in this skin.  The array length must be the same as the `count` property of the `inverseBindMatrices` accessor (when defined)."
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "joints" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::material_pbrMetallicRoughness_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Material PBR Metallic Roughness",
-            "type": "object",
-            "description": "A set of parameter values that are used to define the metallic-roughness material model from Physically-Based Rendering (PBR) methodology.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "baseColorFactor": {
-                    "type": "array",
-                    "items": {
-                        "type": "number",
-                        "minimum": 0.0,
-                        "maximum": 1.0
-                    },
-                    "description": "The material's base color factor.",
-                    "default": [ 1.0, 1.0, 1.0, 1.0 ],
-                    "minItems": 4,
-                    "maxItems": 4,
-                    "gltf_detailedDescription": "The RGBA components of the base color of the material. The fourth component (A) is the alpha coverage of the material. The `alphaMode` property specifies how alpha is interpreted. These values are linear. If a baseColorTexture is specified, this value is multiplied with the texel values."
-                },
-                "baseColorTexture": {
-                    "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-                    "description": "The base color texture.",
-                    "gltf_detailedDescription": "The base color texture. This texture contains RGB(A) components in sRGB color space. The first three components (RGB) specify the base color of the material. If the fourth component (A) is present, it represents the alpha coverage of the material. Otherwise, an alpha of 1.0 is assumed. The `alphaMode` property specifies how alpha is interpreted. The stored texels must not be premultiplied."
-                },
-                "metallicFactor": {
-                    "type": "number",
-                    "description": "The metalness of the material.",
-                    "default": 1.0,
-                    "minimum": 0.0,
-                    "maximum": 1.0,
-                    "gltf_detailedDescription": "The metalness of the material. A value of 1.0 means the material is a metal. A value of 0.0 means the material is a dielectric. Values in between are for blending between metals and dielectrics such as dirty metallic surfaces. This value is linear. If a metallicRoughnessTexture is specified, this value is multiplied with the metallic texel values."
-                },
-                "roughnessFactor": {
-                    "type": "number",
-                    "description": "The roughness of the material.",
-                    "default": 1.0,
-                    "minimum": 0.0,
-                    "maximum": 1.0,
-                    "gltf_detailedDescription": "The roughness of the material. A value of 1.0 means the material is completely rough. A value of 0.0 means the material is completely smooth. This value is linear. If a metallicRoughnessTexture is specified, this value is multiplied with the roughness texel values."
-                },
-                "metallicRoughnessTexture": {
-                    "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-                    "description": "The metallic-roughness texture.",
-                    "gltf_detailedDescription": "The metallic-roughness texture. The metalness values are sampled from the B channel. The roughness values are sampled from the G channel. These values are linear. If other channels are present (R or A), they are ignored for metallic-roughness calculations."
-                },
-                "extensions": { },
-                "extras": { }
-            }
-        })rawstring";
-
-    const char* const SchemaJson::scene_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Scene",
-            "type": "object",
-            "description": "The root nodes of a scene.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "nodes": {
-                    "type": "array",
-                    "description": "The indices of each root node.",
-                    "items": {
-                        "$ref": "glTFid.schema.json"
-                    },
-                    "uniqueItems": true,
-                    "minItems": 1
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            }
-        }
-        )rawstring";
-
-    const char* const SchemaJson::glTFProperty_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "glTF Property",
-            "type": "object",
-            "properties": {
-                "extensions": {
-                    "$ref": "extension.schema.json"
-                },
-                "extras": {
-                    "$ref": "extras.schema.json"
-                }
-            }
-        }
-        )rawstring";
-
-    const char* const SchemaJson::material_normalTextureInfo_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Material Normal Texture Info",
-            "type": "object",
-            "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-            "properties": {
-                "index": { },
-                "texCoord": { },
-                "scale": {
-                    "type": "number",
-                    "description": "The scalar multiplier applied to each normal vector of the normal texture.",
-                    "default": 1.0,
-                    "gltf_detailedDescription": "The scalar multiplier applied to each normal vector of the texture. This value scales the normal vector using the formula: `scaledNormal =  normalize((normalize(<sampled normal texture value>) * 2.0 - 1.0) * vec3(<normal scale>, <normal scale>, 1.0))`. This value is ignored if normalTexture is not specified. This value is linear."
-                },
-                "extensions": { },
-                "extras": { }
-            }
-        })rawstring";
-
-    const char* const SchemaJson::mesh_primitive_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Mesh Primitive",
-            "type": "object",
-            "description": "Geometry to be rendered with the given material.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "attributes": {
-                    "type": "object",
-                    "description": "A dictionary object, where each key corresponds to mesh attribute semantic and each value is the index of the accessor containing attribute's data.",
-                    "minProperties": 1,
-                    "additionalProperties": {
-                        "$ref": "glTFid.schema.json"
-                    }
-                },
-                "indices": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the accessor that contains the indices.",
-                    "gltf_detailedDescription": "The index of the accessor that contains mesh indices.  When this is not defined, the primitives should be rendered without indices using `drawArrays()`.  When defined, the accessor must contain indices: the `bufferView` referenced by the accessor should have a `target` equal to 34963 (ELEMENT_ARRAY_BUFFER); `componentType` must be 5121 (UNSIGNED_BYTE), 5123 (UNSIGNED_SHORT) or 5125 (UNSIGNED_INT), the latter may require enabling additional hardware support; `type` must be `\"SCALAR\"`. For triangle primitives, the front face has a counter-clockwise (CCW) winding order."
-                },
-                "material": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the material to apply to this primitive when rendering."
-                },
-                "mode": {
-                    "description": "The type of primitives to render.",
-                    "default": 4,
-                    "gltf_detailedDescription": "The type of primitives to render. All valid values correspond to WebGL enums.",
-                    "anyOf": [
-                        {
-                            "enum": [ 0 ],
-                            "description": "POINTS"
-                        },
-                        {
-                            "enum": [ 1 ],
-                            "description": "LINES"
-                        },
-                        {
-                            "enum": [ 2 ],
-                            "description": "LINE_LOOP"
-                        },
-                        {
-                            "enum": [ 3 ],
-                            "description": "LINE_STRIP"
-                        },
-                        {
-                            "enum": [ 4 ],
-                            "description": "TRIANGLES"
-                        },
-                        {
-                            "enum": [ 5 ],
-                            "description": "TRIANGLE_STRIP"
-                        },
-                        {
-                            "enum": [ 6 ],
-                            "description": "TRIANGLE_FAN"
-                        },
-                        {
-                            "type": "integer"
-                        }
-                    ]
-                },
-                "targets": {
-                    "type": "array",
-                    "description": "An array of Morph Targets, each  Morph Target is a dictionary mapping attributes (only `POSITION`, `NORMAL`, and `TANGENT` supported) to their deviations in the Morph Target.",
-                    "items": {
-                        "type": "object",
-                        "minProperties": 1,
-                        "additionalProperties": {
-                            "$ref": "glTFid.schema.json"
-                        },
-                        "description": "A dictionary object specifying attributes displacements in a Morph Target, where each key corresponds to one of the three supported attribute semantic (`POSITION`, `NORMAL`, or `TANGENT`) and each value is the index of the accessor containing the attribute displacements' data."
-                    },
-                    "minItems": 1
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "gltf_webgl": "`drawElements()` and `drawArrays()`",
-            "required": [ "attributes" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::mesh_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Mesh",
-            "type": "object",
-            "description": "A set of primitives to be rendered.  A node can contain one mesh.  A node's transform places the mesh in the scene.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "primitives": {
-                    "type": "array",
-                    "description": "An array of primitives, each defining geometry to be rendered with a material.",
-                    "items": {
-                        "$ref": "mesh.primitive.schema.json"
-                    },
-                    "minItems": 1
-                },
-                "weights": {
-                    "type": "array",
-                    "description": "Array of weights to be applied to the Morph Targets.",
-                    "items": {
-                        "type": "number"
-                    },
-                    "minItems": 1
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "primitives" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::camera_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Camera",
-            "type": "object",
-            "description": "A camera's projection.  A node can reference a camera to apply a transform to place the camera in the scene.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "orthographic": {
-                    "allOf": [ { "$ref": "camera.orthographic.schema.json" } ],
-                    "description": "An orthographic camera containing properties to create an orthographic projection matrix."
-                },
-                "perspective": {
-                    "allOf": [ { "$ref": "camera.perspective.schema.json" } ],
-                    "description": "A perspective camera containing properties to create a perspective projection matrix."
-                },
-                "type": {
-                    "description": "Specifies if the camera uses a perspective or orthographic projection.",
-                    "gltf_detailedDescription": "Specifies if the camera uses a perspective or orthographic projection.  Based on this, either the camera's `perspective` or `orthographic` property will be defined.",
-                    "anyOf": [
-                        {
-                            "enum": [ "perspective" ]
-                        },
-                        {
-                            "enum": [ "orthographic" ]
-                        },
-                        {
-                            "type": "string"
-                        }
-                    ]
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "type" ],
-            "not": {
-                "required": [ "perspective", "orthographic" ]
-            }
-        }
-        )rawstring";
-
-    const char* const SchemaJson::extras_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Extras",
-            "description": "Application-specific data."
-        }
-        )rawstring";
-
-    const char* const SchemaJson::accessor_sparse_indices_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Accessor Sparse Indices",
-            "type": "object",
-            "description": "Indices of those attributes that deviate from their initialization value.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "bufferView": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the bufferView with sparse indices. Referenced bufferView can't have ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER target."
-                },
-                "byteOffset": {
-                    "type": "integer",
-                    "description": "The offset relative to the start of the bufferView in bytes. Must be aligned.",
-                    "minimum": 0,
-                    "default": 0
-                },
-                "componentType": {
-                    "description": "The indices data type.",
-                    "gltf_detailedDescription": "The indices data type.  Valid values correspond to WebGL enums: `5121` (UNSIGNED_BYTE), `5123` (UNSIGNED_SHORT), `5125` (UNSIGNED_INT).",
-                    "anyOf": [
-                        {
-                            "enum": [ 5121 ],
-                            "description": "UNSIGNED_BYTE"
-                        },
-                        {
-                            "enum": [ 5123 ],
-                            "description": "UNSIGNED_SHORT"
-                        },
-                        {
-                            "enum": [ 5125 ],
-                            "description": "UNSIGNED_INT"
-                        },
-                        {
-                            "type": "integer"
-                        }
-                    ]
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "bufferView", "componentType" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::camera_perspective_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Camera Perspective",
-            "type": "object",
-            "description": "A perspective camera containing properties to create a perspective projection matrix.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "aspectRatio": {
-                    "type": "number",
-                    "description": "The floating-point aspect ratio of the field of view.",
-                    "minimum": 0.0,
-                    "exclusiveMinimum": true,
-                    "gltf_detailedDescription": "The floating-point aspect ratio of the field of view. When this is undefined, the aspect ratio of the canvas is used."
-                },
-                "yfov": {
-                    "type": "number",
-                    "description": "The floating-point vertical field of view in radians.",
-                    "minimum": 0.0,
-                    "exclusiveMinimum": true
-                },
-                "zfar": {
-                    "type": "number",
-                    "description": "The floating-point distance to the far clipping plane.",
-                    "minimum": 0.0,
-                    "exclusiveMinimum": true,
-                    "gltf_detailedDescription": "The floating-point distance to the far clipping plane. When defined, `zfar` must be greater than `znear`. If `zfar` is undefined, runtime must use infinite projection matrix."
-                },
-                "znear": {
-                    "type": "number",
-                    "description": "The floating-point distance to the near clipping plane.",
-                    "minimum": 0.0,
-                    "exclusiveMinimum": true,
-                    "gltf_detailedDescription": "The floating-point distance to the near clipping plane."
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "yfov", "znear" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::texture_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Texture",
-            "type": "object",
-            "description": "A texture and its sampler.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "sampler": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the sampler used by this texture. When undefined, a sampler with repeat wrapping and auto filtering should be used."
-                },
-                "source": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the image used by this texture."
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "gltf_webgl": "`createTexture()`, `deleteTexture()`, `bindTexture()`, `texImage2D()`, and `texParameterf()`"
-        }
-        )rawstring";
-
-    const char* const SchemaJson::textureInfo_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Texture Info",
-            "type": "object",
-            "description": "Reference to a texture.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "index": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the texture."
-                },
-                "texCoord": {
-                    "type": "integer",
-                    "description": "The set index of texture's TEXCOORD attribute used for texture coordinate mapping.",
-                    "default": 0,
-                    "minimum": 0,
-                    "gltf_detailedDescription": "This integer value is used to construct a string in the format `TEXCOORD_<set index>` which is a reference to a key in mesh.primitives.attributes (e.g. A value of `0` corresponds to `TEXCOORD_0`). Mesh must have corresponding texture coordinate attributes for the material to be applicable to it."
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "index" ]
-        })rawstring";
-
-    const char* const SchemaJson::material_occlusionTextureInfo_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Material Occlusion Texture Info",
-            "type": "object",
-            "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-            "properties": {
-                "index": { },
-                "texCoord": { },
-                "strength": {
-                    "type": "number",
-                    "description": "A scalar multiplier controlling the amount of occlusion applied.",
-                    "default": 1.0,
-                    "minimum": 0.0,
-                    "maximum": 1.0,
-                    "gltf_detailedDescription": "A scalar multiplier controlling the amount of occlusion applied. A value of 0.0 means no occlusion. A value of 1.0 means full occlusion. This value affects the resulting color using the formula: `occludedColor = lerp(color, color * <sampled occlusion texture value>, <occlusion strength>)`. This value is ignored if the corresponding texture is not specified. This value is linear."
-                },
-                "extensions": { },
-                "extras": { }
-            }
-        })rawstring";
-
-    const char* const SchemaJson::bufferView_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Buffer View",
-            "type": "object",
-            "description": "A view into a buffer generally representing a subset of the buffer.",
-            "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-            "properties": {
-                "buffer": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the buffer."
-                },
-                "byteOffset": {
-                    "type": "integer",
-                    "description": "The offset into the buffer in bytes.",
-                    "minimum": 0,
-                    "default": 0
-                },
-                "byteLength": {
-                    "type": "integer",
-                    "description": "The length of the bufferView in bytes.",
-                    "minimum": 1
-                },
-                "byteStride": {
-                    "type": "integer",
-                    "description": "The stride, in bytes.",
-                    "minimum": 4,
-                    "maximum": 252,
-                    "multipleOf": 4,
-                    "gltf_detailedDescription": "The stride, in bytes, between vertex attributes.  When this is not defined, data is tightly packed. When two or more accessors use the same bufferView, this field must be defined.",
-                    "gltf_webgl": "`vertexAttribPointer()` stride parameter"
-                },
-                "target": {
-                    "description": "The target that the GPU buffer should be bound to.",
-                    "gltf_webgl": "`bindBuffer()`",
-                    "anyOf": [
-                        {
-                            "enum": [ 34962 ],
-                            "description": "ARRAY_BUFFER"
-                        },
-                        {
-                            "enum": [ 34963 ],
-                            "description": "ELEMENT_ARRAY_BUFFER"
-                        },
-                        {
-                            "type": "integer"
-                        }
-                    ]
-                },
-                "name": { },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "buffer", "byteLength" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::animation_channel_target_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "Animation Channel Target",
-            "type": "object",
-            "description": "The index of the node and TRS property that an animation channel targets.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "node": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the node to target."
-                },
-                "path": {
-                    "description": "The name of the node's TRS property to modify, or the \"weights\" of the Morph Targets it instantiates. For the \"translation\" property, the values that are provided by the sampler are the translation along the x, y, and z axes. For the \"rotation\" property, the values are a quaternion in the order (x, y, z, w), where w is the scalar. For the \"scale\" property, the values are the scaling factors along the x, y, and z axes.",
-                    "anyOf": [
-                        {
-                            "enum": [ "translation" ]
-                        },
-                        {
-                            "enum": [ "rotation" ]
-                        },
-                        {
-                            "enum": [ "scale" ]
-                        },
-                        {
-                            "enum": [ "weights" ]
-                        },
-                        {
-                            "type": "string"
-                        }
-                    ]
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "required": [ "path" ]
-        }
-        )rawstring";
-
-    const char* const SchemaJson::glTFid_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "glTF Id",
-            "type": "integer",
-            "minimum": 0
-        }
-        )rawstring";
-
-    const char* const SchemaJson::glTF_schema_json = R"rawstring(
-        {
-            "$schema": "http://json-schema.org/draft-04/schema",
-            "title": "glTF",
-            "type": "object",
-            "description": "The root object for a glTF asset.",
-            "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-            "properties": {
-                "extensionsUsed": {
-                    "type": "array",
-                    "description": "Names of glTF extensions used somewhere in this asset.",
-                    "items": {
-                        "type": "string"
-                    },
-                    "uniqueItems": true,
-                    "minItems": 1
-                },
-                "extensionsRequired": {
-                    "type": "array",
-                    "description": "Names of glTF extensions required to properly load this asset.",
-                    "items": {
-                        "type": "string"
-                    },
-                    "uniqueItems": true,
-                    "minItems": 1
-                },
-                "accessors": {
-                    "type": "array",
-                    "description": "An array of accessors.",
-                    "items": {
-                        "$ref": "accessor.schema.json"
-                    },
-                    "minItems": 1,
-                    "gltf_detailedDescription": "An array of accessors.  An accessor is a typed view into a bufferView."
-                },
-                "animations": {
-                    "type": "array",
-                    "description": "An array of keyframe animations.",
-                    "items": {
-                        "$ref": "animation.schema.json"
-                    },
-                    "minItems": 1
-                },
-                "asset": {
-                    "allOf": [ { "$ref": "asset.schema.json" } ],
-                    "description": "Metadata about the glTF asset."
-                },
-                "buffers": {
-                    "type": "array",
-                    "description": "An array of buffers.",
-                    "items": {
-                        "$ref": "buffer.schema.json"
-                    },
-                    "minItems": 1,
-                    "gltf_detailedDescription": "An array of buffers.  A buffer points to binary geometry, animation, or skins."
-                },
-                "bufferViews": {
-                    "type": "array",
-                    "description": "An array of bufferViews.",
-                    "items": {
-                        "$ref": "bufferView.schema.json"
-                    },
-                    "minItems": 1,
-                    "gltf_detailedDescription": "An array of bufferViews.  A bufferView is a view into a buffer generally representing a subset of the buffer."
-                },
-                "cameras": {
-                    "type": "array",
-                    "description": "An array of cameras.",
-                    "items": {
-                        "$ref": "camera.schema.json"
-                    },
-                    "minItems": 1,
-                    "gltf_detailedDescription": "An array of cameras.  A camera defines a projection matrix."
-                },
-                "images": {
-                    "type": "array",
-                    "description": "An array of images.",
-                    "items": {
-                        "$ref": "image.schema.json"
-                    },
-                    "minItems": 1,
-                    "gltf_detailedDescription": "An array of images.  An image defines data used to create a texture."
-                },
-                "materials": {
-                    "type": "array",
-                    "description": "An array of materials.",
-                    "items": {
-                        "$ref": "material.schema.json"
-                    },
-                    "minItems": 1,
-                    "gltf_detailedDescription": "An array of materials.  A material defines the appearance of a primitive."
-                },
-                "meshes": {
-                    "type": "array",
-                    "description": "An array of meshes.",
-                    "items": {
-                        "$ref": "mesh.schema.json"
-                    },
-                    "minItems": 1,
-                    "gltf_detailedDescription": "An array of meshes.  A mesh is a set of primitives to be rendered."
-                },
-                "nodes": {
-                    "type": "array",
-                    "description": "An array of nodes.",
-                    "items": {
-                        "$ref": "node.schema.json"
-                    },
-                    "minItems": 1
-                },
-                "samplers": {
-                    "type": "array",
-                    "description": "An array of samplers.",
-                    "items": {
-                        "$ref": "sampler.schema.json"
-                    },
-                    "minItems": 1,
-                    "gltf_detailedDescription": "An array of samplers.  A sampler contains properties for texture filtering and wrapping modes."
-                },
-                "scene": {
-                    "allOf": [ { "$ref": "glTFid.schema.json" } ],
-                    "description": "The index of the default scene."
-                },
-                "scenes": {
-                    "type": "array",
-                    "description": "An array of scenes.",
-                    "items": {
-                        "$ref": "scene.schema.json"
-                    },
-                    "minItems": 1
-                },
-                "skins": {
-                    "type": "array",
-                    "description": "An array of skins.",
-                    "items": {
-                        "$ref": "skin.schema.json"
-                    },
-                    "minItems": 1,
-                    "gltf_detailedDescription": "An array of skins.  A skin is defined by joints and matrices."
-                },
-                "textures": {
-                    "type": "array",
-                    "description": "An array of textures.",
-                    "items": {
-                        "$ref": "texture.schema.json"
-                    },
-                    "minItems": 1
-                },
-                "extensions": { },
-                "extras": { }
-            },
-            "dependencies": {
-                "scene": [ "scenes" ]
-            },
-            "required": [ "asset" ]
-        }
-        )rawstring";
-
-    const std::unordered_map<std::string, std::string> SchemaJson::GLTF_SCHEMA_MAP =
-    {
-        { "material.schema.json", material_schema_json },
-        { "glTFChildOfRootProperty.schema.json", glTFChildOfRootProperty_schema_json },
-        { "image.schema.json", image_schema_json },
-        { "animation.sampler.schema.json", animation_sampler_schema_json },
-        { "sampler.schema.json", sampler_schema_json },
-        { "extension.schema.json", extension_schema_json },
-        { "buffer.schema.json", buffer_schema_json },
-        { "node.schema.json", node_schema_json },
-        { "accessor.sparse.schema.json", accessor_sparse_schema_json },
-        { "asset.schema.json", asset_schema_json },
-        { "animation.schema.json", animation_schema_json },
-        { "camera.orthographic.schema.json", camera_orthographic_schema_json },
-        { "animation.channel.schema.json", animation_channel_schema_json },
-        { "accessor.sparse.values.schema.json", accessor_sparse_values_schema_json },
-        { "accessor.schema.json", accessor_schema_json },
-        { "skin.schema.json", skin_schema_json },
-        { "material.pbrMetallicRoughness.schema.json", material_pbrMetallicRoughness_schema_json },
-        { "scene.schema.json", scene_schema_json },
-        { "glTFProperty.schema.json", glTFProperty_schema_json },
-        { "material.normalTextureInfo.schema.json", material_normalTextureInfo_schema_json },
-        { "mesh.primitive.schema.json", mesh_primitive_schema_json },
-        { "mesh.schema.json", mesh_schema_json },
-        { "camera.schema.json", camera_schema_json },
-        { "extras.schema.json", extras_schema_json },
-        { "accessor.sparse.indices.schema.json", accessor_sparse_indices_schema_json },
-        { "camera.perspective.schema.json", camera_perspective_schema_json },
-        { "texture.schema.json", texture_schema_json },
-        { "textureInfo.schema.json", textureInfo_schema_json },
-        { "material.occlusionTextureInfo.schema.json", material_occlusionTextureInfo_schema_json },
-        { "bufferView.schema.json", bufferView_schema_json },
-        { "animation.channel.target.schema.json", animation_channel_target_schema_json },
-        { "glTFid.schema.json", glTFid_schema_json },
-        { "glTF.schema.json", glTF_schema_json } };
-    
-
-  }; // end namespace glTF scope
-
-}; // end namespace Microsoft scope
-
diff --git a/thirdparty/GLTFSDK/Source/AnimationUtils.cpp b/thirdparty/GLTFSDK/Source/AnimationUtils.cpp
deleted file mode 100644
index 6e0305b..0000000
--- a/thirdparty/GLTFSDK/Source/AnimationUtils.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/AnimationUtils.h>
-
-#include <GLTFSDK/GLTF.h>
-#include <GLTFSDK/GLTFResourceReader.h>
-
-using namespace Microsoft::glTF;
-
-std::vector<float> AnimationUtils::GetKeyframeTimes(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-{
-    if (accessor.type != TYPE_SCALAR)
-    {
-        throw GLTFException("Invalid type for animation input accessor " + accessor.id);
-    }
-
-    if (accessor.componentType != COMPONENT_FLOAT)
-    {
-        throw GLTFException("Invalid componentType for animation input accessor " + accessor.id);
-    }
-
-    return reader.ReadBinaryData<float>(doc, accessor);
-}
-
-std::vector<float> AnimationUtils::GetKeyframeTimes(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& sampler)
-{
-    auto& accessor = doc.accessors[sampler.inputAccessorId];
-    return GetKeyframeTimes(doc, reader, accessor);
-}
-
-std::vector<float> AnimationUtils::GetInverseBindMatrices(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-{
-    if (accessor.type != TYPE_MAT4)
-    {
-        throw GLTFException("Invalid type for inverse bind matrices accessor " + accessor.id);
-    }
-
-    if (accessor.componentType != COMPONENT_FLOAT)
-    {
-        throw GLTFException("Invalid componentType for inverse bind matrices accessor " + accessor.id);
-    }
-
-    return reader.ReadBinaryData<float>(doc, accessor);
-}
-
-std::vector<float> AnimationUtils::GetInverseBindMatrices(const Document& doc, const GLTFResourceReader& reader, const Skin& skin)
-{
-    auto& accessor = doc.accessors[skin.inverseBindMatricesAccessorId];
-    return GetInverseBindMatrices(doc, reader, accessor);
-}
-
-std::vector<float> AnimationUtils::GetTranslations(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-{
-    if (accessor.type != TYPE_VEC3)
-    {
-        throw GLTFException("Invalid type for translations accessor " + accessor.id);
-    }
-
-    if (accessor.componentType != COMPONENT_FLOAT)
-    {
-        throw GLTFException("Invalid componentType for translations accessor " + accessor.id);
-    }
-
-    return reader.ReadBinaryData<float>(doc, accessor);
-}
-
-std::vector<float> AnimationUtils::GetTranslations(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& sampler)
-{
-    auto& accessor = doc.accessors[sampler.outputAccessorId];
-    return GetTranslations(doc, reader, accessor);
-}
-
-std::vector<float> AnimationUtils::GetRotations(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-{
-    if (accessor.type != TYPE_VEC4)
-    {
-        throw GLTFException("Invalid type for rotations accessor " + accessor.id);
-    }
-
-    return reader.ReadFloatData(doc, accessor);
-}
-
-std::vector<float> AnimationUtils::GetRotations(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& sampler)
-{
-    auto& accessor = doc.accessors[sampler.outputAccessorId];
-    return GetRotations(doc, reader, accessor);
-}
-
-std::vector<float> AnimationUtils::GetScales(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-{
-    if (accessor.type != TYPE_VEC3)
-    {
-        throw GLTFException("Invalid type for scales accessor " + accessor.id);
-    }
-
-    if (accessor.componentType != COMPONENT_FLOAT)
-    {
-        throw GLTFException("Invalid componentType for scales accessor " + accessor.id);
-    }
-
-    return reader.ReadBinaryData<float>(doc, accessor);
-}
-
-std::vector<float> AnimationUtils::GetScales(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& sampler)
-{
-    auto& accessor = doc.accessors[sampler.outputAccessorId];
-    return GetScales(doc, reader, accessor);
-}
-
-std::vector<float> AnimationUtils::GetMorphWeights(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-{
-    if (accessor.type != TYPE_SCALAR)
-    {
-        throw GLTFException("Invalid type for weights accessor " + accessor.id);
-    }
-
-    return reader.ReadFloatData(doc, accessor);
-}
-
-std::vector<float> AnimationUtils::GetMorphWeights(const Document& doc, const GLTFResourceReader& reader, const AnimationSampler& sampler)
-{
-    auto& accessor = doc.accessors[sampler.outputAccessorId];
-    return GetMorphWeights(doc, reader, accessor);
-}
diff --git a/thirdparty/GLTFSDK/Source/BufferBuilder.cpp b/thirdparty/GLTFSDK/Source/BufferBuilder.cpp
deleted file mode 100644
index 98a6ba1..0000000
--- a/thirdparty/GLTFSDK/Source/BufferBuilder.cpp
+++ /dev/null
@@ -1,320 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/BufferBuilder.h>
-
-#include <GLTFSDK/ResourceWriter.h>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    size_t GetPadding(size_t offset, size_t alignment)
-    {
-        const auto padAlign = offset % alignment;
-        const auto pad = padAlign ? alignment - padAlign : 0U;
-
-        return pad;
-    }
-
-    size_t GetPadding(size_t offset, ComponentType componentType)
-    {
-        return GetPadding(offset, Accessor::GetComponentTypeSize(componentType));
-    }
-
-    size_t GetAlignment(const AccessorDesc& desc)
-    {
-        return Accessor::GetComponentTypeSize(desc.componentType);
-    }
-}
-
-BufferBuilder::BufferBuilder(std::unique_ptr<ResourceWriter>&& resourceWriter) : BufferBuilder(std::move(resourceWriter), {}, {}, {})
-{
-}
-
-BufferBuilder::BufferBuilder(std::unique_ptr<ResourceWriter>&& resourceWriter,
-    FnGenId fnGenBufferId,
-    FnGenId fnGenBufferViewId,
-    FnGenId fnGenAccessorId) : m_resourceWriter(std::move(resourceWriter)),
-    m_fnGenBufferId(std::move(fnGenBufferId)),
-    m_fnGenBufferViewId(std::move(fnGenBufferViewId)),
-    m_fnGenAccessorId(std::move(fnGenAccessorId))
-{
-}
-
-const Buffer& BufferBuilder::AddBuffer(const char* bufferId)
-{
-    Buffer buffer;
-
-    if (bufferId)
-    {
-        buffer.id = bufferId;
-    }
-    else if (m_fnGenBufferId)
-    {
-        buffer.id = m_fnGenBufferId(*this);
-    }
-
-    buffer.byteLength = 0U;// The buffer's length is updated whenever an Accessor or BufferView is added (and data is written to the underlying buffer)
-    auto& bufferRef = m_buffers.Append(std::move(buffer), AppendIdPolicy::GenerateOnEmpty);
-    bufferRef.uri = m_resourceWriter->GenerateBufferUri(bufferRef.id);
-
-    return bufferRef;
-}
-
-const BufferView& BufferBuilder::AddBufferView(Optional<BufferViewTarget> target)
-{
-    Buffer& buffer = m_buffers.Back();
-    BufferView bufferView;
-
-    if (m_fnGenBufferViewId)
-    {
-        bufferView.id = m_fnGenBufferViewId(*this);
-    }
-
-    bufferView.bufferId = buffer.id;
-    bufferView.byteOffset = buffer.byteLength;
-    bufferView.byteLength = 0U;// The BufferView's length is updated whenever an Accessor is added (and data is written to the underlying buffer)
-    bufferView.target = target;
-
-    return m_bufferViews.Append(std::move(bufferView), AppendIdPolicy::GenerateOnEmpty);
-}
-
-const BufferView& BufferBuilder::AddBufferView(const void* data, size_t byteLength, Optional<size_t> byteStride, Optional<BufferViewTarget> target)
-{
-    Buffer& buffer = m_buffers.Back();
-    BufferView bufferView;
-
-    if (m_fnGenBufferViewId)
-    {
-        bufferView.id = m_fnGenBufferViewId(*this);
-    }
-
-    bufferView.bufferId = buffer.id;
-    bufferView.byteOffset = buffer.byteLength;
-    bufferView.byteLength = byteLength;
-    bufferView.byteStride = byteStride;
-    bufferView.target = target;
-
-    buffer.byteLength = bufferView.byteOffset + bufferView.byteLength;
-
-    if (m_resourceWriter)
-    {
-        m_resourceWriter->Write(bufferView, data);
-    }
-
-    return m_bufferViews.Append(std::move(bufferView), AppendIdPolicy::GenerateOnEmpty);
-}
-
-const Accessor& BufferBuilder::AddAccessor(const void* data, size_t count, AccessorDesc desc)
-{
-    Buffer& buffer = m_buffers.Back();
-    BufferView& bufferView = m_bufferViews.Back();
-
-    // If the bufferView has not yet been written to then ensure it is correctly aligned for this accessor's component type
-    if (bufferView.byteLength == 0U)
-    {
-        bufferView.byteOffset += ::GetPadding(bufferView.byteOffset, desc.componentType);
-    }
-
-    desc.byteOffset = bufferView.byteLength;
-    const Accessor& accessor = AddAccessor(count, std::move(desc));
-
-    bufferView.byteLength += accessor.GetByteLength();
-    buffer.byteLength = bufferView.byteOffset + bufferView.byteLength;
-
-    if (m_resourceWriter)
-    {
-        m_resourceWriter->Write(bufferView, data, accessor);
-    }
-
-    return accessor;
-}
-
-void BufferBuilder::AddAccessors(const void* data, size_t count, size_t byteStride, const AccessorDesc* pDescs, size_t descCount, std::string* pOutIds)
-{
-    Buffer& buffer = m_buffers.Back();
-    BufferView& bufferView = m_bufferViews.Back();
-
-    if (count == 0 || pDescs == nullptr || descCount == 0)
-    {
-        throw InvalidGLTFException("invalid parameters specified");
-    }
-
-    for (size_t i = 0; i < descCount; ++i)
-    {
-        if (!pDescs[i].IsValid())
-        {
-            throw InvalidGLTFException("invalid AccessorDesc specified in pDescs");
-        }
-    }
-
-    if (bufferView.byteLength != 0U)
-    {
-        throw InvalidGLTFException("current buffer view already has written data - this interface doesn't support appending to an existing buffer view");
-    }
-
-    size_t extent;
-
-    if (byteStride == 0)
-    {
-        if (descCount > 1)
-        {
-            throw InvalidGLTFException("glTF 2.0 specification denotes that byte stride must be >= 4 when a buffer view is accessed by more than one accessor");
-        }
-
-        extent = count * Accessor::GetComponentTypeSize(pDescs[0].componentType) * Accessor::GetTypeCount(pDescs[0].accessorType);
-    }
-    else
-    {
-        extent = count * byteStride;
-
-        // Ensure all accessors fit within the buffer view's extent.
-        const size_t lastElement = (count - 1) * (bufferView.byteStride ? bufferView.byteStride.Get() : 0U);
-
-        for (size_t i = 0; i < descCount; ++i)
-        {
-            const size_t accessorSize = Accessor::GetTypeCount(pDescs[i].accessorType) * Accessor::GetComponentTypeSize(pDescs[i].componentType);
-            const size_t accessorEnd = lastElement + pDescs[i].byteOffset + accessorSize;
-
-            if (extent < accessorEnd)
-            {
-                throw InvalidGLTFException("specified accessor does not fit within the currently defined buffer view");
-            }
-        }
-    }
-
-    // Calculate the max alignment.
-    size_t alignment = 1;
-    for (size_t i = 0; i < descCount; ++i)
-    {
-        alignment = std::max(alignment, GetAlignment(pDescs[i]));
-    }
-
-    bufferView.byteStride = byteStride;
-    bufferView.byteLength = extent;
-    bufferView.byteOffset += ::GetPadding(bufferView.byteOffset, alignment);
-
-    buffer.byteLength = bufferView.byteOffset + bufferView.byteLength;
-
-    for (size_t i = 0; i < descCount; ++i)
-    {
-        AddAccessor(count, pDescs[i]);
-
-        if (pOutIds != nullptr)
-        {
-            pOutIds[i] = GetCurrentAccessor().id;
-        }
-    }
-
-    if (m_resourceWriter)
-    {
-        m_resourceWriter->Write(bufferView, data);
-    }
-}
-
-const Buffer& BufferBuilder::GetCurrentBuffer() const
-{
-    return m_buffers.Back();
-}
-
-const BufferView& BufferBuilder::GetCurrentBufferView() const
-{
-    return m_bufferViews.Back();
-}
-
-const Accessor& BufferBuilder::GetCurrentAccessor() const
-{
-    return m_accessors.Back();
-}
-
-size_t BufferBuilder::GetBufferCount() const
-{
-    return m_buffers.Size();
-}
-
-size_t BufferBuilder::GetBufferViewCount() const
-{
-    return m_bufferViews.Size();
-}
-
-size_t BufferBuilder::GetAccessorCount() const
-{
-    return m_accessors.Size();
-}
-
-ResourceWriter& BufferBuilder::GetResourceWriter()
-{
-    return *m_resourceWriter;
-}
-
-const ResourceWriter& BufferBuilder::GetResourceWriter() const
-{
-    return *m_resourceWriter;
-}
-
-const Accessor& BufferBuilder::AddAccessor(size_t count, AccessorDesc desc)
-{
-    Buffer& buffer = m_buffers.Back();
-    BufferView& bufferView = m_bufferViews.Back();
-
-    if (buffer.id != bufferView.bufferId)
-    {
-        throw InvalidGLTFException("bufferView.bufferId does not match buffer.id");
-    }
-
-    if (count == 0)
-    {
-        throw GLTFException("Invalid accessor count: 0");
-    }
-
-    if (desc.accessorType == TYPE_UNKNOWN)
-    {
-        throw GLTFException("Invalid accessorType: TYPE_UNKNOWN");
-    }
-
-    if (desc.componentType == COMPONENT_UNKNOWN)
-    {
-        throw GLTFException("Invalid componentType: COMPONENT_UNKNOWN");
-    }
-
-    const auto accessorTypeSize = Accessor::GetTypeCount(desc.accessorType);
-    size_t componentTypeSize = Accessor::GetComponentTypeSize(desc.componentType);
-
-    // Only check for a valid number of min and max values if they exist
-    if ((!desc.minValues.empty() || !desc.maxValues.empty()) &&
-        ((desc.minValues.size() != accessorTypeSize) || (desc.maxValues.size() != accessorTypeSize)))
-    {
-        throw InvalidGLTFException("the number of min and max values must be equal to the number of elements to be stored in the accessor");
-    }
-
-    if (desc.byteOffset % componentTypeSize != 0)
-    {
-        throw InvalidGLTFException("asccessor offset within buffer view must be a multiple of the component size");
-    }
-
-    if ((desc.byteOffset + bufferView.byteOffset) % componentTypeSize != 0)
-    {
-        throw InvalidGLTFException("accessor offset within buffer must be a multiple of the component size");
-    }
-
-    Accessor accessor;
-
-    if (m_fnGenAccessorId)
-    {
-        accessor.id = m_fnGenAccessorId(*this);
-    }
-
-    accessor.bufferViewId = bufferView.id;
-    accessor.count = count;
-    accessor.byteOffset = desc.byteOffset;
-    accessor.type = desc.accessorType;
-    accessor.componentType = desc.componentType;
-    accessor.normalized = desc.normalized;
-
-    // TODO: make accessor min & max members be vectors of doubles
-    accessor.min = desc.minValues;
-    accessor.max = desc.maxValues;
-
-    return m_accessors.Append(std::move(accessor), AppendIdPolicy::GenerateOnEmpty);
-}
diff --git a/thirdparty/GLTFSDK/Source/Color.cpp b/thirdparty/GLTFSDK/Source/Color.cpp
deleted file mode 100644
index 6a878da..0000000
--- a/thirdparty/GLTFSDK/Source/Color.cpp
+++ /dev/null
@@ -1,347 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/Color.h>
-
-#include <GLTFSDK/Math.h>
-#include <limits>
-
-using namespace Microsoft::glTF;
-
-Color3::Color3(float r, float g, float b) :
-    r(r),
-    g(g),
-    b(b)
-{
-}
-
-Color3::Color3(uint8_t r, uint8_t g, uint8_t b) :
-    r(Math::ByteToFloat(r)),
-    g(Math::ByteToFloat(g)),
-    b(Math::ByteToFloat(b))
-{
-}
-
-Color3 Color3::FromScalar(float value)
-{
-    return { value, value, value };
-}
-
-Color3& Color3::operator*=(const Color3& rhs)
-{
-    r *= rhs.r;
-    g *= rhs.g;
-    b *= rhs.b;
-
-    return *this;
-}
-
-Color3& Color3::operator*=(float rhs)
-{
-    r *= rhs;
-    g *= rhs;
-    b *= rhs;
-
-    return *this;
-}
-
-Color3& Color3::operator/=(const Color3& rhs)
-{
-    r /= rhs.r;
-    g /= rhs.g;
-    b /= rhs.b;
-
-    return *this;
-}
-
-Color3& Color3::operator/=(float rhs)
-{
-    r /= rhs;
-    g /= rhs;
-    b /= rhs;
-
-    return *this;
-}
-
-Color3& Color3::operator+=(const Color3& rhs)
-{
-    r += rhs.r;
-    g += rhs.g;
-    b += rhs.b;
-
-    return *this;
-}
-
-Color3& Color3::operator+=(float rhs)
-{
-    r += rhs;
-    g += rhs;
-    b += rhs;
-
-    return *this;
-}
-
-Color3& Color3::operator-=(const Color3& rhs)
-{
-    r -= rhs.r;
-    g -= rhs.g;
-    b -= rhs.b;
-
-    return *this;
-}
-
-Color3& Color3::operator-=(float rhs)
-{
-    r -= rhs;
-    g -= rhs;
-    b -= rhs;
-
-    return *this;
-}
-
-Color3 Color3::ToGamma() const
-{
-    return Color3(Math::ToGamma(r), Math::ToGamma(g), Math::ToGamma(b));
-}
-
-Color3 Color3::ToLinear() const
-{
-    return Color3(Math::ToLinear(r), Math::ToLinear(g), Math::ToLinear(b));
-}
-
-Color4 Color3::AsColor4(float a) const
-{
-    return { r, g, b, a };
-}
-
-uint32_t Color3::AsUint32RGBA() const
-{
-    const uint8_t rByte = Math::FloatToByte(r);
-    const uint8_t gByte = Math::FloatToByte(g);
-    const uint8_t bByte = Math::FloatToByte(b);
-    const uint8_t aByte = std::numeric_limits<uint8_t>::max();
-
-    const uint32_t rgba = aByte << 24 | bByte << 16 | gByte << 8 | rByte;
-    return rgba;
-}
-
-uint32_t Color3::AsUint32BGRA() const
-{
-    const uint8_t bByte = Math::FloatToByte(b);
-    const uint8_t gByte = Math::FloatToByte(g);
-    const uint8_t rByte = Math::FloatToByte(r);
-    const uint8_t aByte = std::numeric_limits<uint8_t>::max();
-
-    const uint32_t bgra = aByte << 24 | rByte << 16 | gByte << 8 | bByte;
-    return bgra;
-}
-
-Color3 Color3::FromUint32RGBA(uint32_t color)
-{
-    const uint8_t r = static_cast<uint8_t>( color & 0x000000ff);
-    const uint8_t g = static_cast<uint8_t>((color & 0x0000ff00) >> 8);
-    const uint8_t b = static_cast<uint8_t>((color & 0x00ff0000) >> 16);
-
-    return Color3(r, g, b);
-}
-
-Color3 Color3::FromUint32BGRA(uint32_t color)
-{
-    const uint8_t b = static_cast<uint8_t>( color & 0x000000ff);
-    const uint8_t g = static_cast<uint8_t>((color & 0x0000ff00) >> 8);
-    const uint8_t r = static_cast<uint8_t>((color & 0x00ff0000) >> 16);
-
-    return Color3(r, g, b);
-}
-
-Color3 Color3::Clamp(const Color3& color, float lo, float hi)
-{
-    return {
-        Math::Clamp(color.r, lo, hi),
-        Math::Clamp(color.g, lo, hi),
-        Math::Clamp(color.b, lo, hi)
-    };
-}
-
-bool Microsoft::glTF::operator==(const Color3& lhs, const Color3& rhs)
-{
-    return lhs.r == rhs.r
-        && lhs.g == rhs.g
-        && lhs.b == rhs.b;
-}
-
-bool Microsoft::glTF::operator!=(const Color3& lhs, const Color3& rhs)
-{
-    return !(lhs == rhs);
-}
-
-Color4::Color4(float r, float g, float b, float a) :
-    r(r),
-    g(g),
-    b(b),
-    a(a)
-{
-}
-
-Color4::Color4(uint8_t r, uint8_t g, uint8_t b, uint8_t a) :
-    r(Math::ByteToFloat(r)),
-    g(Math::ByteToFloat(g)),
-    b(Math::ByteToFloat(b)),
-    a(Math::ByteToFloat(a))
-{
-}
-
-Color4 Color4::FromScalar(float value)
-{
-    return { value, value, value, value };
-}
-
-Color4& Color4::operator*=(const Color4& rhs)
-{
-    r *= rhs.r;
-    g *= rhs.g;
-    b *= rhs.b;
-    a *= rhs.a;
-
-    return *this;
-}
-
-Color4& Color4::operator*=(float rhs)
-{
-    r *= rhs;
-    g *= rhs;
-    b *= rhs;
-    a *= rhs;
-
-    return *this;
-}
-
-Color4& Color4::operator/=(const Color4& rhs)
-{
-    r /= rhs.r;
-    g /= rhs.g;
-    b /= rhs.b;
-    a /= rhs.a;
-
-    return *this;
-}
-
-Color4& Color4::operator/=(float rhs)
-{
-    r /= rhs;
-    g /= rhs;
-    b /= rhs;
-    a /= rhs;
-
-    return *this;
-}
-
-Color4& Color4::operator+=(const Color4& rhs)
-{
-    r += rhs.r;
-    g += rhs.g;
-    b += rhs.b;
-    a += rhs.a;
-
-    return *this;
-}
-
-Color4& Color4::operator+=(float rhs)
-{
-    r += rhs;
-    g += rhs;
-    b += rhs;
-    a += rhs;
-
-    return *this;
-}
-
-Color4& Color4::operator-=(const Color4& rhs)
-{
-    r -= rhs.r;
-    g -= rhs.g;
-    b -= rhs.b;
-    a -= rhs.a;
-
-    return *this;
-}
-
-Color4& Color4::operator-=(float rhs)
-{
-    r -= rhs;
-    g -= rhs;
-    b -= rhs;
-    a -= rhs;
-
-    return *this;
-}
-
-Color3 Color4::AsColor3() const
-{
-    return { r, g, b };
-}
-
-uint32_t Color4::AsUint32RGBA() const
-{
-    const uint8_t rByte = Math::FloatToByte(r);
-    const uint8_t gByte = Math::FloatToByte(g);
-    const uint8_t bByte = Math::FloatToByte(b);
-    const uint8_t aByte = Math::FloatToByte(a);
-
-    const uint32_t rgba = aByte << 24 | bByte << 16 | gByte << 8 | rByte;
-    return rgba;
-}
-
-uint32_t Color4::AsUint32BGRA() const
-{
-    const uint8_t bByte = Math::FloatToByte(b);
-    const uint8_t gByte = Math::FloatToByte(g);
-    const uint8_t rByte = Math::FloatToByte(r);
-    const uint8_t aByte = Math::FloatToByte(a);
-
-    const uint32_t bgra = aByte << 24 | rByte << 16 | gByte << 8 | bByte;
-    return bgra;
-}
-
-Color4 Color4::FromUint32RGBA(uint32_t color)
-{
-    const uint8_t r = static_cast<uint8_t>( color & 0x000000ff);
-    const uint8_t g = static_cast<uint8_t>((color & 0x0000ff00) >> 8);
-    const uint8_t b = static_cast<uint8_t>((color & 0x00ff0000) >> 16);
-    const uint8_t a = static_cast<uint8_t>((color & 0xff000000) >> 24);
-
-    return Color4(r, g, b, a);
-}
-
-Color4 Color4::FromUint32BGRA(uint32_t color)
-{
-    const uint8_t b = static_cast<uint8_t>( color & 0x000000ff);
-    const uint8_t g = static_cast<uint8_t>((color & 0x0000ff00) >> 8);
-    const uint8_t r = static_cast<uint8_t>((color & 0x00ff0000) >> 16);
-    const uint8_t a = static_cast<uint8_t>((color & 0xff000000) >> 24);
-
-    return Color4(r, g, b, a);
-}
-
-Color4 Color4::Clamp(const Color4& color, float lo, float hi)
-{
-    return {
-        Math::Clamp(color.r, lo, hi),
-        Math::Clamp(color.g, lo, hi),
-        Math::Clamp(color.b, lo, hi),
-        Math::Clamp(color.a, lo, hi)
-    };
-}
-
-bool Microsoft::glTF::operator==(const Color4& lhs, const Color4& rhs)
-{
-    return lhs.r == rhs.r
-        && lhs.g == rhs.g
-        && lhs.b == rhs.b
-        && lhs.a == rhs.a;
-}
-
-bool Microsoft::glTF::operator!=(const Color4& lhs, const Color4& rhs)
-{
-    return !(lhs == rhs);
-}
diff --git a/thirdparty/GLTFSDK/Source/Deserialize.cpp b/thirdparty/GLTFSDK/Source/Deserialize.cpp
deleted file mode 100644
index 10c281b..0000000
--- a/thirdparty/GLTFSDK/Source/Deserialize.cpp
+++ /dev/null
@@ -1,893 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/Deserialize.h>
-
-#include <GLTFSDK/Constants.h>
-#include <GLTFSDK/ExtensionHandlers.h>
-#include <GLTFSDK/GLTF.h>
-#include <GLTFSDK/RapidJsonUtils.h>
-#include <GLTFSDK/Serialize.h>
-#include <GLTFSDK/SchemaValidation.h>
-
-#include <iostream>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    void ParseExtensions(const rapidjson::Value& v, glTFProperty& node, const ExtensionDeserializer& extensionDeserializer)
-    {
-        const auto& extensionsIt = v.FindMember("extensions");
-        if (extensionsIt != v.MemberEnd())
-        {
-            const rapidjson::Value& extensionsObject = extensionsIt->value;
-            for (const auto& entry : extensionsObject.GetObject())
-            {
-                ExtensionPair extensionPair = { entry.name.GetString(), Serialize(entry.value) };
-
-                if (extensionDeserializer.HasHandler(extensionPair.name, node) ||
-                    extensionDeserializer.HasHandler(extensionPair.name))
-                {
-                    node.SetExtension(extensionDeserializer.Deserialize(extensionPair, node));
-                }
-                else
-                {
-                    node.extensions.emplace(std::move(extensionPair.name), std::move(extensionPair.value));
-                }
-            }
-        }
-    }
-
-    void ParseExtras(const rapidjson::Value& v, glTFProperty& node)
-    {
-        rapidjson::Value::ConstMemberIterator it;
-        if (TryFindMember("extras", v, it))
-        {
-            const rapidjson::Value& a = it->value;
-            node.extras = Serialize(a);
-        }
-    }
-
-    void ParseProperty(const rapidjson::Value& v, glTFProperty& node, const ExtensionDeserializer& extensionDeserializer)
-    {
-        ParseExtensions(v, node, extensionDeserializer);
-        ParseExtras(v, node);
-    }
-
-    void ParseTextureInfo(const rapidjson::Value& v, TextureInfo& textureInfo, const ExtensionDeserializer& extensionDeserializer)
-    {
-        auto textureIndexIt = FindRequiredMember("index", v);
-        textureInfo.textureId = std::to_string(textureIndexIt->value.GetUint());
-        textureInfo.texCoord = GetMemberValueOrDefault<size_t>(v, "texCoord", 0U);
-        ParseProperty(v, textureInfo, extensionDeserializer);
-    }
-
-    template<typename T>
-    IndexedContainer<const T> DeserializeToIndexedContainer(
-        const char* name,
-        const rapidjson::Value& value,
-        const ExtensionDeserializer& extensionDeserializer,
-        T(*fn)(const rapidjson::Value&, const ExtensionDeserializer&))
-    {
-        IndexedContainer<const T> items;
-
-        rapidjson::Value::ConstMemberIterator it;
-        if (TryFindMember(name, value, it))
-        {
-            size_t index = 0;
-
-            for (auto& valueArray : it->value.GetArray())
-            {
-                try
-                {
-                    const auto& item = items.Append(fn(valueArray, extensionDeserializer), AppendIdPolicy::GenerateOnEmpty);
-                    const auto& itemId = item.id;
-
-                    (void)itemId;   // To disable unused-variable warnings when assert is compiled away.
-                    assert(itemId == std::to_string(index));
-                }
-                catch (const InvalidGLTFException& e)
-                {
-                    std::cerr << "Could not parse " << name << "[" << index << "]: " << e.what() << "\n";
-                    throw;
-                }
-
-                ++index;
-            }
-        }
-
-        return items;
-    }
-
-    Asset ParseAsset(const rapidjson::Value& assetValue, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Asset asset;
-
-        asset.copyright = GetMemberValueOrDefault<std::string>(assetValue, "copyright");
-        asset.generator = GetMemberValueOrDefault<std::string>(assetValue, "generator");
-        asset.version = FindRequiredMember("version", assetValue)->value.GetString();
-        asset.minVersion = GetMemberValueOrDefault<std::string>(assetValue, "minVersion");
-
-        ParseProperty(assetValue, asset, extensionDeserializer);
-
-        return asset;
-    }
-
-    Accessor ParseAccessor(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Accessor accessor;
-        accessor.name = GetMemberValueOrDefault<std::string>(v, "name");
-
-        rapidjson::Value::ConstMemberIterator it;
-
-        if (TryFindMember("sparse", v, it)) 
-        {
-            const rapidjson::Value& sparseMember = it->value;
-            const rapidjson::Value& sparseIndicesMember = FindRequiredMember("indices", sparseMember)->value;
-            const rapidjson::Value& sparseValuesMember = FindRequiredMember("values", sparseMember)->value;
-
-            accessor.sparse.count = GetValue<size_t>(FindRequiredMember("count", sparseMember)->value);
-
-            accessor.sparse.indicesBufferViewId = std::to_string(FindRequiredMember("bufferView", sparseIndicesMember)->value.GetUint());
-            accessor.sparse.indicesComponentType = Accessor::GetComponentType(FindRequiredMember("componentType", sparseIndicesMember)->value.GetUint());
-            accessor.sparse.indicesByteOffset = GetMemberValueOrDefault<size_t>(sparseIndicesMember, "byteOffset");
-
-            accessor.sparse.valuesBufferViewId = std::to_string(FindRequiredMember("bufferView", sparseValuesMember)->value.GetUint());
-            accessor.sparse.valuesByteOffset = GetMemberValueOrDefault<size_t>(sparseValuesMember, "byteOffset");
-
-            if (TryFindMember("bufferView", v, it))
-            {
-                accessor.bufferViewId = std::to_string(it->value.GetUint());
-            }
-        }
-        else
-        {
-            accessor.bufferViewId = GetMemberValueAsString<size_t>(v, "bufferView");
-        }
-
-        accessor.byteOffset = GetMemberValueOrDefault<size_t>(v, "byteOffset");
-        accessor.componentType = Accessor::GetComponentType(FindRequiredMember("componentType", v)->value.GetUint());
-        accessor.normalized = GetMemberValueOrDefault<bool>(v, "normalized", false);
-        accessor.count = GetValue<size_t>(FindRequiredMember("count", v)->value);
-        accessor.type = Accessor::ParseType(FindRequiredMember("type", v)->value.GetString());
-
-        if (TryFindMember("min", v, it))
-        {
-            for (rapidjson::Value::ConstValueIterator ait = it->value.Begin(); ait != it->value.End(); ++ait)
-            {
-                accessor.min.push_back(static_cast<float>(ait->GetDouble()));
-            }
-        }
-
-        if (TryFindMember("max", v, it))
-        {
-            for (rapidjson::Value::ConstValueIterator ait = it->value.Begin(); ait != it->value.End(); ++ait)
-            {
-                accessor.max.push_back(static_cast<float>(ait->GetDouble()));
-            }
-        }
-
-        ParseProperty(v, accessor, extensionDeserializer);
-
-        return accessor;
-    }
-
-    BufferView ParseBufferView(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        BufferView bv;
-
-        bv.name = GetMemberValueOrDefault<std::string>(v, "name");
-        bv.bufferId = std::to_string(FindRequiredMember("buffer", v)->value.GetUint());
-        bv.byteOffset = GetMemberValueOrDefault<size_t>(v, "byteOffset");
-        bv.byteLength = GetValue<size_t>(FindRequiredMember("byteLength", v)->value);
-
-        auto itByteStride = v.FindMember("byteStride");
-        if (itByteStride != v.MemberEnd())
-        {
-            bv.byteStride = itByteStride->value.GetUint();
-        }
-
-        // When target is not provided, the bufferView contains animation or skin data
-        auto itTarget = v.FindMember("target");
-        if (itTarget != v.MemberEnd())
-        {
-            bv.target = static_cast<BufferViewTarget>(itTarget->value.GetUint());
-        }
-
-        ParseProperty(v, bv, extensionDeserializer);
-
-        return bv;
-    }
-
-    Scene ParseScene(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Scene scene;
-
-        rapidjson::Value::ConstMemberIterator it = v.FindMember("nodes");
-        if (it != v.MemberEnd())
-        {
-            const rapidjson::Value& a = it->value;
-            scene.nodes.reserve(a.Capacity());
-            for (rapidjson::Value::ConstValueIterator ait = a.Begin(); ait != a.End(); ++ait)
-            {
-                scene.nodes.push_back(std::to_string(ait->GetUint()));
-            }
-        }
-
-        ParseProperty(v, scene, extensionDeserializer);
-
-        return scene;
-    }
-
-    MorphTarget ParseTarget(const rapidjson::Value& v)
-    {
-        MorphTarget target;
-        target.positionsAccessorId = GetMemberValueAsString<uint32_t>(v, ACCESSOR_POSITION);
-        target.normalsAccessorId = GetMemberValueAsString<uint32_t>(v, ACCESSOR_NORMAL);
-        target.tangentsAccessorId = GetMemberValueAsString<uint32_t>(v, ACCESSOR_TANGENT);
-
-        return target;
-    }
-
-    void ParseTargets(const rapidjson::Value& v, MeshPrimitive& primitive)
-    {
-        rapidjson::Value::ConstMemberIterator it = v.FindMember("targets");
-        if (it != v.MemberEnd())
-        {
-            const rapidjson::Value& a = it->value;
-            primitive.targets.reserve(a.Capacity());
-            for (rapidjson::Value::ConstValueIterator ait = a.Begin(); ait != a.End(); ++ait)
-            {
-                primitive.targets.push_back(ParseTarget(*ait));
-            }
-        }
-    }
-
-    MeshPrimitive ParseMeshPrimitive(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        MeshPrimitive primitive;
-
-        rapidjson::Value::ConstMemberIterator it = v.FindMember("attributes");
-        if (it != v.MemberEnd())
-        {
-            const auto& attributes = it->value.GetObject();
-
-            for (const auto& attribute : attributes)
-            {
-                auto name = attribute.name.GetString();
-                primitive.attributes[name] = std::to_string(attribute.value.Get<uint32_t>());
-            }
-        }
-
-        primitive.indicesAccessorId = GetMemberValueAsString<uint32_t>(v, "indices");
-        primitive.materialId = GetMemberValueAsString<uint32_t>(v, "material");
-        primitive.mode = static_cast<MeshMode>(GetMemberValueOrDefault<int>(v, "mode", MESH_TRIANGLES));
-        ParseTargets(v, primitive);
-
-        ParseProperty(v, primitive, extensionDeserializer);
-
-        return primitive;
-    }
-
-    Mesh ParseMesh(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Mesh mesh;
-        mesh.name = GetMemberValueOrDefault<std::string>(v, "name");
-
-        rapidjson::Value::ConstMemberIterator it = v.FindMember("primitives");
-
-        if (it != v.MemberEnd())
-        {
-            const rapidjson::Value& a = it->value;
-            mesh.primitives.reserve(a.Capacity());
-            for (rapidjson::Value::ConstValueIterator ait = a.Begin(); ait != a.End(); ++ait)
-            {
-                mesh.primitives.push_back(ParseMeshPrimitive(*ait, extensionDeserializer));
-            }
-        }
-
-        mesh.weights = RapidJsonUtils::ToFloatArray(v, "weights");
-
-        ParseProperty(v, mesh, extensionDeserializer);
-
-        return mesh;
-    }
-
-    void ParseNodeScale(const rapidjson::Value& v, Node& node)
-    {
-        const int scaleCapacity = 3;
-        auto it = v.FindMember("scale");
-        if (it == v.MemberEnd())
-        {
-            node.scale = Vector3::ONE;
-            return;
-        }
-
-        const rapidjson::Value& a = it->value;
-        if (a.Capacity() != scaleCapacity)
-        {
-            throw InvalidGLTFException("A node must have a scale with 3 elements");
-        }
-
-        rapidjson::Value::ConstValueIterator ait = a.Begin();
-        node.scale.x = ait++->GetFloat();
-        node.scale.y = ait++->GetFloat();
-        node.scale.z = ait->GetFloat();
-    }
-
-    void ParseNodeTranslation(const rapidjson::Value& v, Node& node)
-    {
-        const int translationCapacity = 3;
-        auto it = v.FindMember("translation");
-        if (it == v.MemberEnd())
-        {
-            node.translation = Vector3::ZERO;
-            return;
-        }
-
-        const rapidjson::Value& a = it->value;
-        if (a.Capacity() != translationCapacity)
-        {
-            throw InvalidGLTFException("A node must have a translation with 3 elements");
-        }
-
-        rapidjson::Value::ConstValueIterator ait = a.Begin();
-        node.translation.x = ait++->GetFloat();
-        node.translation.y = ait++->GetFloat();
-        node.translation.z = ait->GetFloat();
-    }
-
-    void ParseNodeRotation(const rapidjson::Value& v, Node& node)
-    {
-        const int rotationCapacity = 4;
-        auto it = v.FindMember("rotation");
-        if (it == v.MemberEnd())
-        {
-            node.rotation = Quaternion(0.0f, 0.0f, 0.0f, 1.0f);
-            return;
-        }
-
-        const rapidjson::Value& a = it->value;
-        if (a.Capacity() != rotationCapacity)
-        {
-            throw InvalidGLTFException("A node must have a rotation with 4 elements");
-        }
-
-        rapidjson::Value::ConstValueIterator ait = a.Begin();
-        node.rotation.x = ait++->GetFloat();
-        node.rotation.y = ait++->GetFloat();
-        node.rotation.z = ait++->GetFloat();
-        node.rotation.w = ait->GetFloat();
-    }
-
-    void ParseNodeMatrix(const rapidjson::Value& v, Node& node)
-    {
-        auto it = v.FindMember("matrix");
-        if (it == v.MemberEnd())
-        {
-            ParseNodeScale(v, node);
-            ParseNodeTranslation(v, node);
-            ParseNodeRotation(v, node);
-            return;
-        }
-
-        const rapidjson::Value& a = it->value;
-        if (a.Capacity() != 16)
-        {
-            throw InvalidGLTFException("A node must have a matrix transform with 16 elements");
-        }
-
-        uint8_t index = 0;
-        for (rapidjson::Value::ConstValueIterator ait = a.Begin(); ait != a.End(); ++ait)
-        {
-            node.matrix.values[index] = static_cast<float>(ait->GetDouble());
-            index++;
-        }
-    }
-
-    void ParseNodeChildren(const rapidjson::Value& v, Node& node)
-    {
-        rapidjson::Value::ConstMemberIterator it = v.FindMember("children");
-        if (it != v.MemberEnd())
-        {
-            const rapidjson::Value& a = it->value;
-            node.children.reserve(a.Capacity());
-            for (rapidjson::Value::ConstValueIterator ait = a.Begin(); ait != a.End(); ++ait)
-            {
-                node.children.push_back(std::to_string(ait->GetUint()));
-            }
-        }
-    }
-
-    Camera ParseCamera(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        std::unique_ptr<Projection> projection;
-        std::string projectionType = FindRequiredMember("type", v)->value.GetString();
-
-        if (projectionType == "perspective")
-        {
-            auto perspectiveIt = v.FindMember("perspective");
-            if (perspectiveIt == v.MemberEnd())
-            {
-                throw InvalidGLTFException("Camera perspective projection undefined");
-            }
-
-            Optional<float> aspectRatio;
-
-            auto itAspectRatio = perspectiveIt->value.FindMember("aspectRatio");
-            if (itAspectRatio != perspectiveIt->value.MemberEnd())
-            {
-                aspectRatio = itAspectRatio->value.GetFloat();
-            }
-
-            float yfov = GetValue<float>(FindRequiredMember("yfov", perspectiveIt->value)->value);
-            float znear = GetValue<float>(FindRequiredMember("znear", perspectiveIt->value)->value);
-
-            Optional<float> zfar;
-
-            auto itZFar = perspectiveIt->value.FindMember("zfar");
-            if (itZFar != perspectiveIt->value.MemberEnd())
-            {
-                zfar = itZFar->value.GetFloat();
-            }
-
-            auto perspective = std::make_unique<Perspective>(znear, yfov);
-
-            perspective->zfar = zfar;
-            perspective->aspectRatio = aspectRatio;
-
-            ParseProperty(perspectiveIt->value, *perspective, extensionDeserializer);
-
-            projection = std::move(perspective);
-        }
-        else if (projectionType == "orthographic")
-        {
-            auto orthographicIt = v.FindMember("orthographic");
-            if (orthographicIt == v.MemberEnd())
-            {
-                throw InvalidGLTFException("Camera orthographic projection undefined");
-            }
-
-            float xmag = GetValue<float>(FindRequiredMember("xmag", orthographicIt->value)->value);
-            float ymag = GetValue<float>(FindRequiredMember("ymag", orthographicIt->value)->value);
-            float zfar = GetValue<float>(FindRequiredMember("zfar", orthographicIt->value)->value);
-            float znear = GetValue<float>(FindRequiredMember("znear", orthographicIt->value)->value);
-            projection = std::make_unique<Orthographic>(zfar, znear, xmag, ymag);
-
-            ParseProperty(orthographicIt->value, *projection, extensionDeserializer);
-        }
-
-        // Camera constructor will throw a GLTFException when projection is null (i.e. source manifest specified an invalid projection type)
-        Camera camera(std::move(projection));
-        camera.name = GetMemberValueOrDefault<std::string>(v, "name");
-
-        if (!camera.projection->IsValid())
-        {
-            throw InvalidGLTFException("Camera's projection is not valid");
-        }
-
-        ParseProperty(v, camera, extensionDeserializer);
-
-        return camera;
-    }
-
-    Node ParseNode(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Node node;
-        node.name = GetMemberValueOrDefault<std::string>(v, "name");
-
-        ParseNodeChildren(v, node);
-        node.meshId = GetMemberValueAsString<uint32_t>(v, "mesh");
-        node.skinId = GetMemberValueAsString<uint32_t>(v, "skin");
-        node.cameraId = GetMemberValueAsString<uint32_t>(v, "camera");
-        ParseNodeMatrix(v, node);
-        node.weights = RapidJsonUtils::ToFloatArray(v, "weights");
-
-        ParseProperty(v, node, extensionDeserializer);
-
-        return node;
-    }
-
-    Buffer ParseBuffer(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Buffer buffer;
-
-        buffer.byteLength = GetValue<size_t>(FindRequiredMember("byteLength", v)->value);
-        buffer.uri = GetMemberValueOrDefault<std::string>(v, "uri");
-
-        ParseProperty(v, buffer, extensionDeserializer);
-
-        return buffer;
-    }
-
-    Sampler ParseSampler(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Sampler sampler;
-
-        sampler.name = GetMemberValueOrDefault<std::string>(v, "name");
-        sampler.wrapT = Sampler::GetSamplerWrapMode(GetMemberValueOrDefault<unsigned int>(v, "wrapT", static_cast<unsigned int>(WrapMode::Wrap_REPEAT)));
-        sampler.wrapS = Sampler::GetSamplerWrapMode(GetMemberValueOrDefault<unsigned int>(v, "wrapS", static_cast<unsigned int>(WrapMode::Wrap_REPEAT)));
-
-        auto itMin = v.FindMember("minFilter");
-        if (itMin != v.MemberEnd())
-        {
-            sampler.minFilter = Sampler::GetSamplerMinFilterMode(itMin->value.GetUint());
-        }
-
-        auto itMag = v.FindMember("magFilter");
-        if (itMag != v.MemberEnd())
-        {
-            sampler.magFilter = Sampler::GetSamplerMagFilterMode(itMag->value.GetUint());
-        }
-
-        ParseProperty(v, sampler, extensionDeserializer);
-
-        return sampler;
-    }
-
-    AnimationTarget ParseAnimationTarget(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        try
-        {
-            AnimationTarget target;
-
-            target.nodeId = GetMemberValueAsString<uint32_t>(v, "node");
-
-            auto it = v.FindMember("path");
-            if (it != v.MemberEnd())
-            {
-                target.path = ParseTargetPath(it->value.GetString());
-            }
-
-            ParseProperty(v, target, extensionDeserializer);
-
-            return target;
-        }
-        catch (const InvalidGLTFException& e)
-        {
-            std::cerr << "Could not parse animation target\n" << e.what() << "\n";
-            throw;
-        }
-    }
-
-    AnimationChannel ParseAnimationChannel(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        try
-        {
-            AnimationChannel channel;
-
-            channel.samplerId = GetMemberValueAsString<uint32_t>(v, "sampler");
-            channel.target = ParseAnimationTarget(FindRequiredMember("target", v)->value, extensionDeserializer);
-
-            ParseProperty(v, channel, extensionDeserializer);
-
-            return channel;
-        }
-        catch (const InvalidGLTFException& e)
-        {
-            std::cerr << "Could not parse channel\n" << e.what() << "\n";
-            throw;
-        }
-    }
-
-    AnimationSampler ParseAnimationSampler(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        AnimationSampler sampler;
-
-        sampler.inputAccessorId = GetMemberValueAsString<uint32_t>(v, "input");
-        sampler.outputAccessorId = GetMemberValueAsString<uint32_t>(v, "output");
-
-        auto it = v.FindMember("interpolation");
-        if (it != v.MemberEnd())
-        {
-            sampler.interpolation = ParseInterpolationType(it->value.GetString());
-        }
-
-        ParseProperty(v, sampler, extensionDeserializer);
-
-        return sampler;
-    }
-
-    Animation ParseAnimation(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Animation anim;
-        anim.name = GetMemberValueOrDefault<std::string>(v, "name");
-
-        anim.channels = DeserializeToIndexedContainer<AnimationChannel>("channels", v, extensionDeserializer, ParseAnimationChannel);
-
-        anim.samplers = DeserializeToIndexedContainer<AnimationSampler>("samplers", v, extensionDeserializer, ParseAnimationSampler);
-
-        ParseProperty(v, anim, extensionDeserializer);
-
-        return anim;
-    }
-
-    Skin ParseSkin(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Skin skin;
-
-        skin.name = GetMemberValueOrDefault<std::string>(v, "name");
-        skin.inverseBindMatricesAccessorId = GetMemberValueAsString<uint32_t>(v, "inverseBindMatrices");
-        skin.skeletonId = GetMemberValueAsString<uint32_t>(v, "skeleton");
-
-        rapidjson::Value::ConstMemberIterator it = v.FindMember("joints");
-        if (it != v.MemberEnd())
-        {
-            const rapidjson::Value& a = it->value;
-            skin.jointIds.reserve(a.Capacity());
-            for (rapidjson::Value::ConstValueIterator ait = a.Begin(); ait != a.End(); ++ait)
-            {
-                skin.jointIds.push_back(std::to_string(ait->GetInt()));
-            }
-        }
-
-        ParseProperty(v, skin, extensionDeserializer);
-
-        return skin;
-    }
-
-    void ParseExtensionsUsed(const rapidjson::Document& d, Document& gltfDocument)
-    {
-        rapidjson::Value::ConstMemberIterator it;
-        if (TryFindMember("extensionsUsed", d, it))
-        {
-            const rapidjson::Value& a = it->value;
-            for (rapidjson::Value::ConstValueIterator ait = a.Begin(); ait != a.End(); ++ait)
-            {
-                gltfDocument.extensionsUsed.insert(ait->GetString());
-            }
-        }
-    }
-
-    void ParseExtensionsRequired(const rapidjson::Document& d, Document& gltfDocument)
-    {
-        rapidjson::Value::ConstMemberIterator it;
-        if (TryFindMember("extensionsRequired", d, it))
-        {
-            const rapidjson::Value& a = it->value;
-            for (rapidjson::Value::ConstValueIterator ait = a.Begin(); ait != a.End(); ++ait)
-            {
-                gltfDocument.extensionsRequired.insert(ait->GetString());
-            }
-        }
-    }
-
-    void ValidateMaterial(Material& material)
-    {
-        if (material.occlusionTexture.strength > 1 || material.occlusionTexture.strength < 0)
-        {
-            throw InvalidGLTFException("Material " + material.name + " has invalid occlusionStrength (value out of range [0,1])");
-        }
-    }
-
-    Material ParseMaterial(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        Material material;
-
-        auto mit = v.FindMember("pbrMetallicRoughness");
-        if (mit != v.MemberEnd())
-        {
-            auto& pbrMr = mit->value;
-
-            // Diffuse
-            auto baseColorFactorIt = pbrMr.FindMember("baseColorFactor");
-            if (baseColorFactorIt != pbrMr.MemberEnd())
-            {
-                std::vector<float> baseColorFactor;
-                for (rapidjson::Value::ConstValueIterator ait = baseColorFactorIt->value.Begin(); ait != baseColorFactorIt->value.End(); ++ait)
-                {
-                    baseColorFactor.push_back(static_cast<float>(ait->GetDouble()));
-                }
-                material.metallicRoughness.baseColorFactor = Color4(baseColorFactor[0], baseColorFactor[1], baseColorFactor[2], baseColorFactor[3]);
-            }
-            
-            auto baseColorTextureIt = pbrMr.FindMember("baseColorTexture");
-            if (baseColorTextureIt != pbrMr.MemberEnd())
-            {
-                ParseTextureInfo(baseColorTextureIt->value, material.metallicRoughness.baseColorTexture, extensionDeserializer);
-            }
-
-            material.metallicRoughness.metallicFactor = GetMemberValueOrDefault<float>(pbrMr, "metallicFactor", 1.0f);
-            material.metallicRoughness.roughnessFactor = GetMemberValueOrDefault<float>(pbrMr, "roughnessFactor", 1.0f);
-
-            auto metallicRoughnessTextureIt = pbrMr.FindMember("metallicRoughnessTexture");
-            if (metallicRoughnessTextureIt != pbrMr.MemberEnd())
-            {
-                ParseTextureInfo(metallicRoughnessTextureIt->value, material.metallicRoughness.metallicRoughnessTexture, extensionDeserializer);
-            }
-        }
-
-        // Normal
-        auto normalTextureIt = v.FindMember("normalTexture");
-        if (normalTextureIt != v.MemberEnd())
-        {
-            ParseTextureInfo(normalTextureIt->value, material.normalTexture, extensionDeserializer);
-            material.normalTexture.scale = GetMemberValueOrDefault<float>(normalTextureIt->value, "scale", 1.0f);
-        }
-
-        // Occlusion
-        auto occlusionTextureIt = v.FindMember("occlusionTexture");
-        if (occlusionTextureIt != v.MemberEnd())
-        {
-            ParseTextureInfo(occlusionTextureIt->value, material.occlusionTexture, extensionDeserializer);
-            material.occlusionTexture.strength = GetMemberValueOrDefault<float>(occlusionTextureIt->value, "strength", 1.0f);
-        }
-
-        // Emissive Texture
-        auto emissionTextureIt = v.FindMember("emissiveTexture");
-        if (emissionTextureIt != v.MemberEnd())
-        {
-            ParseTextureInfo(emissionTextureIt->value, material.emissiveTexture, extensionDeserializer);
-        }
-
-        // Emissive Factor
-        auto emissionFactorIt = v.FindMember("emissiveFactor");
-        if (emissionFactorIt != v.MemberEnd())
-        {
-            std::vector<float> emissiveFactor;
-            for (rapidjson::Value::ConstValueIterator ait = emissionFactorIt->value.Begin(); ait != emissionFactorIt->value.End(); ++ait)
-            {
-                emissiveFactor.push_back(static_cast<float>(ait->GetDouble()));
-            }
-            material.emissiveFactor = Color3(emissiveFactor[0], emissiveFactor[1], emissiveFactor[2]);
-        }
-
-        // Alpha Mode
-        auto alphaModeIt = v.FindMember("alphaMode");
-        if (alphaModeIt != v.MemberEnd())
-        {
-            material.alphaMode = ParseAlphaMode(alphaModeIt->value.GetString());
-        }
-
-        // Alpha Cutoff
-        material.alphaCutoff = GetMemberValueOrDefault<float>(v, "alphaCutoff", 0.5f);
-
-        // Name
-        material.name = GetMemberValueOrDefault<std::string>(v, "name");
-
-        // Double Sided
-        material.doubleSided = GetMemberValueOrDefault<bool>(v, "doubleSided", false);
-
-        ParseProperty(v, material, extensionDeserializer);
-
-        ValidateMaterial(material);
-
-        return material;
-    }
-
-    Texture ParseTexture(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        // Parse texture fields or assign default values see:
-        // https://github.com/KhronosGroup/glTF/blob/master/specification/README.md
-
-        Texture texture;
-
-        texture.name = GetMemberValueOrDefault<std::string>(v, "name");
-        texture.imageId = GetMemberValueAsString<uint32_t>(v, "source");
-        texture.samplerId = GetMemberValueAsString<uint32_t>(v, "sampler");
-
-        ParseProperty(v, texture, extensionDeserializer);
-
-        return texture;
-    }
-
-    Image ParseImage(const rapidjson::Value& v, const ExtensionDeserializer& extensionDeserializer)
-    {
-        // Parse image fields or assign default values see:
-        // https://github.com/KhronosGroup/glTF/blob/master/specification/README.md
-
-        Image image;
-
-        image.name = GetMemberValueOrDefault<std::string>(v, "name");
-        image.uri = GetMemberValueOrDefault<std::string>(v, "uri");
-        image.bufferViewId = GetMemberValueAsString<uint32_t>(v, "bufferView");
-        image.mimeType = GetMemberValueOrDefault<std::string>(v, "mimeType");
-
-        ParseProperty(v, image, extensionDeserializer);
-
-        return image;
-    }
-
-    Document DeserializeInternal(const rapidjson::Document& document, const ExtensionDeserializer& extensionDeserializer, SchemaFlags schemaFlags)
-    {
-        ValidateDocumentAgainstSchema(document, SCHEMA_URI_GLTF, GetDefaultSchemaLocator(schemaFlags));
-
-        Document gltfDocument;
-
-        rapidjson::Value::ConstMemberIterator it;
-        if (TryFindMember("asset", document, it))
-        {
-            gltfDocument.asset = ParseAsset(it->value, extensionDeserializer);
-        }
-
-        gltfDocument.accessors   = DeserializeToIndexedContainer<Accessor>("accessors", document, extensionDeserializer, ParseAccessor);
-        gltfDocument.animations  = DeserializeToIndexedContainer<Animation>("animations", document, extensionDeserializer, ParseAnimation);
-        gltfDocument.buffers     = DeserializeToIndexedContainer<Buffer>("buffers", document, extensionDeserializer, ParseBuffer);
-        gltfDocument.bufferViews = DeserializeToIndexedContainer<BufferView>("bufferViews", document, extensionDeserializer, ParseBufferView);
-        gltfDocument.cameras     = DeserializeToIndexedContainer<Camera>("cameras", document, extensionDeserializer, ParseCamera);
-        gltfDocument.images      = DeserializeToIndexedContainer<Image>("images", document, extensionDeserializer, ParseImage);
-        gltfDocument.materials   = DeserializeToIndexedContainer<Material>("materials", document, extensionDeserializer, ParseMaterial);
-        gltfDocument.meshes      = DeserializeToIndexedContainer<Mesh>("meshes", document, extensionDeserializer, ParseMesh);
-        gltfDocument.nodes       = DeserializeToIndexedContainer<Node>("nodes", document, extensionDeserializer, ParseNode);
-        gltfDocument.samplers    = DeserializeToIndexedContainer<Sampler>("samplers", document, extensionDeserializer, ParseSampler);
-        gltfDocument.scenes      = DeserializeToIndexedContainer<Scene>("scenes", document, extensionDeserializer, ParseScene);
-        gltfDocument.skins       = DeserializeToIndexedContainer<Skin>("skins", document, extensionDeserializer, ParseSkin);
-        gltfDocument.textures    = DeserializeToIndexedContainer<Texture>("textures", document, extensionDeserializer, ParseTexture);
-
-        ParseProperty(document, gltfDocument, extensionDeserializer);
-
-        if (TryFindMember("scene", document, it))
-        {
-            gltfDocument.defaultSceneId = std::to_string(it->value.GetUint());
-        }
-
-        ParseExtensionsUsed(document, gltfDocument);
-        ParseExtensionsRequired(document, gltfDocument);
-
-        return gltfDocument;
-    }
-
-    bool HasFlag(DeserializeFlags flags, DeserializeFlags flag)
-    {
-        return ((flags & flag) == flag);
-    }
-}
-
-Document Microsoft::glTF::Deserialize(const std::string& json, DeserializeFlags flags, SchemaFlags schemaFlags)
-{
-    return Deserialize(json, ExtensionDeserializer(), flags, schemaFlags);
-}
-
-Document Microsoft::glTF::Deserialize(const std::string& json, const ExtensionDeserializer& extensionDeserializer, DeserializeFlags flags, SchemaFlags schemaFlags)
-{
-    const auto document = HasFlag(flags, DeserializeFlags::IgnoreByteOrderMark) ?
-        RapidJsonUtils::CreateDocumentFromEncodedString(json) :
-        RapidJsonUtils::CreateDocumentFromString(json);
-
-    return DeserializeInternal(document, extensionDeserializer, schemaFlags);
-}
-
-Document Microsoft::glTF::Deserialize(std::istream& jsonStream, DeserializeFlags flags, SchemaFlags schemaFlags)
-{
-    return Deserialize(jsonStream, ExtensionDeserializer(), flags, schemaFlags);
-}
-
-Document Microsoft::glTF::Deserialize(std::istream& jsonStream, const ExtensionDeserializer& extensionDeserializer, DeserializeFlags flags, SchemaFlags schemaFlags)
-{
-    const auto document = HasFlag(flags, DeserializeFlags::IgnoreByteOrderMark) ?
-        RapidJsonUtils::CreateDocumentFromEncodedStream(jsonStream) :
-        RapidJsonUtils::CreateDocumentFromStream(jsonStream);
-
-    return DeserializeInternal(document, extensionDeserializer, schemaFlags);
-}
-
-DeserializeFlags Microsoft::glTF::operator|(DeserializeFlags lhs, DeserializeFlags rhs)
-{
-    const auto result =
-        static_cast<std::underlying_type_t<DeserializeFlags>>(lhs) |
-        static_cast<std::underlying_type_t<DeserializeFlags>>(rhs);
-
-    return static_cast<DeserializeFlags>(result);
-}
-
-DeserializeFlags& Microsoft::glTF::operator|=(DeserializeFlags& lhs, DeserializeFlags rhs)
-{
-    lhs = lhs | rhs;
-    return lhs;
-}
-
-DeserializeFlags Microsoft::glTF::operator&(DeserializeFlags lhs, DeserializeFlags rhs)
-{
-    const auto result =
-        static_cast<std::underlying_type_t<DeserializeFlags>>(lhs) &
-        static_cast<std::underlying_type_t<DeserializeFlags>>(rhs);
-
-    return static_cast<DeserializeFlags>(result);
-}
-
-DeserializeFlags& Microsoft::glTF::operator&=(DeserializeFlags& lhs, DeserializeFlags rhs)
-{
-    lhs = lhs & rhs;
-    return lhs;
-}
diff --git a/thirdparty/GLTFSDK/Source/Document.cpp b/thirdparty/GLTFSDK/Source/Document.cpp
deleted file mode 100644
index 91b9f0f..0000000
--- a/thirdparty/GLTFSDK/Source/Document.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/Document.h>
-
-using namespace Microsoft::glTF;
-
-Document::Document() = default;
-
-Document::Document(Asset&& asset) : asset(std::move(asset))
-{
-}
-
-bool Document::IsExtensionUsed(const std::string& extension) const
-{
-    return extensionsUsed.find(extension) != extensionsUsed.end();
-}
-
-bool Document::IsExtensionRequired(const std::string& extension) const
-{
-    return extensionsRequired.find(extension) != extensionsRequired.end();
-}
-
-bool Document::HasDefaultScene() const
-{
-    return !defaultSceneId.empty();
-}
-
-const Scene& Document::GetDefaultScene() const
-{
-    // According to the 2.0 spec: 
-    //      "The glTF asset contains ZERO or more scenes"
-    //      "When scene is undefined, runtime is not required to render anything at load time."
-    // If there's no default defined, return the first scene, if there is one.
-    if (HasDefaultScene())
-    {
-        return scenes[defaultSceneId];
-    }
-
-    if (!scenes.Elements().empty())
-    {
-        return scenes.Elements().front();
-    }
-
-    throw DocumentException("Default scene " + defaultSceneId + " was not found.");
-}
-
-const Scene& Document::SetDefaultScene(Scene&& scene, AppendIdPolicy policy)
-{
-    const auto& defaultScene = scenes.Append(std::move(scene), policy);
-    defaultSceneId = defaultScene.id;
-    return defaultScene;
-}
-
-bool Document::operator==(const Document& rhs) const
-{
-    return this->asset == rhs.asset
-        && this->accessors == rhs.accessors
-        && this->animations == rhs.animations
-        && this->buffers == rhs.buffers
-        && this->bufferViews == rhs.bufferViews
-        && this->cameras == rhs.cameras
-        && this->images == rhs.images
-        && this->materials == rhs.materials
-        && this->meshes == rhs.meshes
-        && this->nodes == rhs.nodes
-        && this->samplers == rhs.samplers
-        && this->scenes == rhs.scenes
-        && this->skins == rhs.skins
-        && this->textures == rhs.textures
-        && this->extensionsUsed == rhs.extensionsUsed
-        && this->extensionsRequired == rhs.extensionsRequired
-        && this->defaultSceneId == rhs.defaultSceneId
-        && glTFProperty::Equals(*this, rhs);
-}
diff --git a/thirdparty/GLTFSDK/Source/Extension.cpp b/thirdparty/GLTFSDK/Source/Extension.cpp
deleted file mode 100644
index b8e5bc8..0000000
--- a/thirdparty/GLTFSDK/Source/Extension.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/Extension.h>
-
-using namespace Microsoft::glTF;
-
-bool Extension::operator==(const Extension& rhs) const
-{
-    return IsEqual(rhs);
-}
-
-bool Extension::operator!=(const Extension& rhs) const
-{
-    return !operator==(rhs);
-}
diff --git a/thirdparty/GLTFSDK/Source/ExtensionHandlers.cpp b/thirdparty/GLTFSDK/Source/ExtensionHandlers.cpp
deleted file mode 100644
index c0455cf..0000000
--- a/thirdparty/GLTFSDK/Source/ExtensionHandlers.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/ExtensionHandlers.h>
-
-#include <GLTFSDK/Exceptions.h>
-#include <GLTFSDK/GLTF.h>
-
-using namespace Microsoft::glTF;
-
-Detail::TypeKey Detail::MakeTypeKey(const Extension& extension, const glTFProperty& property)
-{
-    return { typeid(extension), typeid(property) };
-}
-
-Detail::NameKey Detail::MakeNameKey(const std::string& name, const glTFProperty& property)
-{
-    return { name, typeid(property) };
-}
-
-ExtensionPair ExtensionSerializer::Serialize(const Extension& extension, const glTFProperty& property, const Document& document) const
-{
-    auto it = typeToName.find(Detail::MakeTypeKey(extension, property));
-
-    if (it == typeToName.end())
-    {
-        it = typeToName.find(Detail::MakeTypeKey<glTFPropertyAll>(extension));
-    }
-
-    if (it == typeToName.end())
-    {
-        throw GLTFException("No handler registered to serialize the passed extension type");
-    }
-
-    return { it->second, Process(it->first, extension, document, *this) };
-}
-
-std::unique_ptr<Extension> ExtensionDeserializer::Deserialize(const ExtensionPair& extensionPair, const glTFProperty& property) const
-{
-    auto it = nameToType.find(Detail::MakeNameKey(extensionPair.name, property));
-
-    if (it == nameToType.end())
-    {
-        it = nameToType.find(Detail::MakeNameKey<glTFPropertyAll>(extensionPair.name));
-    }
-
-    if (it == nameToType.end())
-    {
-        throw GLTFException("No handler registered to deserialize the specified extension name");
-    }
-
-    return Process({ it->second, it->first.second }, extensionPair.value, *this);
-}
diff --git a/thirdparty/GLTFSDK/Source/ExtensionsKHR.cpp b/thirdparty/GLTFSDK/Source/ExtensionsKHR.cpp
deleted file mode 100644
index 969e7b7..0000000
--- a/thirdparty/GLTFSDK/Source/ExtensionsKHR.cpp
+++ /dev/null
@@ -1,535 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/ExtensionsKHR.h>
-
-#include <GLTFSDK/Document.h>
-#include <GLTFSDK/RapidJsonUtils.h>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    void ParseExtensions(const rapidjson::Value& v, glTFProperty& node, const ExtensionDeserializer& extensionDeserializer)
-    {
-        const auto& extensionsIt = v.FindMember("extensions");
-        if (extensionsIt != v.MemberEnd())
-        {
-            const rapidjson::Value& extensionsObject = extensionsIt->value;
-            for (const auto& entry : extensionsObject.GetObject())
-            {
-                ExtensionPair extensionPair = { entry.name.GetString(), Serialize(entry.value) };
-
-                if (extensionDeserializer.HasHandler(extensionPair.name, node) ||
-                    extensionDeserializer.HasHandler(extensionPair.name))
-                {
-                    node.SetExtension(extensionDeserializer.Deserialize(extensionPair, node));
-                }
-                else
-                {
-                    node.extensions.emplace(std::move(extensionPair.name), std::move(extensionPair.value));
-                }
-            }
-        }
-    }
-
-    void ParseExtras(const rapidjson::Value& v, glTFProperty& node)
-    {
-        rapidjson::Value::ConstMemberIterator it;
-        if (TryFindMember("extras", v, it))
-        {
-            const rapidjson::Value& a = it->value;
-            node.extras = Serialize(a);
-        }
-    }
-
-    void ParseProperty(const rapidjson::Value& v, glTFProperty& node, const ExtensionDeserializer& extensionDeserializer)
-    {
-        ParseExtensions(v, node, extensionDeserializer);
-        ParseExtras(v, node);
-    }
-
-    void ParseTextureInfo(const rapidjson::Value& v, TextureInfo& textureInfo, const ExtensionDeserializer& extensionDeserializer)
-    {
-        auto textureIndexIt = FindRequiredMember("index", v);
-        textureInfo.textureId = std::to_string(textureIndexIt->value.GetUint());
-        textureInfo.texCoord = GetMemberValueOrDefault<size_t>(v, "texCoord", 0U);
-        ParseProperty(v, textureInfo, extensionDeserializer);
-    }
-
-    void SerializePropertyExtensions(const Document& gltfDocument, const glTFProperty& property, rapidjson::Value& propertyValue, rapidjson::Document::AllocatorType& a, const ExtensionSerializer& extensionSerializer)
-    {
-        auto registeredExtensions = property.GetExtensions();
-
-        if (!property.extensions.empty() || !registeredExtensions.empty())
-        {
-            rapidjson::Value& extensions = RapidJsonUtils::FindOrAddMember(propertyValue, "extensions", a);
-
-            // Add registered extensions
-            for (const auto& extension : registeredExtensions)
-            {
-                const auto extensionPair = extensionSerializer.Serialize(extension, property, gltfDocument);
-
-                if (property.HasUnregisteredExtension(extensionPair.name))
-                {
-                    throw GLTFException("Registered extension '" + extensionPair.name + "' is also present as an unregistered extension.");
-                }
-
-                if (gltfDocument.extensionsUsed.find(extensionPair.name) == gltfDocument.extensionsUsed.end())
-                {
-                    throw GLTFException("Registered extension '" + extensionPair.name + "' is not present in extensionsUsed");
-                }
-
-                const auto d = RapidJsonUtils::CreateDocumentFromString(extensionPair.value);//TODO: validate the returned document against the extension schema!
-                rapidjson::Value v(rapidjson::kObjectType);
-                v.CopyFrom(d, a);
-                extensions.AddMember(RapidJsonUtils::ToStringValue(extensionPair.name, a), v, a);
-            }
-
-            // Add unregistered extensions
-            for (const auto& extension : property.extensions)
-            {
-                const auto d = RapidJsonUtils::CreateDocumentFromString(extension.second);
-                rapidjson::Value v(rapidjson::kObjectType);
-                v.CopyFrom(d, a);
-                extensions.AddMember(RapidJsonUtils::ToStringValue(extension.first, a), v, a);
-            }
-        }
-    }
-
-    void SerializePropertyExtras(const glTFProperty& property, rapidjson::Value& propertyValue, rapidjson::Document::AllocatorType& a)
-    {
-        if (!property.extras.empty())
-        {
-            auto d = RapidJsonUtils::CreateDocumentFromString(property.extras);
-            rapidjson::Value v(rapidjson::kObjectType);
-            v.CopyFrom(d, a);
-            propertyValue.AddMember("extras", v, a);
-        }
-    }
-
-    void SerializeProperty(const Document& gltfDocument, const glTFProperty& property, rapidjson::Value& propertyValue, rapidjson::Document::AllocatorType& a, const ExtensionSerializer& extensionSerializer)
-    {
-        SerializePropertyExtensions(gltfDocument, property, propertyValue, a, extensionSerializer);
-        SerializePropertyExtras(property, propertyValue, a);
-    }
-
-    void SerializeTextureInfo(const Document& gltfDocument, const TextureInfo& textureInfo, rapidjson::Value& textureValue, rapidjson::Document::AllocatorType& a, const IndexedContainer<const Texture>& textures, const ExtensionSerializer& extensionSerializer)
-    {
-        RapidJsonUtils::AddOptionalMemberIndex("index", textureValue, textureInfo.textureId, textures, a);
-        if (textureInfo.texCoord != 0)
-        {
-            textureValue.AddMember("texCoord", ToKnownSizeType(textureInfo.texCoord), a);
-        }
-        SerializeProperty(gltfDocument, textureInfo, textureValue, a, extensionSerializer);
-    }
-}
-
-ExtensionSerializer KHR::GetKHRExtensionSerializer()
-{
-    using namespace Materials;
-    using namespace MeshPrimitives;
-    using namespace TextureInfos;
-
-    ExtensionSerializer extensionSerializer;
-    extensionSerializer.AddHandler<PBRSpecularGlossiness, Material>(PBRSPECULARGLOSSINESS_NAME, SerializePBRSpecGloss);
-    extensionSerializer.AddHandler<Unlit, Material>(UNLIT_NAME, SerializeUnlit);
-    extensionSerializer.AddHandler<DracoMeshCompression, MeshPrimitive>(DRACOMESHCOMPRESSION_NAME, SerializeDracoMeshCompression);
-    extensionSerializer.AddHandler<TextureTransform, TextureInfo>(TEXTURETRANSFORM_NAME, SerializeTextureTransform);
-    extensionSerializer.AddHandler<TextureTransform, Material::NormalTextureInfo>(TEXTURETRANSFORM_NAME, SerializeTextureTransform);
-    extensionSerializer.AddHandler<TextureTransform, Material::OcclusionTextureInfo>(TEXTURETRANSFORM_NAME, SerializeTextureTransform);
-    return extensionSerializer;
-}
-
-ExtensionDeserializer KHR::GetKHRExtensionDeserializer()
-{
-    using namespace Materials;
-    using namespace MeshPrimitives;
-    using namespace TextureInfos;
-
-    ExtensionDeserializer extensionDeserializer;
-    extensionDeserializer.AddHandler<PBRSpecularGlossiness, Material>(PBRSPECULARGLOSSINESS_NAME, DeserializePBRSpecGloss);
-    extensionDeserializer.AddHandler<Unlit, Material>(UNLIT_NAME, DeserializeUnlit);
-    extensionDeserializer.AddHandler<DracoMeshCompression, MeshPrimitive>(DRACOMESHCOMPRESSION_NAME, DeserializeDracoMeshCompression);
-    extensionDeserializer.AddHandler<TextureTransform, TextureInfo>(TEXTURETRANSFORM_NAME, DeserializeTextureTransform);
-    extensionDeserializer.AddHandler<TextureTransform, Material::NormalTextureInfo>(TEXTURETRANSFORM_NAME, DeserializeTextureTransform);
-    extensionDeserializer.AddHandler<TextureTransform, Material::OcclusionTextureInfo>(TEXTURETRANSFORM_NAME, DeserializeTextureTransform);
-    return extensionDeserializer;
-}
-
-// KHR::Materials::PBRSpecularGlossiness
-
-KHR::Materials::PBRSpecularGlossiness::PBRSpecularGlossiness() :
-    diffuseFactor(1.0f, 1.0f, 1.0f, 1.0f),
-    specularFactor(1.0f, 1.0f, 1.0f),
-    glossinessFactor(1.0f)
-{
-}
-
-std::unique_ptr<Extension> KHR::Materials::PBRSpecularGlossiness::Clone() const
-{
-    return std::make_unique<PBRSpecularGlossiness>(*this);
-}
-
-bool KHR::Materials::PBRSpecularGlossiness::IsEqual(const Extension& rhs) const
-{
-    const auto other = dynamic_cast<const PBRSpecularGlossiness*>(&rhs);
-
-    return other != nullptr
-        && glTFProperty::Equals(*this, *other)
-        && this->diffuseFactor == other->diffuseFactor
-        && this->diffuseTexture == other->diffuseTexture
-        && this->specularFactor == other->specularFactor
-        && this->glossinessFactor == other->glossinessFactor
-        && this->specularGlossinessTexture == other->specularGlossinessTexture;
-}
-
-std::string KHR::Materials::SerializePBRSpecGloss(const Materials::PBRSpecularGlossiness& specGloss, const Document& gltfDocument, const ExtensionSerializer& extensionSerializer)
-{
-    rapidjson::Document doc;
-    auto& a = doc.GetAllocator();
-    rapidjson::Value KHR_pbrSpecularGlossiness(rapidjson::kObjectType);
-    {
-        if (specGloss.diffuseFactor != Color4(1.0f, 1.0f, 1.0f, 1.0f))
-        {
-            KHR_pbrSpecularGlossiness.AddMember("diffuseFactor", RapidJsonUtils::ToJsonArray(specGloss.diffuseFactor, a), a);
-        }
-
-        if (!specGloss.diffuseTexture.textureId.empty())
-        {
-            rapidjson::Value diffuseTexture(rapidjson::kObjectType);
-            SerializeTextureInfo(gltfDocument, specGloss.diffuseTexture, diffuseTexture, a, gltfDocument.textures, extensionSerializer);
-            KHR_pbrSpecularGlossiness.AddMember("diffuseTexture", diffuseTexture, a);
-        }
-
-        if (specGloss.specularFactor != Color3(1.0f, 1.0f, 1.0f))
-        {
-            KHR_pbrSpecularGlossiness.AddMember("specularFactor", RapidJsonUtils::ToJsonArray(specGloss.specularFactor, a), a);
-        }
-
-        if (specGloss.glossinessFactor != 1.0)
-        {
-            KHR_pbrSpecularGlossiness.AddMember("glossinessFactor", specGloss.glossinessFactor, a);
-        }
-
-        if (!specGloss.specularGlossinessTexture.textureId.empty())
-        {
-            rapidjson::Value specularGlossinessTexture(rapidjson::kObjectType);
-            SerializeTextureInfo(gltfDocument, specGloss.specularGlossinessTexture, specularGlossinessTexture, a, gltfDocument.textures, extensionSerializer);
-            KHR_pbrSpecularGlossiness.AddMember("specularGlossinessTexture", specularGlossinessTexture, a);
-        }
-
-        SerializeProperty(gltfDocument, specGloss, KHR_pbrSpecularGlossiness, a, extensionSerializer);
-    }
-
-    rapidjson::StringBuffer buffer;
-    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
-    KHR_pbrSpecularGlossiness.Accept(writer);
-
-    return buffer.GetString();
-}
-
-std::unique_ptr<Extension> KHR::Materials::DeserializePBRSpecGloss(const std::string& json, const ExtensionDeserializer& extensionDeserializer)
-{
-    Materials::PBRSpecularGlossiness specGloss;
-
-    auto doc = RapidJsonUtils::CreateDocumentFromString(json);
-    const rapidjson::Value sit = doc.GetObject();
-
-    // Diffuse Factor
-    auto diffuseFactIt = sit.FindMember("diffuseFactor");
-    if (diffuseFactIt != sit.MemberEnd())
-    {
-        std::vector<float> diffuseFactor;
-        for (rapidjson::Value::ConstValueIterator ait = diffuseFactIt->value.Begin(); ait != diffuseFactIt->value.End(); ++ait)
-        {
-            diffuseFactor.push_back(static_cast<float>(ait->GetDouble()));
-        }
-        specGloss.diffuseFactor = Color4(diffuseFactor[0], diffuseFactor[1], diffuseFactor[2], diffuseFactor[3]);
-    }
-
-    // Diffuse Texture
-    const auto diffuseTextureIt = sit.FindMember("diffuseTexture");
-    if (diffuseTextureIt != sit.MemberEnd())
-    {
-        ParseTextureInfo(diffuseTextureIt->value, specGloss.diffuseTexture, extensionDeserializer);
-    }
-
-    // Specular Factor
-    auto specularFactIt = sit.FindMember("specularFactor");
-    if (specularFactIt != sit.MemberEnd())
-    {
-        std::vector<float> specularFactor;
-        for (rapidjson::Value::ConstValueIterator ait = specularFactIt->value.Begin(); ait != specularFactIt->value.End(); ++ait)
-        {
-            specularFactor.push_back(static_cast<float>(ait->GetDouble()));
-        }
-        specGloss.specularFactor = Color3(specularFactor[0], specularFactor[1], specularFactor[2]);
-    }
-
-    // Glossiness Factor
-    specGloss.glossinessFactor = GetMemberValueOrDefault<float>(sit, "glossinessFactor", 1.0f);
-
-    // SpecularGlossinessTexture
-    const auto specularGlossinessTextureIt = sit.FindMember("specularGlossinessTexture");
-    if (specularGlossinessTextureIt != sit.MemberEnd())
-    {
-        ParseTextureInfo(specularGlossinessTextureIt->value, specGloss.specularGlossinessTexture, extensionDeserializer);
-    }
-
-    ParseProperty(sit, specGloss, extensionDeserializer);
-
-    return std::make_unique<PBRSpecularGlossiness>(specGloss);
-}
-
-// KHR::Materials::Unlit
-
-std::unique_ptr<Extension> KHR::Materials::Unlit::Clone() const
-{
-    return std::make_unique<Unlit>(*this);
-}
-
-bool KHR::Materials::Unlit::IsEqual(const Extension& rhs) const
-{
-    return dynamic_cast<const Unlit*>(&rhs) != nullptr;
-}
-
-std::string KHR::Materials::SerializeUnlit(const Materials::Unlit& extension, const Document& gltfDocument, const ExtensionSerializer& extensionSerializer)
-{
-    rapidjson::Document doc;
-    auto& a = doc.GetAllocator();
-    rapidjson::Value unlitValue(rapidjson::kObjectType);
-
-    SerializeProperty(gltfDocument, extension, unlitValue, a, extensionSerializer);
-
-    rapidjson::StringBuffer buffer;
-    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
-    unlitValue.Accept(writer);
-
-    return buffer.GetString();
-}
-
-std::unique_ptr<Extension> KHR::Materials::DeserializeUnlit(const std::string& json, const ExtensionDeserializer& extensionDeserializer)
-{
-    Unlit unlit;
-
-    auto doc = RapidJsonUtils::CreateDocumentFromString(json);
-    const rapidjson::Value objValue = doc.GetObject();
-
-    ParseProperty(objValue, unlit, extensionDeserializer);
-
-    return std::make_unique<Unlit>(unlit);
-}
-
-// KHR::MeshPrimitives::DracoMeshCompression
-
-std::unique_ptr<Extension> KHR::MeshPrimitives::DracoMeshCompression::Clone() const
-{
-    return std::make_unique<DracoMeshCompression>(*this);
-}
-
-bool KHR::MeshPrimitives::DracoMeshCompression::IsEqual(const Extension& rhs) const
-{
-    const auto other = dynamic_cast<const DracoMeshCompression*>(&rhs);
-
-    return other != nullptr
-        && glTFProperty::Equals(*this, *other)
-        && this->bufferViewId == other->bufferViewId
-        && this->attributes == other->attributes;
-}
-
-std::string KHR::MeshPrimitives::SerializeDracoMeshCompression(const MeshPrimitives::DracoMeshCompression& dracoMeshCompression, const Document& glTFdoc, const ExtensionSerializer& extensionSerializer)
-{
-    rapidjson::Document doc;
-    auto& a = doc.GetAllocator();
-    rapidjson::Value KHR_draco_mesh_compression(rapidjson::kObjectType);
-    {
-        if (!dracoMeshCompression.bufferViewId.empty())
-        {
-            RapidJsonUtils::AddOptionalMemberIndex("bufferView", KHR_draco_mesh_compression, dracoMeshCompression.bufferViewId, glTFdoc.bufferViews, a);
-        }
-
-        rapidjson::Value attributesValue(rapidjson::kObjectType);
-
-        for (const auto& attribute : dracoMeshCompression.attributes)
-        {
-            rapidjson::Value attributeValue;
-            attributeValue.SetUint(attribute.second);
-            attributesValue.AddMember(RapidJsonUtils::ToStringValue(attribute.first, a), attributeValue, a);
-        }
-
-        KHR_draco_mesh_compression.AddMember(RapidJsonUtils::ToStringValue("attributes", a), attributesValue, a);
-
-        SerializeProperty(glTFdoc, dracoMeshCompression, KHR_draco_mesh_compression, a, extensionSerializer);
-    }
-
-    rapidjson::StringBuffer buffer;
-    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
-    KHR_draco_mesh_compression.Accept(writer);
-
-    return buffer.GetString();
-}
-
-std::unique_ptr<Extension> KHR::MeshPrimitives::DeserializeDracoMeshCompression(const std::string& json, const ExtensionDeserializer& extensionDeserializer)
-{
-    auto extension = std::make_unique<DracoMeshCompression>();
-
-    auto doc = RapidJsonUtils::CreateDocumentFromString(json);
-    const rapidjson::Value v = doc.GetObject();
-
-    extension->bufferViewId = GetMemberValueAsString<uint32_t>(v, "bufferView");
-
-    rapidjson::Value::ConstMemberIterator it = v.FindMember("attributes");
-    if (it != v.MemberEnd())
-    {
-        if (!it->value.IsObject())
-        {
-            throw GLTFException("Member attributes of " + std::string(DRACOMESHCOMPRESSION_NAME) + " is not an object.");
-        }
-        const auto& attributes = it->value.GetObject();
-
-        for (const auto& attribute : attributes)
-        {
-            auto name = attribute.name.GetString();
-
-            if (!attribute.value.IsInt())
-            {
-                throw GLTFException("Attribute " + std::string(name) + " of " + std::string(DRACOMESHCOMPRESSION_NAME) + " is not a number.");
-            }
-            extension->attributes.emplace(name, attribute.value.Get<uint32_t>());
-        }
-    }
-
-    ParseProperty(v, *extension, extensionDeserializer);
-
-    return extension;
-}
-
-// KHR::TextureInfos::TextureTransform
-
-KHR::TextureInfos::TextureTransform::TextureTransform() :
-    offset(Vector2::ZERO),
-    rotation(0.0f),
-    scale(Vector2::ONE),
-    texCoord()
-{
-}
-
-KHR::TextureInfos::TextureTransform::TextureTransform(const TextureTransform& textureTransform) :
-    offset(textureTransform.offset),
-    rotation(textureTransform.rotation),
-    scale(textureTransform.scale),
-    texCoord(textureTransform.texCoord)
-{
-}
-
-std::unique_ptr<Extension> KHR::TextureInfos::TextureTransform::Clone() const
-{
-    return std::make_unique<TextureTransform>(*this);
-}
-
-bool KHR::TextureInfos::TextureTransform::IsEqual(const Extension& rhs) const
-{
-    const auto other = dynamic_cast<const TextureTransform*>(&rhs);
-
-    return other != nullptr
-        && glTFProperty::Equals(*this, *other)
-        && this->offset == other->offset
-        && this->rotation == other->rotation
-        && this->scale == other->scale
-        && this->texCoord == other->texCoord;
-}
-
-std::string KHR::TextureInfos::SerializeTextureTransform(const TextureTransform& textureTransform, const Document& gltfDocument, const ExtensionSerializer& extensionSerializer)
-{
-    rapidjson::Document doc;
-    auto& a = doc.GetAllocator();
-    rapidjson::Value KHR_textureTransform(rapidjson::kObjectType);
-    {
-        if (textureTransform.offset != Vector2::ZERO)
-        {
-            KHR_textureTransform.AddMember("offset", RapidJsonUtils::ToJsonArray(textureTransform.offset, a), a);
-        }
-
-        if (textureTransform.rotation != 0.0f)
-        {
-            KHR_textureTransform.AddMember("rotation", textureTransform.rotation, a);
-        }
-
-        if (textureTransform.scale != Vector2::ONE)
-        {
-            KHR_textureTransform.AddMember("scale", RapidJsonUtils::ToJsonArray(textureTransform.scale, a), a);
-        }
-
-        if (textureTransform.texCoord)
-        {
-            KHR_textureTransform.AddMember("texCoord", ToKnownSizeType(textureTransform.texCoord.Get()), a);
-        }
-
-        SerializeProperty(gltfDocument, textureTransform, KHR_textureTransform, a, extensionSerializer);
-    }
-
-    glTF::rapidjson::StringBuffer buffer;
-    glTF::rapidjson::Writer<glTF::rapidjson::StringBuffer> writer(buffer);
-    KHR_textureTransform.Accept(writer);
-
-    return buffer.GetString();
-}
-
-std::unique_ptr<Extension> KHR::TextureInfos::DeserializeTextureTransform(const std::string& json, const ExtensionDeserializer& extensionDeserializer)
-{
-    TextureTransform textureTransform;
-
-    auto doc = RapidJsonUtils::CreateDocumentFromString(json);
-    const rapidjson::Value sit = doc.GetObject();
-
-    // Offset
-    auto offsetIt = sit.FindMember("offset");
-    if (offsetIt != sit.MemberEnd())
-    {
-        if (offsetIt->value.Size() != 2)
-        {
-            throw GLTFException("Offset member of " + std::string(TEXTURETRANSFORM_NAME) + " must have two values.");
-        }
-
-        std::vector<float> offset;
-        for (rapidjson::Value::ConstValueIterator ait = offsetIt->value.Begin(); ait != offsetIt->value.End(); ++ait)
-        {
-            offset.push_back(static_cast<float>(ait->GetDouble()));
-        }
-        textureTransform.offset.x = offset[0];
-        textureTransform.offset.y = offset[1];
-    }
-
-    // Rotation
-    textureTransform.rotation = GetMemberValueOrDefault<float>(sit, "rotation", 0.0f);
-
-    // Scale
-    auto scaleIt = sit.FindMember("scale");
-    if (scaleIt != sit.MemberEnd())
-    {
-        if (scaleIt->value.Size() != 2)
-        {
-            throw GLTFException("Scale member of " + std::string(TEXTURETRANSFORM_NAME) + " must have two values.");
-        }
-
-        std::vector<float> scale;
-        for (rapidjson::Value::ConstValueIterator ait = scaleIt->value.Begin(); ait != scaleIt->value.End(); ++ait)
-        {
-            scale.push_back(static_cast<float>(ait->GetDouble()));
-        }
-        textureTransform.scale.x = scale[0];
-        textureTransform.scale.y = scale[1];
-    }
-
-    // TexCoord
-    auto texCoordIt = sit.FindMember("texCoord");
-    if (texCoordIt != sit.MemberEnd())
-    {
-        textureTransform.texCoord = static_cast<size_t>(texCoordIt->value.GetUint());
-    }
-
-    ParseProperty(sit, textureTransform, extensionDeserializer);
-
-    return std::make_unique<TextureTransform>(textureTransform);
-}
diff --git a/thirdparty/GLTFSDK/Source/GLBResourceReader.cpp b/thirdparty/GLTFSDK/Source/GLBResourceReader.cpp
deleted file mode 100644
index ef56b86..0000000
--- a/thirdparty/GLTFSDK/Source/GLBResourceReader.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/GLBResourceReader.h>
-
-#include <GLTFSDK/Constants.h>
-
-#include <memory>
-#include <string.h>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    bool ParseChunkType(const char* expectedChunkType, std::istream& stream)
-    {
-        char buffer[GLB_CHUNK_TYPE_SIZE];
-        stream.read(buffer, GLB_CHUNK_TYPE_SIZE);
-        if (stream.fail())
-        {
-            throw InvalidGLTFException("Cannot read the chunk type: " + std::string(expectedChunkType));
-        }
-        auto cmp = memcmp(&buffer[0], expectedChunkType, GLB_CHUNK_TYPE_SIZE);
-        return cmp == 0;
-    }
-
-    std::string ReadJson(std::istream& stream, size_t jsonLength)
-    {
-        stream.seekg(GLB_HEADER_BYTE_SIZE);
-        std::string json(jsonLength, '\0');
-        StreamUtils::ReadBinary(stream, &json[0], jsonLength);
-        if (stream.fail())
-        {
-            throw InvalidGLTFException("Cannot read the json from the GLB file");
-        }
-        return json;
-    }
-}
-
-GLBResourceReader::GLBResourceReader(std::shared_ptr<const IStreamReader> streamReader, std::shared_ptr<std::istream> glbStream)
-    : GLTFResourceReader(std::move(streamReader)),
-    m_buffer(std::move(glbStream)),
-    m_bufferOffset()
-{
-    Init();
-}
-
-GLBResourceReader::GLBResourceReader(std::unique_ptr<IStreamReaderCache> streamCache, std::shared_ptr<std::istream> glbStream)
-    : GLTFResourceReader(std::move(streamCache)),
-    m_buffer(std::move(glbStream)),
-    m_bufferOffset()
-{
-    Init();
-}
-
-std::shared_ptr<std::istream> GLBResourceReader::GetBinaryStream(const Buffer& buffer) const
-{
-    std::shared_ptr<std::istream> stream;
-
-    // We allow "uri": "data:," to refer to a GLB buffer
-    if (buffer.uri.empty() || buffer.uri == EMPTY_URI)
-    {
-        stream = m_buffer;
-    }
-    else
-    {
-        stream = GLTFResourceReader::GetBinaryStream(buffer);
-    }
-
-    return stream;
-}
-
-std::streampos GLBResourceReader::GetBinaryStreamPos(const Buffer& buffer) const
-{
-    std::streampos streamPos;
-
-    // We allow "uri": "data:," to refer to a GLB buffer
-    if (buffer.uri.empty() || buffer.uri == EMPTY_URI)
-    {
-        streamPos = m_bufferOffset;
-    }
-    else
-    {
-        streamPos = GLTFResourceReader::GetBinaryStreamPos(buffer);
-    }
-
-    return streamPos;
-}
-
-const std::string& GLBResourceReader::GetJson() const
-{
-    return m_json;
-}
-
-void GLBResourceReader::Init()
-{
-    // Get the length of the stream before reading anything, to validate against later
-    // NOTE: The approach used below with seekg to the end and then tellg may be problematic since
-    // seekg is not guaranteed to give the number of bytes from the start of the file:
-    // see http://stackoverflow.com/a/22986486. This is used elsewhere in the code though,
-    // and seems to Do The Right Thing as of right now. TODO: discuss fixing this problem.
-    const auto curPos = m_buffer->tellg();
-    m_buffer->seekg(0, std::ios::end);
-    uint32_t trueStreamLength = static_cast<uint32_t>(m_buffer->tellg()); // in bytes (i.e. sizeof(char))
-    m_buffer->seekg(curPos); // reset the stream pointer where it was
-
-    char magic[GLB_HEADER_MAGIC_STRING_SIZE];
-    m_buffer->read(magic, sizeof(magic));
-    if (m_buffer->fail())
-    {
-        throw InvalidGLTFException("Cannot read the magic number");
-    }
-
-    const uint32_t version = StreamUtils::ReadBinary<uint32_t>(*m_buffer);
-    const uint32_t length = StreamUtils::ReadBinary<uint32_t>(*m_buffer);
-
-    // Verify that the length we just read actually matches the length of the stream
-    if (trueStreamLength != length)
-    {
-        throw InvalidGLTFException("File-reported file length does not match actual file length");
-    }
-
-    const uint32_t jsonChunkLength = StreamUtils::ReadBinary<uint32_t>(*m_buffer);
-
-    if (!ParseChunkType(GLB_CHUNK_TYPE_JSON, *m_buffer))
-    {
-        throw InvalidGLTFException("JSON chunk should appear first");
-    }
-
-    // validate header
-    if (strncmp(magic, GLB_HEADER_MAGIC_STRING, GLB_HEADER_MAGIC_STRING_SIZE) != 0)
-    {
-        throw InvalidGLTFException("Cannot find GLB magic bytes");
-    }
-
-    if (version != GLB_HEADER_VERSION_2)
-    {
-        throw InvalidGLTFException("Unsupported GLB Version: " + std::to_string(version));
-    }
-
-    // Length has been validated as the actual length of the file, but make sure to include the header bytes in this check
-    if (length < (GLB_HEADER_BYTE_SIZE + jsonChunkLength))
-    {
-        throw InvalidGLTFException("File length " + std::to_string(length) + " less than content length " + std::to_string(jsonChunkLength) + 
-            " plus header length " + std::to_string(GLB_HEADER_BYTE_SIZE));
-    }
-
-    m_json = ReadJson(*m_buffer, jsonChunkLength);
-
-    // If length is exactly equal to the json chunk length, plus the header, it means there is no binary buffer chunk
-    if (length == (GLB_HEADER_BYTE_SIZE + jsonChunkLength))
-    {
-        return;
-    }
-
-    // Read the length of the binary buffer chunk
-    const uint32_t bufferChunkLength = StreamUtils::ReadBinary<uint32_t>(*m_buffer);
-
-    if (!ParseChunkType(GLB_CHUNK_TYPE_BIN, *m_buffer))
-    {
-        throw InvalidGLTFException("Binary chunk should appear second");
-    }
-
-    // Verify that the sum of the sizes of the chunks (plus the headers) matches the size of the file
-    const uint32_t chunkSizeSum = GLB_HEADER_BYTE_SIZE + jsonChunkLength + sizeof(bufferChunkLength) + GLB_CHUNK_TYPE_SIZE +  bufferChunkLength;
-
-    if (chunkSizeSum != length)
-    {
-        throw InvalidGLTFException("File length does not match sum of length of component chunks");
-    }
-
-    m_bufferOffset = m_buffer->tellg();
-}
diff --git a/thirdparty/GLTFSDK/Source/GLBResourceWriter.cpp b/thirdparty/GLTFSDK/Source/GLBResourceWriter.cpp
deleted file mode 100644
index 9d3b934..0000000
--- a/thirdparty/GLTFSDK/Source/GLBResourceWriter.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/GLBResourceWriter.h>
-
-#include <sstream>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    uint32_t CalculatePadding(size_t byteLength)
-    {
-        const uint32_t alignmentSize = GLB_CHUNK_ALIGNMENT_SIZE;
-
-        const auto padAlign = byteLength % alignmentSize;
-        const auto pad = padAlign ? alignmentSize - padAlign : 0U;
-
-        return static_cast<uint32_t>(pad);
-    }
-}
-
-GLBResourceWriter::GLBResourceWriter(std::shared_ptr<const IStreamWriter> streamWriter)
-    : GLBResourceWriter(std::move(streamWriter), std::make_unique<std::stringstream>())
-{
-}
-
-GLBResourceWriter::GLBResourceWriter(std::shared_ptr<const IStreamWriter> streamWriter, std::unique_ptr<std::iostream> tempBufferStream)
-    : GLTFResourceWriter(std::move(streamWriter)),
-    m_stream(std::move(tempBufferStream))
-{
-}
-
-GLBResourceWriter::GLBResourceWriter(std::unique_ptr<IStreamWriterCache> streamCache)
-    : GLBResourceWriter(std::move(streamCache), std::make_unique<std::stringstream>())
-{
-}
-
-GLBResourceWriter::GLBResourceWriter(std::unique_ptr<IStreamWriterCache> streamCache, std::unique_ptr<std::iostream> tempBufferStream)
-    : GLTFResourceWriter(std::move(streamCache)),
-    m_stream(std::move(tempBufferStream))
-{
-}
-
-void GLBResourceWriter::Flush(const std::string& manifest, const std::string& uri)
-{
-    uint32_t jsonChunkLength = static_cast<uint32_t>(manifest.length());
-    const uint32_t jsonPaddingLength = ::CalculatePadding(jsonChunkLength);
-
-    jsonChunkLength += jsonPaddingLength;
-
-    uint32_t binaryChunkLength = static_cast<uint32_t>(GetBufferOffset(GLB_BUFFER_ID));
-    const uint32_t binaryPaddingLength = ::CalculatePadding(binaryChunkLength);
-
-    binaryChunkLength += binaryPaddingLength;
-
-    const uint32_t length = GLB_HEADER_BYTE_SIZE // 12 bytes (GLB header) + 8 bytes (JSON header)
-        + jsonChunkLength
-        + sizeof(binaryChunkLength) + GLB_CHUNK_TYPE_SIZE // 8 bytes (BIN header)
-        + binaryChunkLength;
-
-    auto stream = m_streamWriterCache->Get(uri);
-
-    // Write GLB header (12 bytes)
-    StreamUtils::WriteBinary(*stream, GLB_HEADER_MAGIC_STRING, GLB_HEADER_MAGIC_STRING_SIZE);
-    StreamUtils::WriteBinary(*stream, GLB_HEADER_VERSION_2);
-    StreamUtils::WriteBinary(*stream, length);
-
-    // Write JSON header (8 bytes)
-    StreamUtils::WriteBinary(*stream, jsonChunkLength);
-    StreamUtils::WriteBinary(*stream, GLB_CHUNK_TYPE_JSON, GLB_CHUNK_TYPE_SIZE);
-
-    // Write JSON (indeterminate length)
-    StreamUtils::WriteBinary(*stream, manifest);
-
-    if (jsonPaddingLength > 0)
-    {
-        // GLB spec requires the JSON chunk to be padded with trailing space characters (0x20) to satisfy alignment requirements
-        StreamUtils::WriteBinary(*stream, std::string(jsonPaddingLength, ' '));
-    }
-
-    // Write BIN header (8 bytes)
-    StreamUtils::WriteBinary(*stream, binaryChunkLength);
-    StreamUtils::WriteBinary(*stream, GLB_CHUNK_TYPE_BIN, GLB_CHUNK_TYPE_SIZE);
-
-    // Write BIN contents (indeterminate length) - copy the temporary buffer's contents to the output stream
-    if (binaryChunkLength > 0)
-    {
-        *stream << m_stream->rdbuf();
-    }
-
-    if (binaryPaddingLength > 0)
-    {
-        // GLB spec requires the BIN chunk to be padded with trailing zeros (0x00) to satisfy alignment requirements
-        StreamUtils::WriteBinary(*stream, std::vector<uint8_t>(binaryPaddingLength, 0));
-    }
-}
-
-std::string GLBResourceWriter::GenerateBufferUri(const std::string& bufferId) const
-{
-    std::string bufferUri;
-
-    // Return an empty uri string when passed the GLB buffer id
-    if (bufferId != GLB_BUFFER_ID)
-    {
-        bufferUri = GLTFResourceWriter::GenerateBufferUri(bufferId);
-    }
-
-    return bufferUri;
-}
-
-std::ostream* GLBResourceWriter::GetBufferStream(const std::string& bufferId)
-{
-    std::ostream* stream = m_stream.get();
-
-    if (bufferId != GLB_BUFFER_ID)
-    {
-        stream = GLTFResourceWriter::GetBufferStream(bufferId);
-    }
-
-    return stream;
-}
\ No newline at end of file
diff --git a/thirdparty/GLTFSDK/Source/GLTFResourceReader.cpp b/thirdparty/GLTFSDK/Source/GLTFResourceReader.cpp
deleted file mode 100644
index 0cc857e..0000000
--- a/thirdparty/GLTFSDK/Source/GLTFResourceReader.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/GLTFResourceReader.h>
-#include <GLTFSDK/ResourceReaderUtils.h>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    template<typename T>
-    std::vector<float> DecodeToFloats(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-    {
-        std::vector<T> rawData = reader.ReadBinaryData<T>(doc, accessor);
-
-        std::vector<float> floatData;
-        floatData.reserve(rawData.size());
-
-        if (accessor.normalized)
-        {
-            for (size_t i = 0; i < rawData.size(); ++i)
-                floatData.push_back(ComponentToFloat(rawData[i]));
-        }
-        else
-        {
-            for (size_t i = 0; i < rawData.size(); ++i)
-                floatData.push_back(static_cast<float>(rawData[i]));
-        }
-
-        return floatData;
-    }
-}
-
-std::vector<float> GLTFResourceReader::ReadFloatData(const Document& gltfDocument, const Accessor& accessor) const
-{
-    switch (accessor.componentType)
-    {
-    case COMPONENT_BYTE:
-        return DecodeToFloats<int8_t>(gltfDocument, *this, accessor);
-
-    case COMPONENT_UNSIGNED_BYTE:
-        return DecodeToFloats<uint8_t>(gltfDocument, *this, accessor);
-
-    case COMPONENT_SHORT:
-        return DecodeToFloats<int16_t>(gltfDocument, *this, accessor);
-
-    case COMPONENT_UNSIGNED_SHORT:
-        return DecodeToFloats<uint16_t>(gltfDocument, *this, accessor);
-
-    case COMPONENT_FLOAT:
-        return ReadBinaryData<float>(gltfDocument, accessor);
-
-    default:
-        throw GLTFException("Unsupported accessor ComponentType");
-    }
-}
diff --git a/thirdparty/GLTFSDK/Source/GLTFResourceWriter.cpp b/thirdparty/GLTFSDK/Source/GLTFResourceWriter.cpp
deleted file mode 100644
index 9f947d4..0000000
--- a/thirdparty/GLTFSDK/Source/GLTFResourceWriter.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/GLTFResourceWriter.h>
-
-#include <GLTFSDK/StreamCacheLRU.h>
-
-using namespace Microsoft::glTF;
-
-GLTFResourceWriter::GLTFResourceWriter(std::shared_ptr<const IStreamWriter> streamWriter)
-    : GLTFResourceWriter(MakeStreamWriterCache<StreamWriterCacheLRU>(std::move(streamWriter), 16U))
-{
-}
-
-GLTFResourceWriter::GLTFResourceWriter(std::unique_ptr<IStreamWriterCache> streamCache)
-    : ResourceWriter(std::move(streamCache)),
-    m_streamOffsets()
-{
-}
-
-std::string GLTFResourceWriter::GenerateBufferUri(const std::string& bufferId) const
-{
-    return m_uriPrefix + bufferId + "." + Microsoft::glTF::BUFFER_EXTENSION;
-}
-
-void GLTFResourceWriter::SetUriPrefix(std::string uriPrefix)
-{
-    m_uriPrefix = std::move(uriPrefix);
-}
-
-std::ostream* GLTFResourceWriter::GetBufferStream(const std::string& bufferId)
-{
-    return m_streamWriterCache->Get(GenerateBufferUri(bufferId)).get();
-}
-
-std::streamoff GLTFResourceWriter::GetBufferOffset(const std::string& bufferId)
-{
-    // Default constructs an offset value (i.e. zero) if there was no entry in the map
-    return m_streamOffsets[bufferId];
-}
-
-void GLTFResourceWriter::SetBufferOffset(const std::string& bufferId, std::streamoff offset)
-{
-    m_streamOffsets[bufferId] = offset;
-}
diff --git a/thirdparty/GLTFSDK/Source/Math.cpp b/thirdparty/GLTFSDK/Source/Math.cpp
deleted file mode 100644
index 8a9fbf3..0000000
--- a/thirdparty/GLTFSDK/Source/Math.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/Math.h>
-
-#include <tuple>
-
-using namespace Microsoft::glTF;
-
-const Matrix4 Matrix4::IDENTITY = Matrix4();
-const Vector2 Vector2::ZERO = { 0.0f, 0.0f };
-const Vector2 Vector2::ONE = { 1.0f, 1.0f };
-const Vector3 Vector3::ZERO = { 0.0f, 0.0f, 0.0f };
-const Vector3 Vector3::ONE = { 1.0f, 1.0f, 1.0f };
-const Quaternion Quaternion::IDENTITY = { 0.0f, 0.0f, 0.0f, 1.0f };
-
-Matrix4::Matrix4()
-    : values({{
-        1.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 1.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 1.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 1.0f
-    }})
-{
-}
-
-bool Matrix4::operator==(const Matrix4& other) const
-{
-    return values == other.values;
-}
-
-bool Matrix4::operator!=(const Matrix4& other) const
-{
-    return !(*this == other);
-}
-
-Vector2::Vector2()
-    : x(0.0f), y(0.0f)
-{
-}
-
-Vector2::Vector2(float x, float y)
-    : x(x), y(y)
-{
-}
-
-bool Vector2::operator==(const Vector2& other) const
-{
-    return std::tie(x, y) == std::tie(other.x, other.y);
-}
-
-bool Vector2::operator!=(const Vector2& other) const
-{
-    return !operator==(other);
-}
-
-Vector3::Vector3()
-    : x(0.0f), y(0.0f), z(0.0f)
-{
-}
-
-Vector3::Vector3(float x, float y, float z)
-    : x(x), y(y), z(z)
-{
-}
-
-bool Vector3::operator==(const Vector3& other) const
-{
-    return std::tie(x, y, z) == std::tie(other.x, other.y, other.z);
-}
-
-bool Vector3::operator!=(const Vector3& other) const
-{
-    return !operator==(other);
-}
-
-Quaternion::Quaternion() :
-    x(0.0f), y(0.0f), z(0.0f), w(1.0f)
-{
-}
-
-Quaternion::Quaternion(float x, float y, float z, float w)
-    : x(x), y(y), z(z), w(w)
-{
-}
-
-bool Quaternion::operator==(const Quaternion& other) const
-{
-    return std::tie(x, y, z, w) == std::tie(other.x, other.y, other.z, other.w);
-}
-
-bool Quaternion::operator!=(const Quaternion& other) const
-{
-    return !operator==(other);
-}
-
diff --git a/thirdparty/GLTFSDK/Source/MeshPrimitiveUtils.cpp b/thirdparty/GLTFSDK/Source/MeshPrimitiveUtils.cpp
deleted file mode 100644
index 1ebc123..0000000
--- a/thirdparty/GLTFSDK/Source/MeshPrimitiveUtils.cpp
+++ /dev/null
@@ -1,885 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/MeshPrimitiveUtils.h>
-
-#include <GLTFSDK/GLTF.h>
-#include <GLTFSDK/GLTFResourceReader.h>
-#include <GLTFSDK/BufferBuilder.h>
-
-#include <cassert>
-#include <numeric>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    uint64_t ToUint64(const uint16_t short0, const uint16_t short1, const uint16_t short2, const uint16_t short3)
-    {
-        return
-            static_cast<uint64_t>(short3) << 48UL |
-            static_cast<uint64_t>(short2) << 32UL |
-            static_cast<uint64_t>(short1) << 16UL |
-            static_cast<uint64_t>(short0);
-    }
-
-    uint64_t ToUint64(const uint8_t byte0, const uint8_t byte1, const uint8_t byte2, const uint8_t byte3)
-    {
-        return
-            static_cast<uint64_t>(byte3) << 48UL |
-            static_cast<uint64_t>(byte2) << 32UL |
-            static_cast<uint64_t>(byte1) << 16UL |
-            static_cast<uint64_t>(byte0);
-    }
-
-    uint32_t ToUint32(const uint8_t byte0, const uint8_t byte1, const uint8_t byte2, const uint8_t byte3)
-    {
-        return
-            static_cast<uint32_t>(byte3) << 24U |
-            static_cast<uint32_t>(byte2) << 16U |
-            static_cast<uint32_t>(byte1) <<  8U |
-            static_cast<uint32_t>(byte0);
-    }
-
-    template<typename TIn, typename TOut>
-    std::vector<TOut> ReadIndices(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-    {
-        assert(sizeof(TOut) > sizeof(TIn));
-
-        const auto indices = reader.ReadBinaryData<TIn>(doc, accessor);
-        return std::vector<TOut>(indices.begin(), indices.end());
-    }
-
-    std::vector<uint32_t> PackColorsRGBA(const std::vector<float>& colors)
-    {
-        assert(colors.size() % 4 == 0);
-
-        std::vector<uint32_t> colors32;
-        colors32.reserve(colors.size() / 4);
-
-        for (size_t i = 0; i < colors.size(); i += 4)
-        {
-            colors32.push_back(Color4(colors[i], colors[i + 1], colors[i + 2], colors[i + 3]).AsUint32RGBA());
-        }
-
-        return colors32;
-    }
-
-    std::vector<uint32_t> PackColorsRGB(const std::vector<float>& colors)
-    {
-        assert(colors.size() % 3 == 0);
-
-        std::vector<uint32_t> colors32;
-        colors32.reserve(colors.size() / 3);
-
-        for (size_t i = 0; i < colors.size(); i += 3)
-        {
-            colors32.push_back(Color4(colors[i], colors[i + 1], colors[i + 2], 1.0f).AsUint32RGBA());
-        }
-
-        return colors32;
-    }
-
-    std::vector<uint32_t> PackColorsRGBA(const std::vector<uint8_t>& colors)
-    {
-        assert(colors.size() % 4 == 0);
-
-        std::vector<uint32_t> colors32;
-        colors32.reserve(colors.size() / 4);
-
-        for (size_t i = 0; i < colors.size(); i += 4)
-        {
-            uint8_t r = colors[i];
-            uint8_t g = colors[i + 1];
-            uint8_t b = colors[i + 2];
-            uint8_t a = colors[i + 3];
-            uint32_t rgba = ToUint32(r, g, b, a);
-            colors32.push_back(rgba);
-        }
-
-        return colors32;
-    }
-
-    std::vector<uint32_t> PackColorsRGB(const std::vector<uint8_t>& colors)
-    {
-        assert(colors.size() % 3 == 0);
-
-        std::vector<uint32_t> colors32;
-        colors32.reserve(colors.size() / 3);
-
-        for (size_t i = 0; i < colors.size(); i += 3)
-        {
-            uint8_t r = colors[i];
-            uint8_t g = colors[i + 1];
-            uint8_t b = colors[i + 2];
-            uint32_t rgba = ToUint32(r, g, b, 255);
-            colors32.push_back(rgba);
-        }
-
-        return colors32;
-    }
-
-    std::vector<uint32_t> ReadJoints32(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-    {
-        std::vector<uint8_t> joints = reader.ReadBinaryData<uint8_t>(doc, accessor);
-        std::vector<uint32_t> joints32;
-        joints32.reserve(joints.size() / 4);
-        for (size_t i = 0; i < joints.size(); i += 4)
-        {
-            joints32.push_back(ToUint32(joints[i], joints[i + 1], joints[i + 2], joints[i + 3]));
-        }
-        return joints32;
-    }
-
-    std::vector<uint64_t> ReadJoints64(const std::vector<uint8_t>& joints)
-    {
-        std::vector<uint64_t> joints64;
-        joints64.reserve(joints.size() / 4);
-        for (size_t i = 0; i < joints.size(); i += 4)
-        {
-            joints64.push_back(ToUint64(joints[i], joints[i + 1], joints[i + 2], joints[i + 3]));
-        }
-        return joints64;
-    }
-
-    std::vector<uint64_t> ReadJoints64(const std::vector<uint16_t>& joints)
-    {
-        std::vector<uint64_t> joints64;
-        joints64.reserve(joints.size() / 4);
-        for (size_t i = 0; i < joints.size(); i += 4)
-        {
-            joints64.push_back(ToUint64(joints[i], joints[i + 1], joints[i + 2], joints[i + 3]));
-        }
-        return joints64;
-    }
-
-    template<typename T>
-    std::vector<uint64_t> ReadJoints64(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-    {
-        std::vector<T> joints = reader.ReadBinaryData<T>(doc, accessor);
-        return ReadJoints64(joints);
-    }
-
-    std::vector<uint32_t> PackWeights32(const std::vector<float>& weights)
-    {
-        std::vector<uint32_t> weights32;
-        weights32.reserve(weights.size() / 4);
-        for (size_t i = 0; i < weights.size(); i += 4)
-        {
-            weights32.push_back(
-                ToUint32(
-                    Math::FloatToByte(weights[i]),
-                    Math::FloatToByte(weights[i + 1]),
-                    Math::FloatToByte(weights[i + 2]),
-                    Math::FloatToByte(weights[i + 3])));
-        }
-        return weights32;
-    }
-
-    std::vector<uint32_t> PackWeights32(const std::vector<uint8_t>& weights)
-    {
-        std::vector<uint32_t> weights32;
-        weights32.reserve(weights.size() / 4);
-        for (size_t i = 0; i < weights.size(); i += 4)
-        {
-            weights32.push_back(
-                ToUint32(
-                    weights[i],
-                    weights[i + 1],
-                    weights[i + 2],
-                    weights[i + 3]));
-        }
-        return weights32;
-    }
-
-    template<typename T>
-    std::vector<T> GetTrianglesFromTriangleStrip(const std::vector<T>& stripIndices)
-    {
-        if (stripIndices.size() < 3)
-        {
-            throw GLTFException("Triangle strip must contain at least 3 vertices.");
-        }
-
-        const size_t triangleCount = stripIndices.size() - 2;
-
-        std::vector<T> indices;
-        indices.reserve(triangleCount * 3);
-
-        // vertexCount = 5
-        // triangleCount = 3
-        // indices:
-        //     0,1,2
-        //     1,3,2
-        //     2,3,4
-        for (size_t i = 0; i < triangleCount; i++)
-        {
-            if (i % 2 == 0)
-            {
-                indices.push_back(stripIndices[i]);
-                indices.push_back(stripIndices[i + 1]);
-                indices.push_back(stripIndices[i + 2]);
-            }
-            else
-            {
-                indices.push_back(stripIndices[i]);
-                indices.push_back(stripIndices[i + 2]);
-                indices.push_back(stripIndices[i + 1]);
-            }
-        }
-
-        return indices;
-    }
-
-    template<typename T>
-    std::vector<T> GetTrianglesFromTriangleFan(const std::vector<T>& fanIndices)
-    {
-        if (fanIndices.size() < 3)
-        {
-            throw GLTFException("Triangle fan must contain at least 3 vertices.");
-        }
-
-        const size_t triangleCount = fanIndices.size() - 2;
-
-        std::vector<T> indices;
-        indices.reserve(triangleCount * 3);
-
-        // vertexCount = 5
-        // triangleCount = 3
-        // indices:
-        //     0,1,2
-        //     0,2,3
-        //     0,3,4
-        for (size_t i = 0; i < triangleCount; i++)
-        {
-            indices.push_back(fanIndices[0]);
-            indices.push_back(fanIndices[i + 1]);
-            indices.push_back(fanIndices[i + 2]);
-        }
-
-        return indices;
-    }
-
-    template<typename T>
-    std::vector<T> GetSegmentsFromLineStrip(const std::vector<T>& stripIndices)
-    {
-        if (stripIndices.size() < 2)
-        {
-            throw GLTFException("Line must contain at least 2 vertices.");
-        }
-
-        const size_t segmentCount = stripIndices.size() - 1;
-
-        std::vector<T> indices;
-        indices.reserve(segmentCount * 2);
-
-        // vertexCount = 4
-        // segmentCount = 3
-        // indices:
-        //     0,1
-        //     1,2
-        //     2,3
-        //     3,4
-        for (size_t i = 0; i < segmentCount; i++)
-        {
-            indices.push_back(stripIndices[i]);
-            indices.push_back(stripIndices[i + 1]);
-        }
-
-        return indices;
-    }
-
-    template<typename T>
-    std::vector<T> GetSegmentsFromLineLoop(const std::vector<T>& stripIndices)
-    {
-        auto indices = GetSegmentsFromLineStrip(stripIndices);
-
-        const size_t segmentCount = stripIndices.size();
-        indices.push_back(stripIndices[segmentCount - 1]);
-        indices.push_back(stripIndices[0]);
-
-        return indices;
-    }
-
-    template<typename T>
-    std::vector<T> GetTriangulatedIndices(const MeshMode meshMode, const std::vector<T>& rawIndices)
-    {
-        if (rawIndices.size() < 3)
-        {
-            throw GLTFException("MeshPrimitive has fewer than 3 indices.");
-        }
-
-        switch (meshMode)
-        {
-        case MESH_TRIANGLES:
-            if (rawIndices.size() % 3 != 0)
-            {
-                throw GLTFException("MeshPrimitives with mode MESH_TRIANGLES has non-multiple-of-3 indices.");
-            }
-            return rawIndices;
-        case MESH_TRIANGLE_STRIP:
-            return GetTrianglesFromTriangleStrip(rawIndices);
-        case MESH_TRIANGLE_FAN:
-            return GetTrianglesFromTriangleFan(rawIndices);
-        default:
-            throw GLTFException("Invalid mesh mode for triangulation " + std::to_string(meshMode));
-        }
-    }
-
-    template<typename T>
-    std::vector<T> GetSegmentedIndices(const MeshMode meshMode, const std::vector<T>& rawIndices)
-    {
-        if (rawIndices.size() < 2)
-        {
-            throw GLTFException("MeshPrimitive has fewer than 2 indices.");
-        }
-
-        switch (meshMode)
-        {
-        case MESH_LINES:
-            if (rawIndices.size() % 2 != 0)
-            {
-                throw GLTFException("MeshPrimitives with mode MESH_LINES has non-multiple-of-2 indices.");
-            }
-            return rawIndices;
-        case MESH_LINE_STRIP:
-            return GetSegmentsFromLineStrip(rawIndices);
-        case MESH_LINE_LOOP:
-            return GetSegmentsFromLineLoop(rawIndices);
-        default:
-            throw GLTFException("Invalid mesh mode for triangulation " + std::to_string(meshMode));
-        }
-    }
-
-    std::vector<uint16_t> GetOrCreateIndices16(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-    {
-        if (doc.accessors.Has(meshPrimitive.indicesAccessorId))
-        {
-            const auto& indicesAccessor = doc.accessors.Get(meshPrimitive.indicesAccessorId);
-            return MeshPrimitiveUtils::GetIndices16(doc, reader, indicesAccessor);
-        }
-        else
-        {
-            size_t vertexCount = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_POSITION)).count;
-
-            if (vertexCount > std::numeric_limits<uint16_t>::max())
-            {
-                throw GLTFException("Cannot generate 16-bit indices for MeshPrimitive with " + std::to_string(vertexCount) + " vertices.");
-            }
-
-            std::vector<uint16_t> rawIndices(vertexCount);
-            std::iota(rawIndices.begin(), rawIndices.end(), static_cast<uint16_t>(0U));
-            return rawIndices;
-        }
-    }
-
-    std::vector<uint32_t> GetOrCreateIndices32(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-    {
-        if (doc.accessors.Has(meshPrimitive.indicesAccessorId))
-        {
-            const auto& indicesAccessor = doc.accessors.Get(meshPrimitive.indicesAccessorId);
-            return MeshPrimitiveUtils::GetIndices32(doc, reader, indicesAccessor);
-        }
-        else
-        {
-            size_t vertexCount = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_POSITION)).count;
-
-            std::vector<uint32_t> rawIndices(vertexCount);
-            std::iota(rawIndices.begin(), rawIndices.end(), static_cast<uint32_t>(0U));
-            return rawIndices;
-        }
-    }
-
-    template<typename T>
-    std::vector<T> ReconstructTriangleStripIndexing(const T* indices, size_t indexCount)
-    {
-        if (indexCount % 3 != 0)
-        {
-            throw GLTFException("Input triangulated triangle strip has non-multiple-of-3 indices.");
-        }
-
-        if (indexCount < 3)
-        {
-            throw GLTFException("Input triangulated triangle strip has fewer than 3 indices.");
-        }
-
-        std::vector<T> result;
-        result.reserve(2 + indexCount / 3);
-
-        result.push_back(indices[0]);
-        result.push_back(indices[1]);
-
-        for (size_t i = 2; i < indexCount; i += 3)
-        {
-            if (i % 2 == 0)
-            {
-                result.push_back(indices[i]);
-            }
-            else
-            {
-                result.push_back(indices[i - 1]);
-            }
-        }
-
-        return result;
-    }
-
-    template<typename T>
-    std::vector<T> ReconstructTriangleFanIndexing(const T* indices, size_t indexCount)
-    {
-        if (indexCount % 3 != 0)
-        {
-            throw GLTFException("Input triangulated triangle fan has non-multiple-of-3 indices.");
-        }
-
-        if (indexCount < 3)
-        {
-            throw GLTFException("Input triangulated triangle fan has fewer than 3 indices.");
-        }
-
-        std::vector<T> result;
-        result.reserve(2 + indexCount / 3);
-
-        result.push_back(indices[0]);
-        result.push_back(indices[1]);
-
-        for (size_t i = 2; i < indexCount; i += 3)
-        {
-            result.push_back(indices[i]);
-        }
-
-        return result;
-    }
-
-    template<typename T>
-    std::vector<T> ReverseTriangulateIndices(const T* indices, size_t indexCount, MeshMode mode)
-    {
-        if (mode == MeshMode::MESH_TRIANGLE_STRIP)
-        {
-            return ReconstructTriangleStripIndexing(indices, indexCount);
-        }
-        else if (mode == MeshMode::MESH_TRIANGLE_FAN)
-        {
-            return ReconstructTriangleFanIndexing(indices, indexCount);
-        }
-        else
-        {
-            throw GLTFException("Non-triangulated mesh mode specificed.");
-        }
-    }
-
-    template<typename T>
-    std::vector<T> ReconstructLineLoopIndexing(const T* indices, size_t indexCount)
-    {
-        if (indexCount % 2 != 0)
-        {
-            throw GLTFException("Input segmented line has non-multiple-of-2 indices.");
-        }
-
-        std::vector<T> result;
-        result.reserve(indexCount / 2);
-
-        for (size_t i = 0; i < indexCount; i += 2)
-        {
-            result.push_back(indices[i]);
-        }
-
-        return result;
-    }
-
-    template<typename T>
-    std::vector<T> ReconstructLineStripIndexing(const T* indices, size_t indexCount)
-    {
-        auto result = ReconstructLineLoopIndexing(indices, indexCount);
-        result.push_back(indices[indexCount - 1]);
-        return result;
-    }
-
-    template<typename T>
-    std::vector<T> ReverseSegmentIndices(const T* indices, size_t indexCount, MeshMode mode)
-    {
-        if (mode == MeshMode::MESH_LINE_STRIP)
-        {
-            return ReconstructLineStripIndexing(indices, indexCount);
-        }
-        else if (mode == MeshMode::MESH_LINE_LOOP)
-        {
-            return ReconstructLineLoopIndexing(indices, indexCount);
-        }
-        else
-        {
-            throw GLTFException("Non-segmented mesh mode specificed.");
-        }
-    }
-}
-
-std::vector<uint16_t> MeshPrimitiveUtils::GetIndices16(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-{
-    if (accessor.type != TYPE_SCALAR)
-    {
-        throw GLTFException("Invalid type for indices accessor " + accessor.id);
-    }
-
-    switch (accessor.componentType)
-    {
-    case COMPONENT_UNSIGNED_BYTE:
-        return ReadIndices<uint8_t, uint16_t>(doc, reader, accessor);
-
-    case COMPONENT_UNSIGNED_SHORT:
-        return reader.ReadBinaryData<uint16_t>(doc, accessor);
-
-    case COMPONENT_UNSIGNED_INT:
-        throw GLTFException("Cannot convert 32-bit indices to 16-bit");
-
-    default:
-        throw GLTFException("Invalid componentType for indices accessor " + accessor.id);
-    }
-}
-
-std::vector<uint16_t> MeshPrimitiveUtils::GetIndices16(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.indicesAccessorId);
-    return GetIndices16(doc, reader, accessor);
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::GetIndices32(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-{
-    if (accessor.type != TYPE_SCALAR)
-    {
-        throw GLTFException("Invalid type for indices accessor " + accessor.id);
-    }
-
-    switch (accessor.componentType)
-    {
-    case COMPONENT_UNSIGNED_BYTE:
-        return ReadIndices<uint8_t, uint32_t>(doc, reader, accessor);
-
-    case COMPONENT_UNSIGNED_SHORT:
-        return ReadIndices<uint16_t, uint32_t>(doc, reader, accessor);
-
-    case COMPONENT_UNSIGNED_INT:
-        return reader.ReadBinaryData<uint32_t>(doc, accessor);
-
-    default:
-        throw GLTFException("Invalid componentType for indices accessor " + accessor.id);
-    }
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::GetIndices32(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.indicesAccessorId);
-    return GetIndices32(doc, reader, accessor);
-}
-
-std::vector<uint16_t> MeshPrimitiveUtils::GetTriangulatedIndices16(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    return GetTriangulatedIndices<uint16_t>(meshPrimitive.mode, GetOrCreateIndices16(doc, reader, meshPrimitive));
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::GetTriangulatedIndices32(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    return GetTriangulatedIndices<uint32_t>(meshPrimitive.mode, GetOrCreateIndices32(doc, reader, meshPrimitive));
-}
-
-std::vector<uint16_t> MeshPrimitiveUtils::GetSegmentedIndices16(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-
-    return GetSegmentedIndices<uint16_t>(meshPrimitive.mode, GetOrCreateIndices16(doc, reader, meshPrimitive));
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::GetSegmentedIndices32(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    return GetSegmentedIndices<uint32_t>(meshPrimitive.mode, GetOrCreateIndices32(doc, reader, meshPrimitive));
-}
-
-// Positions
-std::vector<float> MeshPrimitiveUtils::GetPositions(const Document& doc, const GLTFResourceReader& reader, const Accessor& positionsAccessor)
-{
-    if (positionsAccessor.type != TYPE_VEC3)
-    {
-        throw GLTFException("Invalid type for positions accessor " + positionsAccessor.id);
-    }
-
-    if (positionsAccessor.componentType != COMPONENT_FLOAT)
-    {
-        throw GLTFException("Invalid component type for positions accessor " + positionsAccessor.id);
-    }
-
-    return reader.ReadFloatData(doc, positionsAccessor);
-}
-
-std::vector<float> MeshPrimitiveUtils::GetPositions(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& positionsAccessor = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_POSITION));
-    return GetPositions(doc, reader, positionsAccessor);
-}
-
-std::vector<float> MeshPrimitiveUtils::GetPositions(const Document& doc, const GLTFResourceReader& reader, const MorphTarget& morphTarget)
-{
-    const auto& positionsAccessor = doc.accessors.Get(morphTarget.positionsAccessorId);
-    return GetPositions(doc, reader, positionsAccessor);
-}
-
-// Normals
-std::vector<float> MeshPrimitiveUtils::GetNormals(const Document& doc, const GLTFResourceReader& reader, const Accessor& normalsAccessor)
-{
-    if (normalsAccessor.type != TYPE_VEC3)
-    {
-        throw GLTFException("Invalid type for normals accessor " + normalsAccessor.id);
-    }
-
-    if (normalsAccessor.componentType != COMPONENT_FLOAT)
-    {
-        throw GLTFException("Invalid component type for normals accessor " + normalsAccessor.id);
-    }
-
-    return reader.ReadFloatData(doc, normalsAccessor);
-}
-
-std::vector<float> MeshPrimitiveUtils::GetNormals(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_NORMAL));
-    return GetNormals(doc, reader, accessor);
-}
-
-std::vector<float> MeshPrimitiveUtils::GetNormals(const Document& doc, const GLTFResourceReader& reader, const MorphTarget& morphTarget)
-{
-    const auto& accessor = doc.accessors.Get(morphTarget.normalsAccessorId);
-    return GetNormals(doc, reader, accessor);
-}
-
-// Tangents
-std::vector<float> MeshPrimitiveUtils::GetTangents(const Document& doc, const GLTFResourceReader& reader, const Accessor& tangentsAccessor)
-{
-    if (tangentsAccessor.type != TYPE_VEC4)
-    {
-        throw GLTFException("Invalid type for tangents accessor " + tangentsAccessor.id);
-    }
-
-    if (tangentsAccessor.componentType != COMPONENT_FLOAT)
-    {
-        throw GLTFException("Invalid component type for tangents accessor " + tangentsAccessor.id);
-    }
-
-    return reader.ReadFloatData(doc, tangentsAccessor);
-}
-
-std::vector<float> MeshPrimitiveUtils::GetTangents(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_TANGENT));
-    return GetTangents(doc, reader, accessor);
-}
-
-// Morph Target Tangents (which have a different accessor type than base mesh tangents)
-std::vector<float> MeshPrimitiveUtils::GetMorphTangents(const Document& doc, const GLTFResourceReader& reader, const Accessor& tangentsAccessor)
-{
-    if (tangentsAccessor.type != TYPE_VEC3)
-    {
-        throw GLTFException("Invalid type for tangents accessor " + tangentsAccessor.id);
-    }
-
-    if (tangentsAccessor.componentType != COMPONENT_FLOAT)
-    {
-        throw GLTFException("Invalid component type for tangents accessor " + tangentsAccessor.id);
-    }
-
-    return reader.ReadFloatData(doc, tangentsAccessor);
-}
-
-std::vector<float> MeshPrimitiveUtils::GetTangents(const Document& doc, const GLTFResourceReader& reader, const MorphTarget& morphTarget)
-{
-    const auto& accessor = doc.accessors.Get(morphTarget.tangentsAccessorId);
-    return GetMorphTangents(doc, reader, accessor);
-}
-
-// Texcoords
-std::vector<float> MeshPrimitiveUtils::GetTexCoords(const Document& doc, const GLTFResourceReader& reader, const Accessor& accessor)
-{
-    if (accessor.type != TYPE_VEC2)
-    {
-        throw GLTFException("Invalid type for texcoords accessor " + accessor.id);
-    }
-
-    if (accessor.componentType != COMPONENT_FLOAT && accessor.componentType != COMPONENT_UNSIGNED_BYTE && accessor.componentType != COMPONENT_UNSIGNED_SHORT)
-    {
-        throw GLTFException("Invalid component type for texcoords accessor " + accessor.id);
-    }
-
-    return reader.ReadFloatData(doc, accessor);
-}
-
-std::vector<float> MeshPrimitiveUtils::GetTexCoords_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_TEXCOORD_0));
-    return GetTexCoords(doc, reader, accessor);
-}
-
-std::vector<float> MeshPrimitiveUtils::GetTexCoords_1(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_TEXCOORD_1));
-    return GetTexCoords(doc, reader, accessor);
-}
-
-// Colors
-std::vector<uint32_t> MeshPrimitiveUtils::GetColors(const Document& doc, const GLTFResourceReader& reader, const Accessor& colorsAccessor)
-{
-    if (colorsAccessor.type != TYPE_VEC4 && colorsAccessor.type != TYPE_VEC3)
-    {
-        throw GLTFException("Invalid type for color accessor " + colorsAccessor.id);
-    }
-
-    if (colorsAccessor.componentType != COMPONENT_FLOAT && colorsAccessor.componentType != COMPONENT_UNSIGNED_BYTE && colorsAccessor.componentType != COMPONENT_UNSIGNED_SHORT)
-    {
-        throw GLTFException("Invalid component type for colors accessor " + colorsAccessor.id);
-    }
-
-    if (colorsAccessor.componentType == COMPONENT_UNSIGNED_BYTE)
-    {
-        std::vector<uint8_t> colorData = reader.ReadBinaryData<uint8_t>(doc, colorsAccessor);
-
-        if (colorsAccessor.type == TYPE_VEC4)
-            return PackColorsRGBA(colorData);
-        else
-            return PackColorsRGB(colorData);
-    }
-    else
-    {
-        std::vector<float> colorData = reader.ReadFloatData(doc, colorsAccessor);
-
-        if (colorsAccessor.type == TYPE_VEC4)
-            return PackColorsRGBA(colorData);
-        else
-            return PackColorsRGB(colorData);
-    }
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::GetColors_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_COLOR_0));
-    return GetColors(doc, reader, accessor);
-}
-
-// Joints
-std::vector<uint32_t> MeshPrimitiveUtils::GetJointIndices32(const Document& doc, const GLTFResourceReader& reader, const Accessor& jointsAccessor)
-{
-    if (jointsAccessor.type != TYPE_VEC4)
-    {
-        throw GLTFException("Invalid type for joints accessor " + jointsAccessor.id);
-    }
-
-    switch (jointsAccessor.componentType)
-    {
-    case COMPONENT_UNSIGNED_BYTE:
-        return ReadJoints32(doc, reader, jointsAccessor);
-
-    case COMPONENT_UNSIGNED_SHORT:
-        throw GLTFException("Cannot pack 4 x 16-bit indices into 32-bits");
-
-    default:
-        throw GLTFException("Invalid componentType for joints accessor " + jointsAccessor.id);
-    }
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::GetJointIndices32_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_JOINTS_0));
-    return GetJointIndices32(doc, reader, accessor);
-}
-
-std::vector<uint64_t> MeshPrimitiveUtils::GetJointIndices64(const Document& doc, const GLTFResourceReader& reader, const Accessor& jointsAccessor)
-{
-    if (jointsAccessor.type != TYPE_VEC4)
-    {
-        throw GLTFException("Invalid type for joints accessor " + jointsAccessor.id);
-    }
-
-    switch (jointsAccessor.componentType)
-    {
-    case COMPONENT_UNSIGNED_BYTE:
-        return ReadJoints64<uint8_t>(doc, reader, jointsAccessor);
-
-    case COMPONENT_UNSIGNED_SHORT:
-        return ReadJoints64<uint16_t>(doc, reader, jointsAccessor);
-
-    default:
-        throw GLTFException("Invalid componentType for joints accessor " + jointsAccessor.id);
-    }
-}
-
-std::vector<uint64_t> MeshPrimitiveUtils::GetJointIndices64_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_JOINTS_0));
-    return GetJointIndices64(doc, reader, accessor);
-}
-
-// Weights
-std::vector<uint32_t> MeshPrimitiveUtils::GetJointWeights32(const Document& doc, const GLTFResourceReader& reader, const Accessor& weightsAccessor)
-{
-    if (weightsAccessor.type != TYPE_VEC4)
-    {
-        throw GLTFException("Invalid type for weights accessor " + weightsAccessor.id);
-    }
-
-    if (weightsAccessor.componentType != COMPONENT_FLOAT && weightsAccessor.componentType != COMPONENT_UNSIGNED_BYTE && weightsAccessor.componentType != COMPONENT_UNSIGNED_SHORT)
-    {
-        throw GLTFException("Invalid component type for weights accessor " + weightsAccessor.id);
-    }
-
-    if (weightsAccessor.componentType == COMPONENT_UNSIGNED_BYTE)
-    {
-        std::vector<uint8_t> weightsData = reader.ReadBinaryData<uint8_t>(doc, weightsAccessor);
-
-        return PackWeights32(weightsData);
-    }
-    else
-    {
-        std::vector<float> weightsData = reader.ReadFloatData(doc, weightsAccessor);
-
-        return PackWeights32(weightsData);
-    }
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::GetJointWeights32_0(const Document& doc, const GLTFResourceReader& reader, const MeshPrimitive& meshPrimitive)
-{
-    const auto& accessor = doc.accessors.Get(meshPrimitive.GetAttributeAccessorId(ACCESSOR_WEIGHTS_0));
-    return GetJointWeights32(doc, reader, accessor);
-}
-
-std::vector<uint16_t> MeshPrimitiveUtils::ReverseTriangulateIndices16(const uint16_t* indices, size_t indexCount, MeshMode mode)
-{
-    return ReverseTriangulateIndices(indices, indexCount, mode);
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::ReverseTriangulateIndices32(const uint32_t* indices, size_t indexCount, MeshMode mode)
-{
-    return ReverseTriangulateIndices(indices, indexCount, mode);
-}
-
-std::vector<uint16_t> MeshPrimitiveUtils::ReverseTriangulateIndices16(const std::vector<uint16_t>& indices, MeshMode mode)
-{
-    return ReverseTriangulateIndices(indices.data(), indices.size(), mode);
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::ReverseTriangulateIndices32(const std::vector<uint32_t>& indices, MeshMode mode)
-{
-    return ReverseTriangulateIndices(indices.data(), indices.size(), mode);
-}
-
-std::vector<uint16_t> MeshPrimitiveUtils::ReverseSegmentIndices16(const uint16_t* indices, size_t indexCount, MeshMode mode)
-{
-    return ReverseSegmentIndices(indices, indexCount, mode);
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::ReverseSegmentIndices32(const uint32_t* indices, size_t indexCount, MeshMode mode)
-{
-    return ReverseSegmentIndices(indices, indexCount, mode);
-}
-
-std::vector<uint16_t> MeshPrimitiveUtils::ReverseSegmentIndices16(const std::vector<uint16_t>& indices, MeshMode mode)
-{
-    return ReverseSegmentIndices(indices.data(), indices.size(), mode);
-}
-
-std::vector<uint32_t> MeshPrimitiveUtils::ReverseSegmentIndices32(const std::vector<uint32_t>& indices, MeshMode mode)
-{
-    return ReverseSegmentIndices(indices.data(), indices.size(), mode);
-}
diff --git a/thirdparty/GLTFSDK/Source/MicrosoftGeneratorVersion.cpp b/thirdparty/GLTFSDK/Source/MicrosoftGeneratorVersion.cpp
deleted file mode 100644
index 2de55c1..0000000
--- a/thirdparty/GLTFSDK/Source/MicrosoftGeneratorVersion.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/MicrosoftGeneratorVersion.h>
-
-#include <GLTFSDK/Constants.h>
-
-#include <regex>
-
-using namespace Microsoft::glTF;
-
-MicrosoftGeneratorVersion::MicrosoftGeneratorVersion(const std::string& version) :
-    m_version(std::make_tuple(0, 0, 0, 0)),
-    m_prereleaseVersion(0),
-    m_isPrerelease(false),
-    m_isMicrosoftGenerator(false)
-{
-    if (!version.empty())
-    {
-        std::string msftGeneratorName(MSFT_GLTF_EXPORTER_NAME);
-
-        //check whether the version name starts with the generator name
-        auto versionLocal(version);
-        if (versionLocal.size() >= msftGeneratorName.size() &&
-            std::equal(msftGeneratorName.begin(), msftGeneratorName.end(), versionLocal.begin()))
-        {
-            m_isMicrosoftGenerator = true;
-            versionLocal = versionLocal.substr(msftGeneratorName.size());
-        }
-
-        unsigned long major = 0, minor = 0, revision = 0, build = 0, prerelease = 0;
-
-        const std::regex regex3("(\\d+)(\\.)(\\d+)(\\.)(\\d+)");
-        const std::regex regex4("(\\d+)(\\.)(\\d+)(\\.)(\\d+)(\\.)(\\d+)");
-        const std::regex regex3beta("(\\d+)(\\.)(\\d+)(\\.)(\\d+)-b(\\d+)");
-        const std::regex regex4beta("(\\d+)(\\.)(\\d+)(\\.)(\\d+)(\\.)(\\d+)-b(\\d+)");
-
-        std::smatch match;
-        bool didMatch = true;
-        if (std::regex_search(versionLocal, match, regex4beta))
-        {
-            build = std::stoul(match[7]);
-            prerelease = std::stoul(match[8]);
-            m_isPrerelease = true;
-        }
-        else if (std::regex_search(versionLocal, match, regex3beta))
-        {
-            prerelease = std::stoul(match[6]);
-            m_isPrerelease = true;
-        }
-        else if (std::regex_search(versionLocal, match, regex4))
-        {
-            build = std::stoul(match[7]);
-        }
-        else if (!std::regex_search(versionLocal, match, regex3))
-        {
-            didMatch = false;
-        }
-
-        //parse the commmon components (major.minor.revision)
-        if (didMatch)
-        {
-            major = std::stoul(match[1]);
-            minor = std::stoul(match[3]);
-            revision = std::stoul(match[5]);
-            m_version = std::make_tuple(major, minor, revision, build);
-            m_prereleaseVersion = prerelease;
-        }
-    }
-}
-
-bool MicrosoftGeneratorVersion::operator==(const MicrosoftGeneratorVersion& other) const
-{
-    return m_version == other.m_version
-        && m_isPrerelease == other.m_isPrerelease
-        && m_prereleaseVersion == other.m_prereleaseVersion;
-}
-
-bool MicrosoftGeneratorVersion::operator<(const MicrosoftGeneratorVersion& other) const
-{
-    if (m_isPrerelease)
-    {
-        if (other.m_isPrerelease && m_version == other.m_version)
-        {
-            return m_prereleaseVersion < other.m_prereleaseVersion;
-        }
-        return m_version <= other.m_version;
-    }
-
-    if (other.m_isPrerelease)
-    {
-        return m_version < other.m_version;
-    }
-
-    return (m_version < other.m_version);
-}
-
-bool MicrosoftGeneratorVersion::operator>(const MicrosoftGeneratorVersion& other) const
-{
-    return other.operator<(*this);
-}
-
-bool MicrosoftGeneratorVersion::operator<=(const MicrosoftGeneratorVersion& other) const
-{
-    return operator<(other) || operator==(other);
-}
-
-bool MicrosoftGeneratorVersion::operator>=(const MicrosoftGeneratorVersion& other) const
-{
-    return operator>(other) || operator==(other);
-}
-
-bool MicrosoftGeneratorVersion::operator!=(const MicrosoftGeneratorVersion& other) const
-{
-    return !operator==(other);
-}
-
-bool MicrosoftGeneratorVersion::IsMicrosoftGenerator() const
-{
-    return m_isMicrosoftGenerator;
-}
-
-bool MicrosoftGeneratorVersion::IsPrerelease() const
-{
-    return m_isPrerelease;
-}
\ No newline at end of file
diff --git a/thirdparty/GLTFSDK/Source/PBRUtils.cpp b/thirdparty/GLTFSDK/Source/PBRUtils.cpp
deleted file mode 100644
index bf2fd55..0000000
--- a/thirdparty/GLTFSDK/Source/PBRUtils.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/PBRUtils.h>
-
-using namespace Microsoft::glTF;
-
-// https://bghgary.github.io/glTF/convert-between-workflows-bjs/js/babylon.pbrUtilities.js
-float Detail::SolveMetallic(float dielectricSpecular, float diffuse, float specular, float oneMinusSpecularStrength)
-{
-    if (specular <= dielectricSpecular)
-    {
-        return 0.0f;
-    }
-
-    const float a = dielectricSpecular;
-    const float b = diffuse * oneMinusSpecularStrength / (1.0f - dielectricSpecular) + specular - 2.0f * dielectricSpecular;
-    const float c = dielectricSpecular - specular;
-    const float D = b * b - 4.0f * a * c;
-    return Math::Clamp((-b + std::sqrt(D)) / (2.0f * a), 0.0f, 1.0f);
-}
-
-namespace Microsoft
-{
-    namespace glTF
-    {
-        constexpr float R(const Color3& color)
-        {
-            return color.r;
-        }
-
-        constexpr float G(const Color3& color)
-        {
-            return color.g;
-        }
-
-        constexpr float B(const Color3& color)
-        {
-            return color.b;
-        }
-    }
-}
-
-MetallicRoughnessValue Microsoft::glTF::SGToMR(const SpecularGlossinessValue& sg)
-{
-    return SGToMR<Color3>(sg);
-}
-
-SpecularGlossinessValue Microsoft::glTF::MRToSG(const MetallicRoughnessValue& mr)
-{
-    return MRToSG<Color3>(mr);
-}
diff --git a/thirdparty/GLTFSDK/Source/ResourceWriter.cpp b/thirdparty/GLTFSDK/Source/ResourceWriter.cpp
deleted file mode 100644
index 943de06..0000000
--- a/thirdparty/GLTFSDK/Source/ResourceWriter.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/ResourceWriter.h>
-
-using namespace Microsoft::glTF;
-
-ResourceWriter::ResourceWriter(std::unique_ptr<IStreamWriterCache> streamWriterCache) : m_streamWriterCache(std::move(streamWriterCache))
-{
-}
-
-ResourceWriter::~ResourceWriter() = default;
-
-void ResourceWriter::Write(const BufferView& bufferView, const void* data)
-{
-    WriteImpl(bufferView, data, bufferView.byteOffset, bufferView.byteLength);
-}
-
-void ResourceWriter::Write(const BufferView& bufferView, const void* data, const Accessor& accessor)
-{
-    if (accessor.bufferViewId != bufferView.id)
-    {
-        throw InvalidGLTFException("accessor.bufferViewId does not match bufferView.id");
-    }
-
-    const auto componentTypeSize = Accessor::GetComponentTypeSize(accessor.componentType);
-
-    // From the glTF 2.0 spec: the offset of an accessor into a bufferView (accessor.byteOffset) must be a multiple of the size of the accessor's component type
-    if (accessor.byteOffset % componentTypeSize)
-    {
-        throw InvalidGLTFException("accessor.byteOffset must be a multiple of the accessor's component type size");
-    }
-
-    // From the glTF 2.0 spec: the offset of an accessor into a buffer (accessor.byteOffset + bufferView.byteOffset) must be a multiple of the size of the accessor's component type
-    if ((accessor.byteOffset + bufferView.byteOffset) % componentTypeSize)
-    {
-        throw InvalidGLTFException("accessor.byteOffset + bufferView.byteOffset must be a multiple of the accessor's component type size");
-    }
-
-    const auto accessorByteLength = accessor.GetByteLength();
-
-    // Ensure there is enough room in the BufferView for the accessor's data
-    if (bufferView.byteLength < accessor.byteOffset + accessorByteLength)
-    {
-        throw InvalidGLTFException("accessor offset and byte length exceed the buffer view's byte length");
-    }
-
-    WriteImpl(bufferView, data, bufferView.byteOffset + accessor.byteOffset, accessorByteLength);
-}
-
-void ResourceWriter::WriteExternal(const std::string& uri, const void* data, size_t byteLength) const
-{
-    if (auto stream = m_streamWriterCache->Get(uri))
-    {
-        StreamUtils::WriteBinary(*stream, data, byteLength);
-    }
-}
-
-void ResourceWriter::WriteExternal(const std::string& uri, const std::string& data) const
-{
-    WriteExternal(uri, data.c_str(), data.length());
-}
-
-void ResourceWriter::WriteImpl(const BufferView& bufferView, const void* data, std::streamoff totalOffset, size_t totalByteLength)
-{
-    // TODO: vertex attributes must be aligned to 4-byte boundaries inside a bufferView (accessor.byteOffset and bufferView.byteStride must be multiples of 4)
-
-    if (auto bufferStream = GetBufferStream(bufferView.bufferId))
-    {
-        const auto bufferOffset = GetBufferOffset(bufferView.bufferId);
-
-        if (totalOffset < bufferOffset)
-        {
-            throw InvalidGLTFException("Stream 'put' pointer is already ahead of specified offset");
-        }
-        else if (totalOffset > bufferOffset)
-        {
-            const auto padSize = static_cast<size_t>(totalOffset - bufferOffset);
-            const auto padData = std::make_unique<char[]>(padSize);
-
-            StreamUtils::WriteBinary(*bufferStream, padData.get(), padSize);
-        }
-
-        SetBufferOffset(bufferView.bufferId, totalOffset);
-
-        if (StreamUtils::WriteBinary(*bufferStream, data, totalByteLength) != totalByteLength)
-        {
-            throw InvalidGLTFException("An unexpected number of bytes were output to the stream");
-        }
-
-        SetBufferOffset(bufferView.bufferId, totalOffset + totalByteLength);
-    }
-}
diff --git a/thirdparty/GLTFSDK/Source/Schema.cpp b/thirdparty/GLTFSDK/Source/Schema.cpp
deleted file mode 100644
index e09f372..0000000
--- a/thirdparty/GLTFSDK/Source/Schema.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/Schema.h>
-#include <GLTFSDK/SchemaValidation.h>
-#include <GLTFSDK/Exceptions.h>
-
-#include "SchemaJson.h" // Auto-generated header, don't include in any other translation units to avoid linker errors
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    const std::unordered_map<std::string, SchemaFlags> schemaFlagMap = {
-        { SCHEMA_URI_GLTF, SchemaFlags::DisableSchemaRoot },
-        { SCHEMA_URI_GLTFID, SchemaFlags::DisableSchemaId },
-        { SCHEMA_URI_GLTFCHILDOFROOTPROPERTY, SchemaFlags::DisableSchemaChildOfRoot },
-        { SCHEMA_URI_GLTFPROPERTY, SchemaFlags::DisableSchemaProperty },
-        { SCHEMA_URI_BUFFER, SchemaFlags::DisableSchemaBuffer },
-        { SCHEMA_URI_BUFFERVIEW, SchemaFlags::DisableSchemaBufferView },
-        { SCHEMA_URI_ACCESSOR, SchemaFlags::DisableSchemaAccessor },
-        { SCHEMA_URI_ACCESSORSPARSE, SchemaFlags::DisableSchemaAccessorSparse },
-        { SCHEMA_URI_ACCESSORSPARSEVALUES, SchemaFlags::DisableSchemaAccessorSparseValues },
-        { SCHEMA_URI_ACCESSORSPARSEINDICES, SchemaFlags::DisableSchemaAccessorSparseIndices },
-        { SCHEMA_URI_ASSET, SchemaFlags::DisableSchemaAsset },
-        { SCHEMA_URI_SCENE, SchemaFlags::DisableSchemaScene },
-        { SCHEMA_URI_NODE, SchemaFlags::DisableSchemaNode },
-        { SCHEMA_URI_MESH, SchemaFlags::DisableSchemaMesh },
-        { SCHEMA_URI_MESHPRIMITIVE, SchemaFlags::DisableSchemaMeshPrimitive },
-        { SCHEMA_URI_SKIN, SchemaFlags::DisableSchemaSkin },
-        { SCHEMA_URI_CAMERA, SchemaFlags::DisableSchemaCamera },
-        { SCHEMA_URI_CAMERAORTHOGRAPHIC, SchemaFlags::DisableSchemaCameraOrthographic },
-        { SCHEMA_URI_CAMERAPERSPECTIVE, SchemaFlags::DisableSchemaCameraPerspective },
-        { SCHEMA_URI_MATERIAL, SchemaFlags::DisableSchemaMaterial },
-        { SCHEMA_URI_MATERIALNORMALTEXTUREINFO, SchemaFlags::DisableSchemaMaterialNormalTextureInfo },
-        { SCHEMA_URI_MATERIALOCCLUSIONTEXTUREINFO, SchemaFlags::DisableSchemaMaterialOcclusionTextureInfo },
-        { SCHEMA_URI_MATERIALPBRMETALLICROUGHNESS, SchemaFlags::DisableSchemaMaterialPBRMetallicRoughness },
-        { SCHEMA_URI_TEXTURE, SchemaFlags::DisableSchemaTexture },
-        { SCHEMA_URI_TEXTUREINFO, SchemaFlags::DisableSchemaTextureInfo },
-        { SCHEMA_URI_IMAGE, SchemaFlags::DisableSchemaImage },
-        { SCHEMA_URI_SAMPLER, SchemaFlags::DisableSchemaSampler },
-        { SCHEMA_URI_ANIMATION, SchemaFlags::DisableSchemaAnimation },
-        { SCHEMA_URI_ANIMATIONSAMPLER, SchemaFlags::DisableSchemaAnimationSampler },
-        { SCHEMA_URI_ANIMATIONCHANNEL, SchemaFlags::DisableSchemaAnimationChannel },
-        { SCHEMA_URI_ANIMATIONCHANNELTARGET, SchemaFlags::DisableSchemaAnimationChannelTarget },
-        { SCHEMA_URI_EXTENSION, SchemaFlags::DisableSchemaExtension },
-        { SCHEMA_URI_EXTRAS, SchemaFlags::DisableSchemaExtras }
-    };
-
-    bool HasSchemaFlag(SchemaFlags flag, SchemaFlags flags)
-    {
-        return (flags & flag) == flag;
-    }
-
-    class DefaultSchemaLocator : public ISchemaLocator
-    {
-    public:
-        DefaultSchemaLocator(SchemaFlags schemaFlags) : schemaFlags(schemaFlags)
-        {
-        }
-
-        const char* GetSchemaContent(const std::string& uri) const override
-        {
-            auto itFlag = schemaFlagMap.find(uri);
-
-            // If the schema for this uri is disabled via the relevant SchemaFlags enum value then return an
-            // empty object as empty objects are a completely valid schema that will accept any valid JSON.
-            if (itFlag != schemaFlagMap.end() && HasSchemaFlag(itFlag->second, schemaFlags))
-            {
-                return "{}";
-            }
-
-            auto itSchema = SchemaJson::GLTF_SCHEMA_MAP.find(uri);
-
-            if (itSchema == SchemaJson::GLTF_SCHEMA_MAP.end())
-            {
-                throw GLTFException("Unknown Schema uri " + uri);
-            }
-
-            return itSchema->second.c_str();
-        }
-
-    private:
-        const SchemaFlags schemaFlags;
-    };
-}
-
-// Microsoft::glTF namespace function definitions
-
-const std::unordered_map<std::string, std::string>& Microsoft::glTF::GetDefaultSchemaUriMap()
-{
-    return SchemaJson::GLTF_SCHEMA_MAP;
-}
-
-std::unique_ptr<const ISchemaLocator> Microsoft::glTF::GetDefaultSchemaLocator(SchemaFlags schemaFlags)
-{
-    return std::make_unique<const DefaultSchemaLocator>(schemaFlags);
-}
-
-// SchemaFlags operator definitions
-
-SchemaFlags Microsoft::glTF::operator|(SchemaFlags lhs, SchemaFlags rhs)
-{
-    const auto result =
-        static_cast<std::underlying_type_t<SchemaFlags>>(lhs) |
-        static_cast<std::underlying_type_t<SchemaFlags>>(rhs);
-
-    return static_cast<SchemaFlags>(result);
-}
-
-SchemaFlags& Microsoft::glTF::operator|=(SchemaFlags& lhs, SchemaFlags rhs)
-{
-    lhs = lhs | rhs;
-    return lhs;
-}
-
-SchemaFlags Microsoft::glTF::operator&(SchemaFlags lhs, SchemaFlags rhs)
-{
-    const auto result =
-        static_cast<std::underlying_type_t<SchemaFlags>>(lhs) &
-        static_cast<std::underlying_type_t<SchemaFlags>>(rhs);
-
-    return static_cast<SchemaFlags>(result);
-}
-
-SchemaFlags& Microsoft::glTF::operator&=(SchemaFlags& lhs, SchemaFlags rhs)
-{
-    lhs = lhs & rhs;
-    return lhs;
-}
diff --git a/thirdparty/GLTFSDK/Source/SchemaValidation.cpp b/thirdparty/GLTFSDK/Source/SchemaValidation.cpp
deleted file mode 100644
index 3ca2988..0000000
--- a/thirdparty/GLTFSDK/Source/SchemaValidation.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/SchemaValidation.h>
-#include <GLTFSDK/Exceptions.h>
-
-#include <unordered_map>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    class RemoteSchemaDocumentProvider : public rapidjson::IRemoteSchemaDocumentProvider
-    {
-    public:
-        RemoteSchemaDocumentProvider(std::unique_ptr<const ISchemaLocator> schemaLocator) : schemaLocator(std::move(schemaLocator))
-        {
-            assert(this->schemaLocator);
-        }
-
-        const rapidjson::SchemaDocument* GetRemoteDocument(const std::string& uri)
-        {
-            auto itDoc = schemaDocuments.find(uri);
-
-            if (itDoc != schemaDocuments.end())
-            {
-                return &(itDoc->second);
-            }
-
-            rapidjson::Document document;
-
-            if (document.Parse(schemaLocator->GetSchemaContent(uri)).HasParseError())
-            {
-                throw GLTFException("Schema document at " + uri + " is not valid JSON");
-            }
-
-            auto result = schemaDocuments.emplace(uri, rapidjson::SchemaDocument(document));
-            assert(result.second);
-            auto resultSchemaDoc = &(result.first->second);
-            assert(resultSchemaDoc);
-
-            return resultSchemaDoc;
-        }
-
-        const rapidjson::SchemaDocument* GetRemoteDocument(const char* uri, rapidjson::SizeType length) override
-        {
-            return GetRemoteDocument({ uri, length });
-        }
-
-        const std::unique_ptr<const ISchemaLocator> schemaLocator;
-
-    private:
-        std::unordered_map<std::string, rapidjson::SchemaDocument> schemaDocuments;
-    };
-}
-
-void Microsoft::glTF::ValidateDocumentAgainstSchema(const rapidjson::Document& document, const std::string& schemaUri, std::unique_ptr<const ISchemaLocator> schemaLocator)
-{
-    if (!schemaLocator)
-    {
-        throw GLTFException("ISchemaLocator instance must not be null");
-    }
-
-    RemoteSchemaDocumentProvider provider(std::move(schemaLocator));
-
-    if (auto* schemaDocument = provider.GetRemoteDocument(schemaUri))
-    {
-        rapidjson::SchemaValidator schemaValidator(*schemaDocument);
-
-        if (!document.Accept(schemaValidator))
-        {
-            rapidjson::StringBuffer sb;
-
-            const std::string schemaKeyword = schemaValidator.GetInvalidSchemaKeyword();
-            schemaValidator.GetInvalidDocumentPointer().StringifyUriFragment(sb);
-            const std::string schemaInvalid = sb.GetString();
-
-            throw ValidationException("Schema violation at " + schemaInvalid + " due to " + schemaKeyword);
-        }
-    }
-    else
-    {
-        throw GLTFException("Schema document at " + schemaUri + " could not be located");
-    }
-}
diff --git a/thirdparty/GLTFSDK/Source/Serialize.cpp b/thirdparty/GLTFSDK/Source/Serialize.cpp
deleted file mode 100644
index abc3aa8..0000000
--- a/thirdparty/GLTFSDK/Source/Serialize.cpp
+++ /dev/null
@@ -1,916 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/Serialize.h>
-
-#include <GLTFSDK/Document.h>
-#include <GLTFSDK/ExtensionHandlers.h>
-#include <GLTFSDK/GLTF.h>
-#include <GLTFSDK/RapidJsonUtils.h>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    std::string AccessorTypeToString(AccessorType type)
-    {
-        switch (type)
-        {
-        case TYPE_SCALAR:
-            return TYPE_NAME_SCALAR;
-        case TYPE_VEC2:
-            return TYPE_NAME_VEC2;
-        case TYPE_VEC3:
-            return TYPE_NAME_VEC3;
-        case TYPE_VEC4:
-            return TYPE_NAME_VEC4;
-        case TYPE_MAT2:
-            return TYPE_NAME_MAT2;
-        case TYPE_MAT3:
-            return TYPE_NAME_MAT3;
-        case TYPE_MAT4:
-            return TYPE_NAME_MAT4;
-        default:
-            return "";
-        }
-    }
-
-    std::string TargetPathToString(TargetPath target)
-    {
-        switch (target)
-        {
-        case TARGET_TRANSLATION:
-            return TARGETPATH_NAME_TRANSLATION;
-        case TARGET_ROTATION:
-            return TARGETPATH_NAME_ROTATION;
-        case TARGET_SCALE:
-            return TARGETPATH_NAME_SCALE;
-        case TARGET_WEIGHTS:
-            return TARGETPATH_NAME_WEIGHTS;
-        default:
-            return "";
-        }
-    }
-
-    std::string AlphaModeToString(AlphaMode mode)
-    {
-        switch (mode)
-        {
-        case ALPHA_OPAQUE:
-            return ALPHAMODE_NAME_OPAQUE;
-        case ALPHA_BLEND:
-            return ALPHAMODE_NAME_BLEND;
-        case ALPHA_MASK:
-            return ALPHAMODE_NAME_MASK;
-        default:
-            return "";
-        }
-    }
-
-    std::string InterpolationTypeToString(InterpolationType interpolationType)
-    {
-        switch (interpolationType)
-        {
-        case INTERPOLATION_LINEAR:
-            return INTERPOLATIONTYPE_NAME_LINEAR;
-        case INTERPOLATION_STEP:
-            return INTERPOLATIONTYPE_NAME_STEP;
-        case INTERPOLATION_CUBICSPLINE:
-            return INTERPOLATIONTYPE_NAME_CUBICSPLINE;
-        default:
-            return "";
-        }
-    }
-
-    void SerializePropertyExtensions(const Document& doc, const glTFProperty& property, rapidjson::Value& propertyValue, rapidjson::Document::AllocatorType& a, const ExtensionSerializer& extensionSerializer)
-    {
-        auto registeredExtensions = property.GetExtensions();
-
-        if (!property.extensions.empty() || !registeredExtensions.empty())
-        {
-            rapidjson::Value& extensions = RapidJsonUtils::FindOrAddMember(propertyValue, "extensions", a);
-
-            // Add registered extensions
-            for (const auto& extension : registeredExtensions)
-            {
-                const auto extensionPair = extensionSerializer.Serialize(extension, property, doc);
-
-                if (property.HasUnregisteredExtension(extensionPair.name))
-                {
-                    throw GLTFException("Registered extension '" + extensionPair.name + "' is also present as an unregistered extension.");
-                }
-
-                if (doc.extensionsUsed.find(extensionPair.name) == doc.extensionsUsed.end())
-                {
-                    throw GLTFException("Registered extension '" + extensionPair.name + "' is not present in extensionsUsed");
-                }
-
-                const auto d = RapidJsonUtils::CreateDocumentFromString(extensionPair.value);//TODO: validate the returned document against the extension schema!
-                rapidjson::Value v(rapidjson::kObjectType);
-                v.CopyFrom(d, a);
-                extensions.AddMember(RapidJsonUtils::ToStringValue(extensionPair.name, a), v, a);
-            }
-
-            // Add unregistered extensions
-            for (const auto& extension : property.extensions)
-            {
-                if (doc.extensionsUsed.find(extension.first) == doc.extensionsUsed.end())
-                {
-                    throw GLTFException("Unregistered extension '" + extension.first + "' is not present in extensionsUsed");
-                }
-
-                const auto d = RapidJsonUtils::CreateDocumentFromString(extension.second);//TODO: validate the returned document against the extension schema!
-                rapidjson::Value v(rapidjson::kObjectType);
-                v.CopyFrom(d, a);
-                extensions.AddMember(RapidJsonUtils::ToStringValue(extension.first, a), v, a);
-            }
-        }
-    }
-
-    void SerializePropertyExtras(const glTFProperty& property, rapidjson::Value& propertyValue, rapidjson::Document::AllocatorType& a)
-    {
-        if (!property.extras.empty())
-        {
-            auto d = RapidJsonUtils::CreateDocumentFromString(property.extras);
-            rapidjson::Value v(rapidjson::kObjectType);
-            v.CopyFrom(d, a);
-            propertyValue.AddMember("extras", v, a);
-        }
-    }
-
-    void SerializeProperty(const Document& doc, const glTFProperty& property, rapidjson::Value& propertyValue, rapidjson::Document::AllocatorType& a, const ExtensionSerializer& extensionSerializer)
-    {
-        SerializePropertyExtensions(doc, property, propertyValue, a, extensionSerializer);
-        SerializePropertyExtras(property, propertyValue, a);
-    }
-
-    void SerializeTextureInfo(const Document& doc, const TextureInfo& textureInfo, rapidjson::Value& textureValue, rapidjson::Document::AllocatorType& a, const IndexedContainer<const Texture>& textures, const ExtensionSerializer& extensionSerializer)
-    {
-        RapidJsonUtils::AddOptionalMemberIndex("index", textureValue, textureInfo.textureId, textures, a);
-        if (textureInfo.texCoord != 0)
-        {
-            textureValue.AddMember("texCoord", ToKnownSizeType(textureInfo.texCoord), a);
-        }
-        SerializeProperty(doc, textureInfo, textureValue, a, extensionSerializer);
-    }
-
-    void SerializeAsset(const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value assetValue(rapidjson::kObjectType);
-
-        RapidJsonUtils::AddOptionalMember("copyright", assetValue, gltfDocument.asset.copyright, a);
-        RapidJsonUtils::AddOptionalMember("generator", assetValue, gltfDocument.asset.generator, a);
-        assetValue.AddMember("version", RapidJsonUtils::ToStringValue(gltfDocument.asset.version, a), a);
-        RapidJsonUtils::AddOptionalMember("minVersion", assetValue, gltfDocument.asset.minVersion, a);
-
-        SerializeProperty(gltfDocument, gltfDocument.asset, assetValue, a, extensionSerializer);
-
-        document.AddMember("asset", assetValue, a);
-    }
-
-    void SerializeDefaultScene(const Document& gltfDocument, rapidjson::Document& document)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-
-        if (gltfDocument.HasDefaultScene())
-        {
-            document.AddMember("scene", ToKnownSizeType(gltfDocument.scenes.GetIndex(gltfDocument.defaultSceneId)), a);
-        }
-    }
-
-    template<typename T>
-    void SerializeIndexedContainer(
-        const char* name,
-        const IndexedContainer<const T>& indexedContainer,
-        const Document& gltfDocument,
-        rapidjson::Document& document,
-        const ExtensionSerializer& ext,
-        rapidjson::Value(*fn)(const T&, const Document&, rapidjson::Document&, const ExtensionSerializer&))
-    {
-        if (indexedContainer.Size() > 0)
-        {
-            rapidjson::Document::AllocatorType& a = document.GetAllocator();
-            rapidjson::Value containerItems(rapidjson::kArrayType);
-            for (const auto& containerElement : indexedContainer.Elements())
-            {
-                rapidjson::Value value = fn(containerElement, gltfDocument, document, ext);
-                containerItems.PushBack(value, a);
-            }
-
-            document.AddMember(rapidjson::StringRef(name), containerItems, a);
-        }
-    }
-
-    rapidjson::Value SerializeAccessor(const Accessor& accessor, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-
-        rapidjson::Value accessorValue;
-        accessorValue.SetObject();
-
-        RapidJsonUtils::AddOptionalMember("name", accessorValue, accessor.name, a);
-
-        if (accessor.sparse.count > 0U)
-        {
-            if (!accessor.bufferViewId.empty())
-            {
-                accessorValue.AddMember("bufferView", ToKnownSizeType(gltfDocument.bufferViews.GetIndex(accessor.bufferViewId)), a);
-            }
-
-            rapidjson::Value sparseRoot(rapidjson::kObjectType);
-            rapidjson::Value indices(rapidjson::kObjectType);
-            rapidjson::Value values(rapidjson::kObjectType);
-
-            indices.AddMember("bufferView", ToKnownSizeType(gltfDocument.bufferViews.GetIndex(accessor.sparse.indicesBufferViewId)), a);
-            if (accessor.sparse.indicesByteOffset != 0U)
-            {
-                indices.AddMember("byteOffset", ToKnownSizeType(accessor.sparse.indicesByteOffset), a);
-            }
-            indices.AddMember("componentType", accessor.sparse.indicesComponentType, a);
-
-            values.AddMember("bufferView", ToKnownSizeType(gltfDocument.bufferViews.GetIndex(accessor.sparse.valuesBufferViewId)), a);
-            if (accessor.sparse.valuesByteOffset != 0U)
-            {
-                values.AddMember("byteOffset", ToKnownSizeType(accessor.sparse.valuesByteOffset), a);
-            }
-
-            sparseRoot.AddMember("count", ToKnownSizeType(accessor.sparse.count), a);
-            sparseRoot.AddMember("indices", indices, a);
-            sparseRoot.AddMember("values", values, a);
-
-            accessorValue.AddMember("sparse", sparseRoot, a);
-        }
-        else
-        {
-            RapidJsonUtils::AddOptionalMemberIndex("bufferView", accessorValue, accessor.bufferViewId, gltfDocument.bufferViews, a);
-        }
-
-        if (accessor.byteOffset != 0U)
-        {
-            accessorValue.AddMember("byteOffset", ToKnownSizeType(accessor.byteOffset), a);
-        }
-
-        // Normalized
-        if (accessor.normalized)
-        {
-            accessorValue.AddMember("normalized", accessor.normalized, a);
-        }
-
-        accessorValue.AddMember("componentType", accessor.componentType, a);
-        accessorValue.AddMember("count", ToKnownSizeType(accessor.count), a);
-        accessorValue.AddMember("type", RapidJsonUtils::ToStringValue(AccessorTypeToString(accessor.type), a), a);
-
-        rapidjson::Value max(rapidjson::kArrayType);
-        rapidjson::Value min(rapidjson::kArrayType);
-
-        if (!accessor.max.empty())
-        {
-            accessorValue.AddMember("max", RapidJsonUtils::ToJsonArray(accessor.max, a), a);
-        }
-
-        if (!accessor.min.empty())
-        {
-            accessorValue.AddMember("min", RapidJsonUtils::ToJsonArray(accessor.min, a), a);
-        }
-
-        SerializeProperty(gltfDocument, accessor, accessorValue, a, extensionSerializer);
-
-        return accessorValue;
-    }
-
-    rapidjson::Value SerializeAnimation(const Animation& animation, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-
-        rapidjson::Value animationValue(rapidjson::kObjectType);
-        rapidjson::Value channelValues(rapidjson::kArrayType);
-        rapidjson::Value samplerValues(rapidjson::kArrayType);
-
-        for (const auto& channel : animation.channels.Elements())
-        {
-            rapidjson::Value channelValue(rapidjson::kObjectType);
-            rapidjson::Value targetValue(rapidjson::kObjectType);
-
-            RapidJsonUtils::AddOptionalMemberIndex("node", targetValue, channel.target.nodeId, gltfDocument.nodes, a);
-            targetValue.AddMember("path", RapidJsonUtils::ToStringValue(TargetPathToString(channel.target.path), a), a);
-
-            channelValue.AddMember("sampler", ToKnownSizeType(animation.samplers.GetIndex(channel.samplerId)), a);
-            channelValue.AddMember("target", targetValue, a);
-
-            SerializeProperty(gltfDocument, channel, channelValue, a, extensionSerializer);
-
-            channelValues.PushBack(channelValue, a);
-        }
-
-        for (const auto& sampler : animation.samplers.Elements())
-        {
-            rapidjson::Value samplerValue(rapidjson::kObjectType);
-            samplerValue.AddMember("input", ToKnownSizeType(gltfDocument.accessors.GetIndex(sampler.inputAccessorId)), a);
-            RapidJsonUtils::AddOptionalMember("interpolation", samplerValue, InterpolationTypeToString(sampler.interpolation), a);
-            samplerValue.AddMember("output", ToKnownSizeType(gltfDocument.accessors.GetIndex(sampler.outputAccessorId)), a);
-
-            SerializeProperty(gltfDocument, sampler, samplerValue, a, extensionSerializer);
-
-            samplerValues.PushBack(samplerValue, a);
-        }
-
-        animationValue.AddMember("channels", channelValues, a);
-        animationValue.AddMember("samplers", samplerValues, a);
-        RapidJsonUtils::AddOptionalMember("name", animationValue, animation.name, a);
-
-        SerializeProperty(gltfDocument, animation, animationValue, a, extensionSerializer);
-
-        return animationValue;
-    }
-
-    rapidjson::Value SerializeBufferView(const BufferView& bufferView, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-
-        rapidjson::Value bufferViewValue;
-        bufferViewValue.SetObject();
-
-        RapidJsonUtils::AddOptionalMember("name", bufferViewValue, bufferView.name, a);
-        bufferViewValue.AddMember("buffer", ToKnownSizeType(gltfDocument.buffers.GetIndex(bufferView.bufferId)), a);
-        bufferViewValue.AddMember("byteOffset", ToKnownSizeType(bufferView.byteOffset), a);
-        bufferViewValue.AddMember("byteLength", ToKnownSizeType(bufferView.byteLength), a);
-
-        if (bufferView.byteStride)
-        {
-            bufferViewValue.AddMember("byteStride", ToKnownSizeType(bufferView.byteStride.Get()), a);
-        }
-
-        if (bufferView.target)
-        {
-            bufferViewValue.AddMember("target", bufferView.target.Get(), a);
-        }
-
-        SerializeProperty(gltfDocument, bufferView, bufferViewValue, a, extensionSerializer);
-
-        return bufferViewValue;
-    }
-
-    rapidjson::Value SerializeBuffer(const Buffer& buffer, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value bufferValue(rapidjson::kObjectType);
-
-        bufferValue.AddMember("byteLength", ToKnownSizeType(buffer.byteLength), a);
-        RapidJsonUtils::AddOptionalMember("uri", bufferValue, buffer.uri, a);
-
-        SerializeProperty(gltfDocument, buffer, bufferValue, a, extensionSerializer);
-
-        return bufferValue;
-    }
-
-    rapidjson::Value SerializeImage(const Image& image, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        if (image.uri.empty())
-        {
-            if (image.bufferViewId.empty() || image.mimeType.empty())
-            {
-                throw InvalidGLTFException("Invalid image: " + image.id + ". Images must have either a uri or a bufferView and a mimeType.");
-            }
-        }
-        else if (!image.bufferViewId.empty())
-        {
-            throw InvalidGLTFException("Invalid image: " + image.id + ". Images can only have a uri or a bufferView, but not both.");
-        }
-
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value imageValue(rapidjson::kObjectType);
-
-        RapidJsonUtils::AddOptionalMember("name", imageValue, image.name, a);
-        RapidJsonUtils::AddOptionalMember("uri", imageValue, image.uri, a);
-        RapidJsonUtils::AddOptionalMemberIndex("bufferView", imageValue, image.bufferViewId, gltfDocument.bufferViews, a);
-        RapidJsonUtils::AddOptionalMember("mimeType", imageValue, image.mimeType, a);
-
-        SerializeProperty(gltfDocument, image, imageValue, a, extensionSerializer);
-
-        return imageValue;
-    }
-
-    rapidjson::Value SerializeMaterial(const Material& material, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value materialValue(rapidjson::kObjectType);
-        {
-            rapidjson::Value pbrMetallicRoughness(rapidjson::kObjectType);
-            {
-                if (material.metallicRoughness.baseColorFactor != Color4(1.0f, 1.0f, 1.0f, 1.0f))
-                {
-                    pbrMetallicRoughness.AddMember("baseColorFactor", RapidJsonUtils::ToJsonArray(material.metallicRoughness.baseColorFactor, a), a);
-                }
-
-                if (!material.metallicRoughness.baseColorTexture.textureId.empty())
-                {
-                    rapidjson::Value baseColorTexture(rapidjson::kObjectType);
-                    SerializeTextureInfo(gltfDocument, material.metallicRoughness.baseColorTexture, baseColorTexture, a, gltfDocument.textures, extensionSerializer);
-                    pbrMetallicRoughness.AddMember("baseColorTexture", baseColorTexture, a);
-                }
-
-                if (material.metallicRoughness.metallicFactor != 1.0f)
-                {
-                    pbrMetallicRoughness.AddMember("metallicFactor", material.metallicRoughness.metallicFactor, a);
-                }
-
-                if (material.metallicRoughness.roughnessFactor != 1.0f)
-                {
-                    pbrMetallicRoughness.AddMember("roughnessFactor", material.metallicRoughness.roughnessFactor, a);
-                }
-
-                if (!material.metallicRoughness.metallicRoughnessTexture.textureId.empty())
-                {
-                    rapidjson::Value metallicRoughnessTexture(rapidjson::kObjectType);
-                    SerializeTextureInfo(gltfDocument, material.metallicRoughness.metallicRoughnessTexture, metallicRoughnessTexture, a, gltfDocument.textures, extensionSerializer);
-                    pbrMetallicRoughness.AddMember("metallicRoughnessTexture", metallicRoughnessTexture, a);
-                }
-            }
-
-            materialValue.AddMember("pbrMetallicRoughness", pbrMetallicRoughness, a);
-
-            // Normal
-            if (!material.normalTexture.textureId.empty())
-            {
-                rapidjson::Value normalTexture(rapidjson::kObjectType);
-                SerializeTextureInfo(gltfDocument, material.normalTexture, normalTexture, a, gltfDocument.textures, extensionSerializer);
-                if (material.normalTexture.scale != 1.0f)
-                {
-                    normalTexture.AddMember("scale", material.normalTexture.scale, a);
-                }
-                materialValue.AddMember("normalTexture", normalTexture, a);
-            }
-
-            // Occlusion
-            if (!material.occlusionTexture.textureId.empty())
-            {
-                rapidjson::Value occlusionTexture(rapidjson::kObjectType);
-                SerializeTextureInfo(gltfDocument, material.occlusionTexture, occlusionTexture, a, gltfDocument.textures, extensionSerializer);
-                if (material.occlusionTexture.strength != 1.0f)
-                {
-                    occlusionTexture.AddMember("strength", material.occlusionTexture.strength, a);
-                }
-                materialValue.AddMember("occlusionTexture", occlusionTexture, a);
-            }
-
-            // Emissive Texture
-            if (!material.emissiveTexture.textureId.empty())
-            {
-                rapidjson::Value emissiveTexture(rapidjson::kObjectType);
-                SerializeTextureInfo(gltfDocument, material.emissiveTexture, emissiveTexture, a, gltfDocument.textures, extensionSerializer);
-                materialValue.AddMember("emissiveTexture", emissiveTexture, a);
-            }
-
-            //// Emissive Factor
-            if (material.emissiveFactor != Color3(0.0f, 0.0f, 0.0f))
-            {
-                materialValue.AddMember("emissiveFactor", RapidJsonUtils::ToJsonArray(material.emissiveFactor, a), a);
-            }
-
-            // Alpha Mode : do not serialize default value (opaque) or currently-unsupported value (unknown)
-            if (material.alphaMode != ALPHA_OPAQUE && material.alphaMode != ALPHA_UNKNOWN)
-            {
-                materialValue.AddMember("alphaMode", RapidJsonUtils::ToStringValue(AlphaModeToString(material.alphaMode), a), a);
-            }
-
-            // Alpha Cutoff
-            if (material.alphaCutoff != 0.5f)
-            {
-                materialValue.AddMember("alphaCutoff", material.alphaCutoff, a);
-            }
-
-            // Name
-            RapidJsonUtils::AddOptionalMember("name", materialValue, material.name, a);
-
-            // Double Sided
-            if (material.doubleSided)
-            {
-                materialValue.AddMember("doubleSided", material.doubleSided, a);
-            }
-
-            SerializeProperty(gltfDocument, material, materialValue, a, extensionSerializer);
-        }
-
-        return materialValue;
-    }
-
-    rapidjson::Value SerializeTarget(const MorphTarget& target, const Document& gltfDocument, rapidjson::Document& document)
-    {
-        rapidjson::Value targetValue(rapidjson::kObjectType);
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-
-        RapidJsonUtils::AddOptionalMemberIndex(ACCESSOR_POSITION, targetValue, target.positionsAccessorId, gltfDocument.accessors, a);
-        RapidJsonUtils::AddOptionalMemberIndex(ACCESSOR_NORMAL, targetValue, target.normalsAccessorId, gltfDocument.accessors, a);
-        RapidJsonUtils::AddOptionalMemberIndex(ACCESSOR_TANGENT, targetValue, target.tangentsAccessorId, gltfDocument.accessors, a);
-
-        return targetValue;
-    }
-
-    void SerializeTargets(const MeshPrimitive& primitive, rapidjson::Value& primitiveValue, const Document& gltfDocument, rapidjson::Document& document)
-    {
-        if (!primitive.targets.empty())
-        {
-            rapidjson::Document::AllocatorType& a = document.GetAllocator();
-            rapidjson::Value targets(rapidjson::kArrayType);
-            for (const auto& morphTarget : primitive.targets)
-            {
-                rapidjson::Value targetValue = SerializeTarget(morphTarget, gltfDocument, document);
-                targets.PushBack(targetValue, a);
-            }
-            primitiveValue.AddMember("targets", targets, a);
-        }
-    }
-
-    rapidjson::Value SerializeMesh(const Mesh& mesh, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-
-        rapidjson::Value meshValue(rapidjson::kObjectType);
-        rapidjson::Value primitiveValues(rapidjson::kArrayType);
-
-        for (const auto& primitive : mesh.primitives)
-        {
-            rapidjson::Value attributes(rapidjson::kObjectType);
-
-            for (const auto& attribute : primitive.attributes)
-            {
-                attributes.AddMember(RapidJsonUtils::ToStringValue(attribute.first, a), rapidjson::Value(ToKnownSizeType(gltfDocument.accessors.GetIndex(attribute.second))), a);
-            }
-
-            rapidjson::Value primitiveValue(rapidjson::kObjectType);
-
-            primitiveValue.AddMember("attributes", attributes, a);
-            RapidJsonUtils::AddOptionalMemberIndex("indices", primitiveValue, primitive.indicesAccessorId, gltfDocument.accessors, a);
-            RapidJsonUtils::AddOptionalMemberIndex("material", primitiveValue, primitive.materialId, gltfDocument.materials, a);
-
-            if (primitive.mode != MESH_TRIANGLES)
-            {
-                primitiveValue.AddMember("mode", primitive.mode, a);
-            }
-
-            SerializeTargets(primitive, primitiveValue, gltfDocument, document);
-
-            SerializeProperty(gltfDocument, primitive, primitiveValue, a, extensionSerializer);
-
-            primitiveValues.PushBack(primitiveValue, a);
-        }
-
-        RapidJsonUtils::AddArrayMember(meshValue, "weights", mesh.weights, a);
-
-        RapidJsonUtils::AddOptionalMember("name", meshValue, mesh.name, a);
-        meshValue.AddMember("primitives", primitiveValues, a);
-
-        SerializeProperty(gltfDocument, mesh, meshValue, a, extensionSerializer);
-
-        return meshValue;
-    }
-
-    rapidjson::Value SerializeNode(const Node& node, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-
-        rapidjson::Value nodeValue(rapidjson::kObjectType);
-
-        if (!node.children.empty())
-        {
-            rapidjson::Value nodeChildren(rapidjson::kArrayType);
-            {
-                for (const auto& childId : node.children)
-                {
-                    nodeChildren.PushBack(ToKnownSizeType(gltfDocument.nodes.GetIndex(childId)), a);
-                }
-            }
-            nodeValue.AddMember("children", nodeChildren, a);
-        }
-
-        if (!node.HasValidTransformType())
-        {
-            throw DocumentException("Node " + node.id + " doesn't have a valid transform type");
-        }
-
-        if (node.GetTransformationType() == Microsoft::glTF::TransformationType::TRANSFORMATION_MATRIX)
-        {
-            nodeValue.AddMember("matrix", RapidJsonUtils::ToJsonArray<float, 16>(node.matrix.values, a), a);
-        }
-        else if (node.GetTransformationType() == Microsoft::glTF::TransformationType::TRANSFORMATION_TRS)
-        {
-            if (node.translation != Vector3::ZERO)
-            {
-                nodeValue.AddMember("translation", RapidJsonUtils::ToJsonArray(node.translation, a), a);
-            }
-            if (node.rotation != Quaternion::IDENTITY)
-            {
-                nodeValue.AddMember("rotation", RapidJsonUtils::ToJsonArray(node.rotation, a), a);
-            }
-            if (node.scale != Vector3::ONE)
-            {
-                nodeValue.AddMember("scale", RapidJsonUtils::ToJsonArray(node.scale, a), a);
-            }
-        }
-
-        RapidJsonUtils::AddOptionalMemberIndex("mesh", nodeValue, node.meshId, gltfDocument.meshes, a);
-        RapidJsonUtils::AddOptionalMemberIndex("skin", nodeValue, node.skinId, gltfDocument.skins, a);
-
-        if (!node.cameraId.empty())
-        {
-            nodeValue.AddMember("camera", ToKnownSizeType(gltfDocument.cameras.GetIndex(node.cameraId)), a);
-        }
-
-        RapidJsonUtils::AddArrayMember(nodeValue, "weights", node.weights, a);
-
-        RapidJsonUtils::AddOptionalMember("name", nodeValue, node.name, a);
-
-        SerializeProperty(gltfDocument, node, nodeValue, a, extensionSerializer);
-
-        return nodeValue;
-    }
-
-    rapidjson::Value SerializeCamera(const Camera& camera, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value cameraValue(rapidjson::kObjectType);
-        rapidjson::Value projectionValue(rapidjson::kObjectType);
-
-        const ProjectionType projectionType = camera.projection->GetProjectionType();
-
-        if (projectionType == PROJECTION_PERSPECTIVE)
-        {
-            const auto& perspective = camera.GetPerspective();
-
-            projectionValue.AddMember("znear", RapidJsonUtils::ToFloatValue(perspective.znear), a);
-            projectionValue.AddMember("yfov", RapidJsonUtils::ToFloatValue(perspective.yfov), a);
-
-            if (perspective.zfar)
-            {
-                projectionValue.AddMember("zfar", RapidJsonUtils::ToFloatValue(perspective.zfar.Get()), a);
-            }
-
-            if (perspective.aspectRatio)
-            {
-                projectionValue.AddMember("aspectRatio", RapidJsonUtils::ToFloatValue(perspective.aspectRatio.Get()), a);
-            }
-
-            SerializeProperty(gltfDocument, perspective, projectionValue, a, extensionSerializer);
-
-            cameraValue.AddMember("perspective", projectionValue, a);
-            cameraValue.AddMember("type", RapidJsonUtils::ToStringValue("perspective", a), a);
-        }
-        else if (projectionType == PROJECTION_ORTHOGRAPHIC)
-        {
-            const auto& orthographic = camera.GetOrthographic();
-
-            projectionValue.AddMember("xmag", RapidJsonUtils::ToFloatValue(orthographic.xmag), a);
-            projectionValue.AddMember("ymag", RapidJsonUtils::ToFloatValue(orthographic.ymag), a);
-            projectionValue.AddMember("znear", RapidJsonUtils::ToFloatValue(orthographic.znear), a);
-            projectionValue.AddMember("zfar", RapidJsonUtils::ToFloatValue(orthographic.zfar), a);
-
-            SerializeProperty(gltfDocument, orthographic, projectionValue, a, extensionSerializer);
-
-            cameraValue.AddMember("orthographic", projectionValue, a);
-            cameraValue.AddMember("type", RapidJsonUtils::ToStringValue("orthographic", a), a);
-        }
-        else
-        {
-            throw DocumentException("Camera " + camera.id + " doesn't have a valid projection type");
-        }
-
-        SerializeProperty(gltfDocument, camera, cameraValue, a, extensionSerializer);
-
-        RapidJsonUtils::AddOptionalMember("name", cameraValue, camera.name, a);
-
-        return cameraValue;
-    }
-
-    rapidjson::Value SerializeSampler(const Sampler& sampler, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value samplerValue(rapidjson::kObjectType);
-
-        {
-            RapidJsonUtils::AddOptionalMember("name", samplerValue, sampler.name, a);
-
-            if (sampler.magFilter)
-            {
-                samplerValue.AddMember("magFilter", sampler.magFilter.Get(), a);
-            }
-
-            if (sampler.minFilter)
-            {
-                samplerValue.AddMember("minFilter", sampler.minFilter.Get(), a);
-            }
-
-            if (sampler.wrapS != WrapMode::Wrap_REPEAT)
-            {
-                samplerValue.AddMember("wrapS", sampler.wrapS, a);
-            }
-
-            if (sampler.wrapT != WrapMode::Wrap_REPEAT)
-            {
-                samplerValue.AddMember("wrapT", sampler.wrapT, a);
-            }
-
-            SerializeProperty(gltfDocument, sampler, samplerValue, a, extensionSerializer);
-        }
-
-        return samplerValue;
-    }
-
-    rapidjson::Value SerializeScene(const Scene& scene, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value sceneValue(rapidjson::kObjectType);
-
-        if (!scene.nodes.empty())
-        {
-            rapidjson::Value nodesArray(rapidjson::kArrayType);
-            for (const auto& nodeId : scene.nodes)
-            {
-                nodesArray.PushBack(ToKnownSizeType(gltfDocument.nodes.GetIndex(nodeId)), a);
-            }
-            sceneValue.AddMember("nodes", nodesArray, a);
-        }
-
-        RapidJsonUtils::AddOptionalMember("name", sceneValue, scene.name, a);
-
-        SerializeProperty(gltfDocument, scene, sceneValue, a, extensionSerializer);
-
-        return sceneValue;
-    }
-
-    rapidjson::Value SerializeSkin(const Skin& skin, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value skinValue(rapidjson::kObjectType);
-        {
-            RapidJsonUtils::AddOptionalMemberIndex("inverseBindMatrices", skinValue, skin.inverseBindMatricesAccessorId, gltfDocument.accessors, a);
-            RapidJsonUtils::AddOptionalMemberIndex("skeleton", skinValue, skin.skeletonId, gltfDocument.nodes, a);
-
-            if (!skin.jointIds.empty())
-            {
-                rapidjson::Value jointIds(rapidjson::kArrayType);
-                {
-                    for (const auto& jointId : skin.jointIds)
-                    {
-                        jointIds.PushBack(ToKnownSizeType(gltfDocument.nodes.GetIndex(jointId)), a);
-                    }
-                }
-                skinValue.AddMember("joints", jointIds, a);
-            }
-
-            RapidJsonUtils::AddOptionalMember("name", skinValue, skin.name, a);
-
-            SerializeProperty(gltfDocument, skin, skinValue, a, extensionSerializer);
-        }
-        return skinValue;
-    }
-
-    rapidjson::Value SerializeTexture(const Texture& texture, const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value textureValue(rapidjson::kObjectType);
-
-        RapidJsonUtils::AddOptionalMember("name", textureValue, texture.name, a);
-        RapidJsonUtils::AddOptionalMemberIndex("sampler", textureValue, texture.samplerId, gltfDocument.samplers, a);
-        RapidJsonUtils::AddOptionalMemberIndex("source", textureValue, texture.imageId, gltfDocument.images, a);
-
-        SerializeProperty(gltfDocument, texture, textureValue, a, extensionSerializer);
-
-        return textureValue;
-    }
-
-    void SerializeExtensions(const Document& gltfDocument, rapidjson::Document& document, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document::AllocatorType& a = document.GetAllocator();
-        rapidjson::Value extensionValue(rapidjson::kObjectType);
-
-        SerializePropertyExtensions(gltfDocument, gltfDocument, extensionValue, a, extensionSerializer);
-
-        if (extensionValue.HasMember("extensions"))
-        {
-            auto& value = extensionValue.FindMember("extensions")->value;
-            document.AddMember("extensions", value, a);
-        }
-    }
-
-    void SerializeStringSet(const std::string& key, const std::unordered_set<std::string> set, rapidjson::Document& document)
-    {
-        if (!set.empty())
-        {
-            rapidjson::Document::AllocatorType& a = document.GetAllocator();
-            rapidjson::Value extensions(rapidjson::kArrayType);
-            for (const auto& element : set)
-            {
-                extensions.PushBack(RapidJsonUtils::ToStringValue(element, a), a);
-            }
-            document.AddMember(RapidJsonUtils::ToStringValue(key, a), extensions, a);
-        }
-    }
-
-    void SerializeExtensionsUsed(const Document& gltfDocument, rapidjson::Document& document)
-    {
-        SerializeStringSet("extensionsUsed", gltfDocument.extensionsUsed, document);
-    }
-
-    void SerializeExtensionsRequired(const Document& gltfDocument, rapidjson::Document& document)
-    {
-        for (auto& extensionName : gltfDocument.extensionsRequired)
-        {
-            if (gltfDocument.extensionsUsed.find(extensionName) == gltfDocument.extensionsUsed.end())
-            {
-                throw GLTFException("required extension '" + extensionName + "' not present in extensionsUsed.");
-            }
-        }
-        
-        SerializeStringSet("extensionsRequired", gltfDocument.extensionsRequired, document);
-    }
-
-    rapidjson::Document CreateJsonDocument(const Document& gltfDocument, const ExtensionSerializer& extensionSerializer)
-    {
-        rapidjson::Document document(rapidjson::kObjectType);
-
-        SerializeAsset(gltfDocument, document, extensionSerializer);
-
-        SerializeIndexedContainer<Accessor>("accessors", gltfDocument.accessors, gltfDocument, document, extensionSerializer, SerializeAccessor);
-        SerializeIndexedContainer<Animation>("animations", gltfDocument.animations, gltfDocument, document, extensionSerializer, SerializeAnimation);
-        SerializeIndexedContainer<BufferView>("bufferViews", gltfDocument.bufferViews, gltfDocument, document, extensionSerializer, SerializeBufferView);
-        SerializeIndexedContainer<Buffer>("buffers", gltfDocument.buffers, gltfDocument, document, extensionSerializer, SerializeBuffer);
-        SerializeIndexedContainer<Camera>("cameras", gltfDocument.cameras, gltfDocument, document, extensionSerializer, SerializeCamera);
-        SerializeIndexedContainer<Image>("images", gltfDocument.images, gltfDocument, document, extensionSerializer, SerializeImage);
-        SerializeIndexedContainer<Material>("materials", gltfDocument.materials, gltfDocument, document, extensionSerializer, SerializeMaterial);
-        SerializeIndexedContainer<Mesh>("meshes", gltfDocument.meshes, gltfDocument, document, extensionSerializer, SerializeMesh);
-        SerializeIndexedContainer<Node>("nodes", gltfDocument.nodes, gltfDocument, document, extensionSerializer, SerializeNode);
-        SerializeIndexedContainer<Sampler>("samplers", gltfDocument.samplers, gltfDocument, document, extensionSerializer, SerializeSampler);
-        SerializeIndexedContainer<Scene>("scenes", gltfDocument.scenes, gltfDocument, document, extensionSerializer, SerializeScene);
-        SerializeIndexedContainer<Skin>("skins", gltfDocument.skins, gltfDocument, document, extensionSerializer, SerializeSkin);
-        SerializeIndexedContainer<Texture>("textures", gltfDocument.textures, gltfDocument, document, extensionSerializer, SerializeTexture);
-
-        SerializeDefaultScene(gltfDocument, document);
-
-        SerializeExtensions(gltfDocument, document, extensionSerializer);
-
-        SerializeExtensionsUsed(gltfDocument, document);
-        SerializeExtensionsRequired(gltfDocument, document);
-
-        return document;
-    }
-
-    bool HasFlag(SerializeFlags flags, SerializeFlags flag)
-    {
-        return ((flags & flag) == flag);
-    }
-}
-
-std::string Microsoft::glTF::Serialize(const Document& gltfDocument, SerializeFlags flags)
-{
-    return Serialize(gltfDocument, ExtensionSerializer(), flags);
-}
-
-std::string Microsoft::glTF::Serialize(const Document& gltfDocument, const ExtensionSerializer& extensionSerializer, SerializeFlags flags)
-{
-    auto doc = CreateJsonDocument(gltfDocument, extensionSerializer);
-
-    rapidjson::StringBuffer stringBuffer;
-    if (HasFlag(flags, SerializeFlags::Pretty))
-    {
-        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(stringBuffer);
-        doc.Accept(writer);
-    }
-    else
-    {
-        rapidjson::Writer<rapidjson::StringBuffer> writer(stringBuffer);
-        doc.Accept(writer);
-    }
-
-    return stringBuffer.GetString();
-}
-
-SerializeFlags Microsoft::glTF::operator|(SerializeFlags lhs, SerializeFlags rhs)
-{
-    const auto result =
-        static_cast<std::underlying_type_t<SerializeFlags>>(lhs) |
-        static_cast<std::underlying_type_t<SerializeFlags>>(rhs);
-
-    return static_cast<SerializeFlags>(result);
-}
-
-SerializeFlags& Microsoft::glTF::operator|=(SerializeFlags& lhs, SerializeFlags rhs)
-{
-    lhs = lhs | rhs;
-    return lhs;
-}
-
-SerializeFlags Microsoft::glTF::operator&(SerializeFlags lhs, SerializeFlags rhs)
-{
-    const auto result =
-        static_cast<std::underlying_type_t<SerializeFlags>>(lhs) &
-        static_cast<std::underlying_type_t<SerializeFlags>>(rhs);
-
-    return static_cast<SerializeFlags>(result);
-}
-
-SerializeFlags& Microsoft::glTF::operator&=(SerializeFlags& lhs, SerializeFlags rhs)
-{
-    lhs = lhs & rhs;
-    return lhs;
-}
diff --git a/thirdparty/GLTFSDK/Source/Validation.cpp b/thirdparty/GLTFSDK/Source/Validation.cpp
deleted file mode 100644
index f081fac..0000000
--- a/thirdparty/GLTFSDK/Source/Validation.cpp
+++ /dev/null
@@ -1,341 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/Validation.h>
-
-#include <GLTFSDK/BufferBuilder.h>
-
-#include <sstream>
-
-using namespace Microsoft::glTF;
-
-namespace
-{
-    template<typename It>
-    std::string Join(It it, It itEnd, const char* const delimiter)
-    {
-        std::stringstream sstream;
-
-        if(it != itEnd)
-        {
-            sstream << *it++;
-
-            while(it != itEnd)
-            {
-                sstream << delimiter << *it++;
-            }
-        }
-
-        return sstream.str();
-    }
-
-    std::string GetAccessorTypesAsString(const std::set<AccessorType>& accessorTypes)
-    {
-        std::vector<std::string> accessorTypeNames(accessorTypes.size());
-
-        std::transform(
-            accessorTypes.begin(),
-            accessorTypes.end(),
-            accessorTypeNames.begin(),
-            Accessor::GetAccessorTypeName);
-
-        return Join(accessorTypeNames.begin(), accessorTypeNames.end(), ", ");
-    }
-
-    std::string GetComponentTypesAsString(const std::set<ComponentType>& componentTypes)
-    {
-        std::vector<std::string> componentTypeNames(componentTypes.size());
-
-        std::transform(
-            componentTypes.begin(),
-            componentTypes.end(),
-            componentTypeNames.begin(),
-            Accessor::GetComponentTypeName);
-
-        return Join(componentTypeNames.begin(), componentTypeNames.end(), ", ");
-    }
-
-    void ValidateAccessorsImpl(const size_t count, const size_t byteOffset, const ComponentType& componentType,
-        const AccessorType& accessorType, const std::string& id, const BufferView& bufferView, const Buffer& buffer)
-    {
-        if (byteOffset > bufferView.byteLength)
-        {
-            std::string byteLength = std::to_string(bufferView.byteLength);
-            throw ValidationException("Accessor" + id + " byteoffset (" + std::to_string(byteOffset) + ") is larger than bufferview byte length (" + byteLength + ")");
-        }
-
-        // Check the multiplication in accessor.GetByteLength() for overflow
-        size_t testAccessorByteLength;
-        if (!Validation::SafeMultiplication(static_cast<size_t>(count),
-                (static_cast<size_t>(Accessor::GetComponentTypeSize(componentType) *
-                Accessor::GetTypeCount(accessorType))),
-            testAccessorByteLength))
-        {
-            throw ValidationException("Accessor" + id + " byte length too large");
-        }
-
-        size_t byteLength = static_cast<size_t>(count * Accessor::GetComponentTypeSize(componentType) * Accessor::GetTypeCount(accessorType));
-
-        if (testAccessorByteLength != byteLength)
-        {
-            throw ValidationException("Accessor" + id + " byte length safe value does not match actual value");
-        }
-
-        if (byteLength > bufferView.byteLength)
-        {
-            std::string accessorByteLengthStr = std::to_string(byteLength);
-            std::string bvByteLength = std::to_string(bufferView.byteLength);
-            throw ValidationException("Accessor" + id + " byte length (" + accessorByteLengthStr + ") greater than buffer view (" + bvByteLength + ")");
-        }
-
-        short accessorComponentTypeSize = Accessor::GetComponentTypeSize(componentType);
-        if ((byteOffset + bufferView.byteOffset) % accessorComponentTypeSize != 0)
-        {
-            throw ValidationException("Accessor" + id + ": the accessor offset must be a multiple of the size of the accessor component type.");
-        }
-
-        Validation::ValidateBufferView(bufferView, buffer);
-    }
-
-    void ValidateVertexCount(const MeshMode mode, const size_t count, const std::string& type)
-    {
-        switch (mode)
-        {
-        case MESH_POINTS:
-            break;
-
-        case MESH_LINES:
-            if (count < 2)
-            {
-                throw ValidationException(type + " count must be at least 2.");
-            }
-
-            if (count % 2 != 0)
-            {
-                throw ValidationException(type + " count for MESH_LINES must be a multiple of 2.");
-            }
-            break;
-
-        case MESH_LINE_LOOP:
-        case MESH_LINE_STRIP:
-            if (count < 2)
-            {
-                throw ValidationException(type + " count must be at least 2.");
-            }
-            break;
-
-        case MESH_TRIANGLES:
-            if (count < 3)
-            {
-                throw ValidationException(type + " count must be at least 3.");
-            }
-
-            if (count % 3 != 0)
-            {
-                throw ValidationException(type + " count for MESH_TRIANGLES must be a multiple of 3.");
-            }
-            break;
-
-        case MESH_TRIANGLE_FAN:
-        case MESH_TRIANGLE_STRIP:
-            if (count < 3)
-            {
-                throw ValidationException(type + " count must be at least 3.");
-            }
-            break;
-
-        default:
-            throw ValidationException(type + " invalid mesh mode for validation " + std::to_string(mode));
-            break;
-        }
-    }
-}
-
-void Validation::Validate(const Document& doc)
-{
-    ValidateAccessors(doc);
-    ValidateMeshes(doc);
-}
-
-void Validation::ValidateAccessors(const Document& doc)
-{
-    for (const auto& accessor : doc.accessors.Elements())
-    {
-        ValidateAccessor(doc, accessor);
-    }
-}
-
-void Validation::ValidateMeshes(const Document& doc)
-{
-    for (const auto& mesh : doc.meshes.Elements())
-    {
-        for (const auto& primitive : mesh.primitives)
-        {
-            ValidateMeshPrimitive(doc, primitive);
-        }
-    }
-}
-
-void Validation::ValidateMeshPrimitive(const Document& doc, const MeshPrimitive& primitive)
-{
-    if (!primitive.HasAttribute(ACCESSOR_POSITION))
-    {
-        throw ValidationException("MeshPrimitive must have 'POSITION' attribute.");
-    }
-
-    size_t vertexCount = doc.accessors.Get(primitive.GetAttributeAccessorId(ACCESSOR_POSITION)).count;
-
-    const auto& indicesAccessorId = primitive.indicesAccessorId;
-    if (!indicesAccessorId.empty())
-    {
-        const auto& indicesAccessor = doc.accessors.Get(indicesAccessorId);
-        ValidateAccessorTypes(indicesAccessor, "indices", { TYPE_SCALAR }, { COMPONENT_UNSIGNED_BYTE, COMPONENT_UNSIGNED_SHORT, COMPONENT_UNSIGNED_INT });
-        ValidateVertexCount(primitive.mode, indicesAccessor.count, "Index");
-    }
-    else
-    {
-        ValidateVertexCount(primitive.mode, vertexCount, "Position");
-    }
-
-    ValidateMeshPrimitiveAttributeAccessors(doc, primitive.attributes, vertexCount);
-}
-
-void Validation::ValidateMeshPrimitiveAttributeAccessors(
-    const Document& doc,
-    const std::unordered_map<std::string, std::string>& attributes,
-    const size_t vertexCount
-)
-{
-    // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#meshes
-    static const std::unordered_map <std::string, std::pair<std::set<AccessorType>, std::set<ComponentType>>> attributeDefinitions =
-    {
-        { ACCESSOR_POSITION,   { { TYPE_VEC3 },            { COMPONENT_FLOAT } } },
-        { ACCESSOR_NORMAL,     { { TYPE_VEC3 },            { COMPONENT_FLOAT } } },
-        { ACCESSOR_TANGENT,    { { TYPE_VEC4 },            { COMPONENT_FLOAT } } },
-        { ACCESSOR_TEXCOORD_0, { { TYPE_VEC2 },            { COMPONENT_FLOAT, COMPONENT_UNSIGNED_BYTE, COMPONENT_UNSIGNED_SHORT } } },
-        { ACCESSOR_TEXCOORD_1, { { TYPE_VEC2 },            { COMPONENT_FLOAT, COMPONENT_UNSIGNED_BYTE, COMPONENT_UNSIGNED_SHORT } } },
-        { ACCESSOR_COLOR_0,    { { TYPE_VEC3, TYPE_VEC4 }, { COMPONENT_FLOAT, COMPONENT_UNSIGNED_BYTE, COMPONENT_UNSIGNED_SHORT } } },
-        { ACCESSOR_JOINTS_0,   { { TYPE_VEC4 },            {                  COMPONENT_UNSIGNED_BYTE, COMPONENT_UNSIGNED_SHORT } } },
-        { ACCESSOR_WEIGHTS_0,  { { TYPE_VEC4 },            { COMPONENT_FLOAT, COMPONENT_UNSIGNED_BYTE, COMPONENT_UNSIGNED_SHORT } } }
-    };
-
-    // TODO: Validate by prefix TEXCOORD_/COLOR_/JOINTS_/WEIGHTS_ 
-    for (const auto& attribute : attributes)
-    {
-        const auto& attributeName = attribute.first;
-        const auto& attributeAccessorId = attribute.second;
-
-        const auto it = attributeDefinitions.find(attributeName);
-        if (it != attributeDefinitions.end())
-        {
-            const auto& accessor = doc.accessors.Get(attributeAccessorId);
-            ValidateAccessorTypes(accessor, attributeName, it->second.first, it->second.second);
-
-            if (accessor.count != vertexCount)
-            {
-                throw ValidationException(
-                    "MeshPrimitive attribute '" + std::string(attributeName) + "' had an incorrect count ("
-                    + std::to_string(accessor.count) + " vs. " + std::to_string(vertexCount));
-            }
-        }
-    }
-}
-
-void Validation::ValidateAccessorTypes(
-    const Accessor& accessor,
-    const std::string& accessorName,
-    const std::set<AccessorType>& accessorTypes,
-    const std::set<ComponentType>& componentTypes
-)
-{
-    if (accessorTypes.find(accessor.type) == accessorTypes.end())
-    {
-        throw ValidationException(
-            "Accessor " + accessor.id + " " + accessorName + " type must be: [" + GetAccessorTypesAsString(accessorTypes) + "]"
-        );
-    }
-
-    if (componentTypes.find(accessor.componentType) == componentTypes.end())
-    {
-        throw ValidationException(
-            "Accessor " + accessor.id + " " + accessorName + " componentType must be: [" + GetComponentTypesAsString(componentTypes) + "]"
-        );
-    }
-}
-
-void Validation::ValidateAccessor(const Document& gltfDocument, const Accessor& accessor)
-{
-    if (!accessor.bufferViewId.empty())
-    {
-        const BufferView& bufferView = gltfDocument.bufferViews.Get(accessor.bufferViewId);
-        const Buffer& buffer = gltfDocument.buffers.Get(bufferView.bufferId);
-        ValidateAccessorsImpl(accessor.count, accessor.byteOffset, accessor.componentType, accessor.type, accessor.id, bufferView, buffer);
-    }
-
-    if (accessor.sparse.count > 0U) 
-    {
-        const BufferView& indicesBufferView = gltfDocument.bufferViews.Get(accessor.sparse.indicesBufferViewId);
-        const Buffer& indicesBuffer = gltfDocument.buffers.Get(indicesBufferView.bufferId);
-        std::string indices_id = accessor.id + "_sparseIndices";
-        ValidateAccessorsImpl(accessor.sparse.count, accessor.sparse.indicesByteOffset, accessor.sparse.indicesComponentType,
-            TYPE_SCALAR, indices_id, indicesBufferView, indicesBuffer);
-
-        const BufferView& valuesBufferView = gltfDocument.bufferViews.Get(accessor.sparse.valuesBufferViewId);
-        const Buffer& valuesBuffer = gltfDocument.buffers.Get(valuesBufferView.bufferId);
-        std::string values_id = accessor.id + "_sparseValues";
-        ValidateAccessorsImpl(accessor.sparse.count, accessor.sparse.valuesByteOffset, accessor.componentType,
-            accessor.type, values_id, valuesBufferView, valuesBuffer);
-    }
-}
-
-void Validation::ValidateBufferView(const BufferView& buffer_view, const Buffer& buffer)
-{
-    size_t totalBufferViewLength;
-    if (!SafeAddition(buffer_view.byteOffset, buffer_view.byteLength, totalBufferViewLength))
-    {
-        throw ValidationException("Buffer view size too large");
-    }
-
-    if (totalBufferViewLength > buffer.byteLength)
-    {
-        std::string totalBufferViewLengthStr = std::to_string(totalBufferViewLength);
-        std::string byteLength = std::to_string(buffer.byteLength);
-        throw ValidationException("BufferView " + buffer_view.bufferId + " offset + length (" + totalBufferViewLengthStr + ") greater than buffer length (" + byteLength + ")");
-    }
-}
-
-// Figure out if the two arguments, when summed, will overflow a size_t or not.
-// If addition was successful, return true and the result of the addition in result.
-// If addition was unsuccessful, return false and the value in result is not valid.
-bool Validation::SafeAddition(size_t a, size_t b, size_t& result)
-{
-    if (b <= std::numeric_limits<size_t>::max() - a)
-    {
-        // No overflow
-        result = a + b;
-        return true;
-    }
-
-    return false;
-}
-
-// Figure out if the two arguments, when multiplied, will overflow a size_t or not.
-// If multiplication was successful, return true and the result of the addition in result.
-// If multiplication was unsuccessful, return false and the value in result is not valid.
-bool Validation::SafeMultiplication(size_t a, size_t b, size_t& result)
-{
-    if (b == 0)
-    {
-        result = 0;
-        return true;
-    }
-
-    if (a <= std::numeric_limits<size_t>::max() / b)
-    {
-        // No overflow
-        result = a * b;
-        return true;
-    }
-
-    return false;
-}
\ No newline at end of file
diff --git a/thirdparty/GLTFSDK/Source/Version.cpp b/thirdparty/GLTFSDK/Source/Version.cpp
deleted file mode 100644
index 0db0593..0000000
--- a/thirdparty/GLTFSDK/Source/Version.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#include <GLTFSDK/Version.h>
-
-#include <GLTFSDK/Exceptions.h>
-
-#include <set>
-#include <regex>
-#include <sstream>
-#include <limits>
-
-using namespace Microsoft::glTF;
-
-Version::Version(const char* version) : Version(AsTuple(version))
-{
-}
-
-Version::Version(const std::string& version) : Version(version.c_str())
-{
-}
-
-std::string Version::AsString() const
-{
-    std::stringstream ss;
-
-    ss << major;
-    ss << ".";
-    ss << minor;
-
-    return ss.str();
-}
-
-bool Version::operator==(const Version& rhs) const
-{
-    return major == rhs.major
-        && minor == rhs.minor;
-}
-
-bool Version::operator!=(const Version& rhs) const
-{
-    return !operator==(rhs);
-}
-
-std::tuple<uint32_t, uint32_t> Version::AsTuple(const char* version)
-{
-    std::cmatch match_results;
-
-    if (version && std::regex_match(version, match_results, std::regex("^([0-9]+)\\.([0-9]+)$")))
-    {
-        // Use std::istringstream rather than std::stoul to get consistent behaviour on both LLP64 and LP64 platforms
-        uint32_t major = std::numeric_limits<uint32_t>::max();
-        uint32_t minor = std::numeric_limits<uint32_t>::max();
-
-        std::istringstream ssMajor(match_results.str(1));
-
-        if (!(ssMajor >> major))
-        {
-            throw GLTFException("Invalid version number - major value would fall outside the range of the result type");
-        }
-
-        std::istringstream ssMinor(match_results.str(2));
-
-        if (!(ssMinor >> minor))
-        {
-            throw GLTFException("Invalid version number - minor value would fall outside the range of the result type");
-        }
-
-        return { major, minor };
-    }
-    else
-    {
-        throw GLTFException("Invalid version number");
-    }
-}
-
-bool Microsoft::glTF::IsMinVersionRequirementSatisfied(const Version& minVersion, std::initializer_list<Version> supported)
-{
-    if (supported.size() == 0U)
-    {
-        throw GLTFException("List of supported versions cannot be empty");
-    }
-
-    auto fnCompare = [](const Version& lhs, const Version& rhs)
-    {
-        return (lhs.major < rhs.major) || ((lhs.major == rhs.major) && (lhs.minor < rhs.minor));
-    };
-
-    std::set<Version, decltype(fnCompare)> versions(
-        supported.begin(),
-        supported.end(),
-        fnCompare);
-
-    auto it = versions.lower_bound(minVersion);
-
-    if (it != versions.end())
-    {
-        return it->major == minVersion.major;
-    }
-
-    return false;
-}
-
-bool Microsoft::glTF::IsMinVersionRequirementSatisfied(const std::string& minVersion, std::initializer_list<Version> supported)
-{
-    if (supported.size() == 0U)
-    {
-        throw GLTFException("List of supported versions cannot be empty");
-    }
-
-    return minVersion.empty() || IsMinVersionRequirementSatisfied(Version(minVersion), supported);
-}
diff --git a/thirdparty/GLTFSDK/schema/accessor.schema.json b/thirdparty/GLTFSDK/schema/accessor.schema.json
deleted file mode 100644
index 5e21853..0000000
--- a/thirdparty/GLTFSDK/schema/accessor.schema.json
+++ /dev/null
@@ -1,129 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Accessor",
-    "type": "object",
-    "description": "A typed view into a bufferView.  A bufferView contains raw binary data.  An accessor provides a typed view into a bufferView or a subset of a bufferView similar to how WebGL's `vertexAttribPointer()` defines an attribute in a buffer.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "bufferView": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the bufferView.",
-            "gltf_detailedDescription": "The index of the bufferView. When not defined, accessor must be initialized with zeros; `sparse` property or extensions could override zeros with actual values."
-        },
-        "byteOffset": {
-            "type": "integer",
-            "description": "The offset relative to the start of the bufferView in bytes.",
-            "minimum": 0,
-            "default": 0,
-            "gltf_detailedDescription": "The offset relative to the start of the bufferView in bytes.  This must be a multiple of the size of the component datatype.",
-            "gltf_webgl": "`vertexAttribPointer()` offset parameter"
-        },
-        "componentType": {
-            "description": "The datatype of components in the attribute.",
-            "gltf_detailedDescription": "The datatype of components in the attribute.  All valid values correspond to WebGL enums.  The corresponding typed arrays are `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Uint32Array`, and `Float32Array`, respectively.  5125 (UNSIGNED_INT) is only allowed when the accessor contains indices, i.e., the accessor is only referenced by `primitive.indices`.",
-            "gltf_webgl": "`vertexAttribPointer()` type parameter",
-            "anyOf": [
-                {
-                    "enum": [ 5120 ],
-                    "description": "BYTE"
-                },
-                {
-                    "enum": [ 5121 ],
-                    "description": "UNSIGNED_BYTE"
-                },
-                {
-                    "enum": [ 5122 ],
-                    "description": "SHORT"
-                },
-                {
-                    "enum": [ 5123 ],
-                    "description": "UNSIGNED_SHORT"
-                },
-                {
-                    "enum": [ 5125 ],
-                    "description": "UNSIGNED_INT"
-                },
-                {
-                    "enum": [ 5126 ],
-                    "description": "FLOAT"
-                },
-                {
-                    "type": "integer"
-                }
-            ]
-        },
-        "normalized": {
-            "type": "boolean",
-            "description": "Specifies whether integer data values should be normalized.",
-            "default": false,
-            "gltf_detailedDescription": "Specifies whether integer data values should be normalized (`true`) to [0, 1] (for unsigned types) or [-1, 1] (for signed types), or converted directly (`false`) when they are accessed. This property is defined only for accessors that contain vertex attributes or animation output data.",
-            "gltf_webgl": "`vertexAttribPointer()` normalized parameter"
-        },
-        "count": {
-            "type": "integer",
-            "description": "The number of attributes referenced by this accessor.",
-            "minimum": 1,
-            "gltf_detailedDescription": "The number of attributes referenced by this accessor, not to be confused with the number of bytes or number of components."
-        },
-        "type": {
-            "description": "Specifies if the attribute is a scalar, vector, or matrix.",
-            "anyOf": [
-                {
-                    "enum": [ "SCALAR" ]
-                },
-                {
-                    "enum": [ "VEC2" ]
-                },
-                {
-                    "enum": [ "VEC3" ]
-                },
-                {
-                    "enum": [ "VEC4" ]
-                },
-                {
-                    "enum": [ "MAT2" ]
-                },
-                {
-                    "enum": [ "MAT3" ]
-                },
-                {
-                    "enum": [ "MAT4" ]
-                },
-                {
-                    "type": "string"
-                }
-            ]
-        },
-        "max": {
-            "type": "array",
-            "description": "Maximum value of each component in this attribute.",
-            "items": {
-                "type": "number"
-            },
-            "minItems": 1,
-            "maxItems": 16,
-            "gltf_detailedDescription": "Maximum value of each component in this attribute.  Array elements must be treated as having the same data type as accessor's `componentType`. Both min and max arrays have the same length.  The length is determined by the value of the type property; it can be 1, 2, 3, 4, 9, or 16.\n\n`normalized` property has no effect on array values: they always correspond to the actual values stored in the buffer. When accessor is sparse, this property must contain max values of accessor data with sparse substitution applied."
-        },
-        "min": {
-            "type": "array",
-            "description": "Minimum value of each component in this attribute.",
-            "items": {
-                "type": "number"
-            },
-            "minItems": 1,
-            "maxItems": 16,
-            "gltf_detailedDescription": "Minimum value of each component in this attribute.  Array elements must be treated as having the same data type as accessor's `componentType`. Both min and max arrays have the same length.  The length is determined by the value of the type property; it can be 1, 2, 3, 4, 9, or 16.\n\n`normalized` property has no effect on array values: they always correspond to the actual values stored in the buffer. When accessor is sparse, this property must contain min values of accessor data with sparse substitution applied."
-        },
-        "sparse": {
-            "allOf": [ { "$ref": "accessor.sparse.schema.json" } ],
-            "description": "Sparse storage of attributes that deviate from their initialization value."
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "dependencies": {
-        "byteOffset": [ "bufferView" ]
-    },
-    "required": [ "componentType", "count", "type" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/accessor.sparse.indices.schema.json b/thirdparty/GLTFSDK/schema/accessor.sparse.indices.schema.json
deleted file mode 100644
index 3dd537a..0000000
--- a/thirdparty/GLTFSDK/schema/accessor.sparse.indices.schema.json
+++ /dev/null
@@ -1,43 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Accessor Sparse Indices",
-    "type": "object",
-    "description": "Indices of those attributes that deviate from their initialization value.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "bufferView": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the bufferView with sparse indices. Referenced bufferView can't have ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER target."
-        },
-        "byteOffset": {
-            "type": "integer",
-            "description": "The offset relative to the start of the bufferView in bytes. Must be aligned.",
-            "minimum": 0,
-            "default": 0
-        },
-        "componentType": {
-            "description": "The indices data type.",
-            "gltf_detailedDescription": "The indices data type.  Valid values correspond to WebGL enums: `5121` (UNSIGNED_BYTE), `5123` (UNSIGNED_SHORT), `5125` (UNSIGNED_INT).",
-            "anyOf": [
-                {
-                    "enum": [ 5121 ],
-                    "description": "UNSIGNED_BYTE"
-                },
-                {
-                    "enum": [ 5123 ],
-                    "description": "UNSIGNED_SHORT"
-                },
-                {
-                    "enum": [ 5125 ],
-                    "description": "UNSIGNED_INT"
-                },
-                {
-                    "type": "integer"
-                }
-            ]
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "bufferView", "componentType" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/accessor.sparse.schema.json b/thirdparty/GLTFSDK/schema/accessor.sparse.schema.json
deleted file mode 100644
index c9a2706..0000000
--- a/thirdparty/GLTFSDK/schema/accessor.sparse.schema.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Accessor Sparse",
-    "type": "object",
-    "description": "Sparse storage of attributes that deviate from their initialization value.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "count": {
-            "type": "integer",
-            "description": "Number of entries stored in the sparse array.",
-            "minimum": 1,
-            "gltf_detailedDescription": "The number of attributes encoded in this sparse accessor."
-        },
-        "indices": {
-            "allOf": [ { "$ref": "accessor.sparse.indices.schema.json" } ],
-            "description": "Index array of size `count` that points to those accessor attributes that deviate from their initialization value. Indices must strictly increase."
-        },
-        "values": {
-            "allOf": [ { "$ref": "accessor.sparse.values.schema.json" } ],
-            "description": "Array of size `count` times number of components, storing the displaced accessor attributes pointed by `indices`. Substituted values must have the same `componentType` and number of components as the base accessor."
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "count", "indices", "values" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/accessor.sparse.values.schema.json b/thirdparty/GLTFSDK/schema/accessor.sparse.values.schema.json
deleted file mode 100644
index 184c870..0000000
--- a/thirdparty/GLTFSDK/schema/accessor.sparse.values.schema.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Accessor Sparse Values",
-    "type": "object",
-    "description": "Array of size `accessor.sparse.count` times number of components storing the displaced accessor attributes pointed by `accessor.sparse.indices`.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "bufferView": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the bufferView with sparse values. Referenced bufferView can't have ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER target."
-        },
-        "byteOffset": {
-            "type": "integer",
-            "description": "The offset relative to the start of the bufferView in bytes. Must be aligned.",
-            "minimum": 0,
-            "default": 0
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "bufferView" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/animation.channel.schema.json b/thirdparty/GLTFSDK/schema/animation.channel.schema.json
deleted file mode 100644
index 0a5a4e2..0000000
--- a/thirdparty/GLTFSDK/schema/animation.channel.schema.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Animation Channel",
-    "type": "object",
-    "description": "Targets an animation's sampler at a node's property.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "sampler": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of a sampler in this animation used to compute the value for the target.",
-            "gltf_detailedDescription": "The index of a sampler in this animation used to compute the value for the target, e.g., a node's translation, rotation, or scale (TRS)."
-        },
-        "target": {
-            "allOf": [ { "$ref": "animation.channel.target.schema.json" } ],
-            "description": "The index of the node and TRS property to target."
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "sampler", "target" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/animation.channel.target.schema.json b/thirdparty/GLTFSDK/schema/animation.channel.target.schema.json
deleted file mode 100644
index 0511af7..0000000
--- a/thirdparty/GLTFSDK/schema/animation.channel.target.schema.json
+++ /dev/null
@@ -1,36 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Animation Channel Target",
-    "type": "object",
-    "description": "The index of the node and TRS property that an animation channel targets.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "node": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the node to target."
-        },
-        "path": {
-            "description": "The name of the node's TRS property to modify, or the \"weights\" of the Morph Targets it instantiates. For the \"translation\" property, the values that are provided by the sampler are the translation along the x, y, and z axes. For the \"rotation\" property, the values are a quaternion in the order (x, y, z, w), where w is the scalar. For the \"scale\" property, the values are the scaling factors along the x, y, and z axes.",
-            "anyOf": [
-                {
-                    "enum": [ "translation" ]
-                },
-                {
-                    "enum": [ "rotation" ]
-                },
-                {
-                    "enum": [ "scale" ]
-                },
-                {
-                    "enum": [ "weights" ]
-                },
-                {
-                    "type": "string"
-                }
-            ]
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "path" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/animation.sampler.schema.json b/thirdparty/GLTFSDK/schema/animation.sampler.schema.json
deleted file mode 100644
index 1cfeb9c..0000000
--- a/thirdparty/GLTFSDK/schema/animation.sampler.schema.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Animation Sampler",
-    "type": "object",
-    "description": "Combines input and output accessors with an interpolation algorithm to define a keyframe graph (but not its target).",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "input": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of an accessor containing keyframe input values, e.g., time.",
-            "gltf_detailedDescription": "The index of an accessor containing keyframe input values, e.g., time. That accessor must have componentType `FLOAT`. The values represent time in seconds with `time[0] >= 0.0`, and strictly increasing values, i.e., `time[n + 1] > time[n]`."
-        },
-        "interpolation": {
-            "description": "Interpolation algorithm.",
-            "default": "LINEAR",
-            "gltf_detailedDescription": "Interpolation algorithm.",
-            "anyOf": [
-                {
-                    "enum": [ "LINEAR" ],
-                    "description": "The animated values are linearly interpolated between keyframes. When targeting a rotation, spherical linear interpolation (slerp) should be used to interpolate quaternions. The number output of elements must equal the number of input elements."
-                },
-                {
-                    "enum": [ "STEP" ],
-                    "description": "The animated values remain constant to the output of the first keyframe, until the next keyframe. The number of output elements must equal the number of input elements."
-                },
-                {
-                    "enum": [ "CUBICSPLINE" ],
-                    "description": "The animation's interpolation is computed using a cubic spline with specified tangents. The number of output elements must equal three times the number of input elements. For each input element, the output stores three elements, an in-tangent, a spline vertex, and an out-tangent. There must be at least two keyframes when using this interpolation."
-                },
-                {
-                    "type": "string"
-                }
-            ]
-        },
-        "output": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of an accessor, containing keyframe output values.",
-            "gltf_detailedDescription": "The index of an accessor containing keyframe output values. When targeting translation or scale paths, the `accessor.componentType` of the output values must be `FLOAT`. When targeting rotation or morph weights, the `accessor.componentType` of the output values must be `FLOAT` or normalized integer. For weights, each output element stores `SCALAR` values with a count equal to the number of morph targets."
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "input", "output" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/animation.schema.json b/thirdparty/GLTFSDK/schema/animation.schema.json
deleted file mode 100644
index 9cb90e3..0000000
--- a/thirdparty/GLTFSDK/schema/animation.schema.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Animation",
-    "type": "object",
-    "description": "A keyframe animation.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "channels": {
-            "type": "array",
-            "description": "An array of channels, each of which targets an animation's sampler at a node's property. Different channels of the same animation can't have equal targets.",
-            "items": {
-                "$ref": "animation.channel.schema.json"
-            },
-            "minItems": 1
-        },
-        "samplers": {
-            "type": "array",
-            "description": "An array of samplers that combines input and output accessors with an interpolation algorithm to define a keyframe graph (but not its target).",
-            "items": {
-                "$ref": "animation.sampler.schema.json"
-            },
-            "minItems": 1
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "channels", "samplers" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/asset.schema.json b/thirdparty/GLTFSDK/schema/asset.schema.json
deleted file mode 100644
index 6f24888..0000000
--- a/thirdparty/GLTFSDK/schema/asset.schema.json
+++ /dev/null
@@ -1,30 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Asset",
-    "type": "object",
-    "description": "Metadata about the glTF asset.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "copyright": {
-            "type": "string",
-            "description": "A copyright message suitable for display to credit the content creator."
-        },
-        "generator": {
-            "type": "string",
-            "description": "Tool that generated this glTF model.  Useful for debugging."
-        },
-        "version": {
-            "type": "string",
-            "description": "The glTF version that this asset targets.",
-            "pattern": "^[0-9]+\\.[0-9]+$"
-        },
-        "minVersion": {
-            "type": "string",
-            "description": "The minimum glTF version that this asset targets.",
-            "pattern": "^[0-9]+\\.[0-9]+$"
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "version" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/buffer.schema.json b/thirdparty/GLTFSDK/schema/buffer.schema.json
deleted file mode 100644
index a3c6b81..0000000
--- a/thirdparty/GLTFSDK/schema/buffer.schema.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Buffer",
-    "type": "object",
-    "description": "A buffer points to binary geometry, animation, or skins.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "uri": {
-            "type": "string",
-            "description": "The uri of the buffer.",
-            "format": "uriref",
-            "gltf_detailedDescription": "The uri of the buffer.  Relative paths are relative to the .gltf file.  Instead of referencing an external file, the uri can also be a data-uri.",
-            "gltf_uriType": "application"
-        },
-        "byteLength": {
-            "type": "integer",
-            "description": "The length of the buffer in bytes.",
-            "minimum": 1
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "byteLength" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/bufferView.schema.json b/thirdparty/GLTFSDK/schema/bufferView.schema.json
deleted file mode 100644
index b8addb7..0000000
--- a/thirdparty/GLTFSDK/schema/bufferView.schema.json
+++ /dev/null
@@ -1,54 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Buffer View",
-    "type": "object",
-    "description": "A view into a buffer generally representing a subset of the buffer.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "buffer": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the buffer."
-        },
-        "byteOffset": {
-            "type": "integer",
-            "description": "The offset into the buffer in bytes.",
-            "minimum": 0,
-            "default": 0
-        },
-        "byteLength": {
-            "type": "integer",
-            "description": "The length of the bufferView in bytes.",
-            "minimum": 1
-        },
-        "byteStride": {
-            "type": "integer",
-            "description": "The stride, in bytes.",
-            "minimum": 4,
-            "maximum": 252,
-            "multipleOf": 4,
-            "gltf_detailedDescription": "The stride, in bytes, between vertex attributes.  When this is not defined, data is tightly packed. When two or more accessors use the same bufferView, this field must be defined.",
-            "gltf_webgl": "`vertexAttribPointer()` stride parameter"
-        },
-        "target": {
-            "description": "The target that the GPU buffer should be bound to.",
-            "gltf_webgl": "`bindBuffer()`",
-            "anyOf": [
-                {
-                    "enum": [ 34962 ],
-                    "description": "ARRAY_BUFFER"
-                },
-                {
-                    "enum": [ 34963 ],
-                    "description": "ELEMENT_ARRAY_BUFFER"
-                },
-                {
-                    "type": "integer"
-                }
-            ]
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "buffer", "byteLength" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/camera.orthographic.schema.json b/thirdparty/GLTFSDK/schema/camera.orthographic.schema.json
deleted file mode 100644
index 47e10da..0000000
--- a/thirdparty/GLTFSDK/schema/camera.orthographic.schema.json
+++ /dev/null
@@ -1,31 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Camera Orthographic",
-    "type": "object",
-    "description": "An orthographic camera containing properties to create an orthographic projection matrix.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "xmag": {
-            "type": "number",
-            "description": "The floating-point horizontal magnification of the view. Must not be zero."
-        },
-        "ymag": {
-            "type": "number",
-            "description": "The floating-point vertical magnification of the view. Must not be zero."
-        },
-        "zfar": {
-            "type": "number",
-            "description": "The floating-point distance to the far clipping plane. `zfar` must be greater than `znear`.",
-            "minimum": 0.0,
-            "exclusiveMinimum": true
-        },
-        "znear": {
-            "type": "number",
-            "description": "The floating-point distance to the near clipping plane.",
-            "minimum": 0.0
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "xmag", "ymag", "zfar", "znear" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/camera.perspective.schema.json b/thirdparty/GLTFSDK/schema/camera.perspective.schema.json
deleted file mode 100644
index a7e7426..0000000
--- a/thirdparty/GLTFSDK/schema/camera.perspective.schema.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Camera Perspective",
-    "type": "object",
-    "description": "A perspective camera containing properties to create a perspective projection matrix.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "aspectRatio": {
-            "type": "number",
-            "description": "The floating-point aspect ratio of the field of view.",
-            "minimum": 0.0,
-            "exclusiveMinimum": true,
-            "gltf_detailedDescription": "The floating-point aspect ratio of the field of view. When this is undefined, the aspect ratio of the canvas is used."
-        },
-        "yfov": {
-            "type": "number",
-            "description": "The floating-point vertical field of view in radians.",
-            "minimum": 0.0,
-            "exclusiveMinimum": true
-        },
-        "zfar": {
-            "type": "number",
-            "description": "The floating-point distance to the far clipping plane.",
-            "minimum": 0.0,
-            "exclusiveMinimum": true,
-            "gltf_detailedDescription": "The floating-point distance to the far clipping plane. When defined, `zfar` must be greater than `znear`. If `zfar` is undefined, runtime must use infinite projection matrix."
-        },
-        "znear": {
-            "type": "number",
-            "description": "The floating-point distance to the near clipping plane.",
-            "minimum": 0.0,
-            "exclusiveMinimum": true,
-            "gltf_detailedDescription": "The floating-point distance to the near clipping plane."
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "yfov", "znear" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/camera.schema.json b/thirdparty/GLTFSDK/schema/camera.schema.json
deleted file mode 100644
index 6f32da3..0000000
--- a/thirdparty/GLTFSDK/schema/camera.schema.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Camera",
-    "type": "object",
-    "description": "A camera's projection.  A node can reference a camera to apply a transform to place the camera in the scene.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "orthographic": {
-            "allOf": [ { "$ref": "camera.orthographic.schema.json" } ],
-            "description": "An orthographic camera containing properties to create an orthographic projection matrix."
-        },
-        "perspective": {
-            "allOf": [ { "$ref": "camera.perspective.schema.json" } ],
-            "description": "A perspective camera containing properties to create a perspective projection matrix."
-        },
-        "type": {
-            "description": "Specifies if the camera uses a perspective or orthographic projection.",
-            "gltf_detailedDescription": "Specifies if the camera uses a perspective or orthographic projection.  Based on this, either the camera's `perspective` or `orthographic` property will be defined.",
-            "anyOf": [
-                {
-                    "enum": [ "perspective" ]
-                },
-                {
-                    "enum": [ "orthographic" ]
-                },
-                {
-                    "type": "string"
-                }
-            ]
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "type" ],
-    "not": {
-        "required": [ "perspective", "orthographic" ]
-    }
-}
diff --git a/thirdparty/GLTFSDK/schema/extension.schema.json b/thirdparty/GLTFSDK/schema/extension.schema.json
deleted file mode 100644
index ca2dccd..0000000
--- a/thirdparty/GLTFSDK/schema/extension.schema.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Extension",
-    "type": "object",
-    "description": "Dictionary object with extension-specific objects.",
-    "properties": {
-    },
-    "additionalProperties": {
-        "type": "object"
-    }
-}
diff --git a/thirdparty/GLTFSDK/schema/extras.schema.json b/thirdparty/GLTFSDK/schema/extras.schema.json
deleted file mode 100644
index ff872b5..0000000
--- a/thirdparty/GLTFSDK/schema/extras.schema.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Extras",
-    "description": "Application-specific data."
-}
diff --git a/thirdparty/GLTFSDK/schema/glTF.schema.json b/thirdparty/GLTFSDK/schema/glTF.schema.json
deleted file mode 100644
index e5f0331..0000000
--- a/thirdparty/GLTFSDK/schema/glTF.schema.json
+++ /dev/null
@@ -1,154 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "glTF",
-    "type": "object",
-    "description": "The root object for a glTF asset.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "extensionsUsed": {
-            "type": "array",
-            "description": "Names of glTF extensions used somewhere in this asset.",
-            "items": {
-                "type": "string"
-            },
-            "uniqueItems": true,
-            "minItems": 1
-        },
-        "extensionsRequired": {
-            "type": "array",
-            "description": "Names of glTF extensions required to properly load this asset.",
-            "items": {
-                "type": "string"
-            },
-            "uniqueItems": true,
-            "minItems": 1
-        },
-        "accessors": {
-            "type": "array",
-            "description": "An array of accessors.",
-            "items": {
-                "$ref": "accessor.schema.json"
-            },
-            "minItems": 1,
-            "gltf_detailedDescription": "An array of accessors.  An accessor is a typed view into a bufferView."
-        },
-        "animations": {
-            "type": "array",
-            "description": "An array of keyframe animations.",
-            "items": {
-                "$ref": "animation.schema.json"
-            },
-            "minItems": 1
-        },
-        "asset": {
-            "allOf": [ { "$ref": "asset.schema.json" } ],
-            "description": "Metadata about the glTF asset."
-        },
-        "buffers": {
-            "type": "array",
-            "description": "An array of buffers.",
-            "items": {
-                "$ref": "buffer.schema.json"
-            },
-            "minItems": 1,
-            "gltf_detailedDescription": "An array of buffers.  A buffer points to binary geometry, animation, or skins."
-        },
-        "bufferViews": {
-            "type": "array",
-            "description": "An array of bufferViews.",
-            "items": {
-                "$ref": "bufferView.schema.json"
-            },
-            "minItems": 1,
-            "gltf_detailedDescription": "An array of bufferViews.  A bufferView is a view into a buffer generally representing a subset of the buffer."
-        },
-        "cameras": {
-            "type": "array",
-            "description": "An array of cameras.",
-            "items": {
-                "$ref": "camera.schema.json"
-            },
-            "minItems": 1,
-            "gltf_detailedDescription": "An array of cameras.  A camera defines a projection matrix."
-        },
-        "images": {
-            "type": "array",
-            "description": "An array of images.",
-            "items": {
-                "$ref": "image.schema.json"
-            },
-            "minItems": 1,
-            "gltf_detailedDescription": "An array of images.  An image defines data used to create a texture."
-        },
-        "materials": {
-            "type": "array",
-            "description": "An array of materials.",
-            "items": {
-                "$ref": "material.schema.json"
-            },
-            "minItems": 1,
-            "gltf_detailedDescription": "An array of materials.  A material defines the appearance of a primitive."
-        },
-        "meshes": {
-            "type": "array",
-            "description": "An array of meshes.",
-            "items": {
-                "$ref": "mesh.schema.json"
-            },
-            "minItems": 1,
-            "gltf_detailedDescription": "An array of meshes.  A mesh is a set of primitives to be rendered."
-        },
-        "nodes": {
-            "type": "array",
-            "description": "An array of nodes.",
-            "items": {
-                "$ref": "node.schema.json"
-            },
-            "minItems": 1
-        },
-        "samplers": {
-            "type": "array",
-            "description": "An array of samplers.",
-            "items": {
-                "$ref": "sampler.schema.json"
-            },
-            "minItems": 1,
-            "gltf_detailedDescription": "An array of samplers.  A sampler contains properties for texture filtering and wrapping modes."
-        },
-        "scene": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the default scene."
-        },
-        "scenes": {
-            "type": "array",
-            "description": "An array of scenes.",
-            "items": {
-                "$ref": "scene.schema.json"
-            },
-            "minItems": 1
-        },
-        "skins": {
-            "type": "array",
-            "description": "An array of skins.",
-            "items": {
-                "$ref": "skin.schema.json"
-            },
-            "minItems": 1,
-            "gltf_detailedDescription": "An array of skins.  A skin is defined by joints and matrices."
-        },
-        "textures": {
-            "type": "array",
-            "description": "An array of textures.",
-            "items": {
-                "$ref": "texture.schema.json"
-            },
-            "minItems": 1
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "dependencies": {
-        "scene": [ "scenes" ]
-    },
-    "required": [ "asset" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/glTFChildOfRootProperty.schema.json b/thirdparty/GLTFSDK/schema/glTFChildOfRootProperty.schema.json
deleted file mode 100644
index acb110b..0000000
--- a/thirdparty/GLTFSDK/schema/glTFChildOfRootProperty.schema.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "glTF Child of Root Property",
-    "type": "object",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "name": {
-            "type": "string",
-            "description": "The user-defined name of this object.",
-            "gltf_detailedDescription": "The user-defined name of this object.  This is not necessarily unique, e.g., an accessor and a buffer could have the same name, or two accessors could even have the same name."
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/schema/glTFProperty.schema.json b/thirdparty/GLTFSDK/schema/glTFProperty.schema.json
deleted file mode 100644
index e875aac..0000000
--- a/thirdparty/GLTFSDK/schema/glTFProperty.schema.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "glTF Property",
-    "type": "object",
-    "properties": {
-        "extensions": {
-            "$ref": "extension.schema.json"
-        },
-        "extras": {
-            "$ref": "extras.schema.json"
-        }
-    }
-}
diff --git a/thirdparty/GLTFSDK/schema/glTFid.schema.json b/thirdparty/GLTFSDK/schema/glTFid.schema.json
deleted file mode 100644
index 6fcda5a..0000000
--- a/thirdparty/GLTFSDK/schema/glTFid.schema.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "glTF Id",
-    "type": "integer",
-    "minimum": 0
-}
diff --git a/thirdparty/GLTFSDK/schema/image.schema.json b/thirdparty/GLTFSDK/schema/image.schema.json
deleted file mode 100644
index 81dcceb..0000000
--- a/thirdparty/GLTFSDK/schema/image.schema.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Image",
-    "type": "object",
-    "description": "Image data used to create a texture. Image can be referenced by URI or `bufferView` index. `mimeType` is required in the latter case.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "uri": {
-            "type": "string",
-            "description": "The uri of the image.",
-            "format": "uriref",
-            "gltf_detailedDescription": "The uri of the image.  Relative paths are relative to the .gltf file.  Instead of referencing an external file, the uri can also be a data-uri.  The image format must be jpg or png.",
-            "gltf_uriType": "image"
-        },
-        "mimeType": {
-            "anyOf": [
-                {
-                    "enum": [ "image/jpeg" ]
-                },
-                {
-                    "enum": [ "image/png" ]
-                },
-                {
-                    "type": "string"
-                }
-            ],
-            "description": "The image's MIME type."
-        },
-        "bufferView": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the bufferView that contains the image. Use this instead of the image's uri property."
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "dependencies": {
-        "bufferView": [ "mimeType" ]
-    },
-    "oneOf": [
-        { "required": [ "uri" ] },
-        { "required": [ "bufferView" ] }
-    ]
-}
diff --git a/thirdparty/GLTFSDK/schema/material.normalTextureInfo.schema.json b/thirdparty/GLTFSDK/schema/material.normalTextureInfo.schema.json
deleted file mode 100644
index 6df0cad..0000000
--- a/thirdparty/GLTFSDK/schema/material.normalTextureInfo.schema.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Material Normal Texture Info",
-    "type": "object",
-    "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-    "properties": {
-        "index": { },
-        "texCoord": { },
-        "scale": {
-            "type": "number",
-            "description": "The scalar multiplier applied to each normal vector of the normal texture.",
-            "default": 1.0,
-            "gltf_detailedDescription": "The scalar multiplier applied to each normal vector of the texture. This value scales the normal vector using the formula: `scaledNormal =  normalize((normalize(<sampled normal texture value>) * 2.0 - 1.0) * vec3(<normal scale>, <normal scale>, 1.0))`. This value is ignored if normalTexture is not specified. This value is linear."
-        },
-        "extensions": { },
-        "extras": { }
-    }
-}
\ No newline at end of file
diff --git a/thirdparty/GLTFSDK/schema/material.occlusionTextureInfo.schema.json b/thirdparty/GLTFSDK/schema/material.occlusionTextureInfo.schema.json
deleted file mode 100644
index a32f6a3..0000000
--- a/thirdparty/GLTFSDK/schema/material.occlusionTextureInfo.schema.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Material Occlusion Texture Info",
-    "type": "object",
-    "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-    "properties": {
-        "index": { },
-        "texCoord": { },
-        "strength": {
-            "type": "number",
-            "description": "A scalar multiplier controlling the amount of occlusion applied.",
-            "default": 1.0,
-            "minimum": 0.0,
-            "maximum": 1.0,
-            "gltf_detailedDescription": "A scalar multiplier controlling the amount of occlusion applied. A value of 0.0 means no occlusion. A value of 1.0 means full occlusion. This value affects the resulting color using the formula: `occludedColor = lerp(color, color * <sampled occlusion texture value>, <occlusion strength>)`. This value is ignored if the corresponding texture is not specified. This value is linear."
-        },
-        "extensions": { },
-        "extras": { }
-    }
-}
\ No newline at end of file
diff --git a/thirdparty/GLTFSDK/schema/material.pbrMetallicRoughness.schema.json b/thirdparty/GLTFSDK/schema/material.pbrMetallicRoughness.schema.json
deleted file mode 100644
index a812f69..0000000
--- a/thirdparty/GLTFSDK/schema/material.pbrMetallicRoughness.schema.json
+++ /dev/null
@@ -1,50 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Material PBR Metallic Roughness",
-    "type": "object",
-    "description": "A set of parameter values that are used to define the metallic-roughness material model from Physically-Based Rendering (PBR) methodology.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "baseColorFactor": {
-            "type": "array",
-            "items": {
-                "type": "number",
-                "minimum": 0.0,
-                "maximum": 1.0
-            },
-            "description": "The material's base color factor.",
-            "default": [ 1.0, 1.0, 1.0, 1.0 ],
-            "minItems": 4,
-            "maxItems": 4,
-            "gltf_detailedDescription": "The RGBA components of the base color of the material. The fourth component (A) is the alpha coverage of the material. The `alphaMode` property specifies how alpha is interpreted. These values are linear. If a baseColorTexture is specified, this value is multiplied with the texel values."
-        },
-        "baseColorTexture": {
-            "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-            "description": "The base color texture.",
-            "gltf_detailedDescription": "The base color texture. This texture contains RGB(A) components in sRGB color space. The first three components (RGB) specify the base color of the material. If the fourth component (A) is present, it represents the alpha coverage of the material. Otherwise, an alpha of 1.0 is assumed. The `alphaMode` property specifies how alpha is interpreted. The stored texels must not be premultiplied."
-        },
-        "metallicFactor": {
-            "type": "number",
-            "description": "The metalness of the material.",
-            "default": 1.0,
-            "minimum": 0.0,
-            "maximum": 1.0,
-            "gltf_detailedDescription": "The metalness of the material. A value of 1.0 means the material is a metal. A value of 0.0 means the material is a dielectric. Values in between are for blending between metals and dielectrics such as dirty metallic surfaces. This value is linear. If a metallicRoughnessTexture is specified, this value is multiplied with the metallic texel values."
-        },
-        "roughnessFactor": {
-            "type": "number",
-            "description": "The roughness of the material.",
-            "default": 1.0,
-            "minimum": 0.0,
-            "maximum": 1.0,
-            "gltf_detailedDescription": "The roughness of the material. A value of 1.0 means the material is completely rough. A value of 0.0 means the material is completely smooth. This value is linear. If a metallicRoughnessTexture is specified, this value is multiplied with the roughness texel values."
-        },
-        "metallicRoughnessTexture": {
-            "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-            "description": "The metallic-roughness texture.",
-            "gltf_detailedDescription": "The metallic-roughness texture. The metalness values are sampled from the B channel. The roughness values are sampled from the G channel. These values are linear. If other channels are present (R or A), they are ignored for metallic-roughness calculations."
-        },
-        "extensions": { },
-        "extras": { }
-    }
-}
\ No newline at end of file
diff --git a/thirdparty/GLTFSDK/schema/material.schema.json b/thirdparty/GLTFSDK/schema/material.schema.json
deleted file mode 100644
index cbdbadc..0000000
--- a/thirdparty/GLTFSDK/schema/material.schema.json
+++ /dev/null
@@ -1,82 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Material",
-    "type": "object",
-    "description": "The material appearance of a primitive.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "name": { },
-        "extensions": { },
-        "extras": { },
-        "pbrMetallicRoughness": {
-            "allOf": [ { "$ref": "material.pbrMetallicRoughness.schema.json" } ],
-            "description": "A set of parameter values that are used to define the metallic-roughness material model from Physically-Based Rendering (PBR) methodology. When not specified, all the default values of `pbrMetallicRoughness` apply."
-        },
-        "normalTexture": {
-            "allOf": [ { "$ref": "material.normalTextureInfo.schema.json" } ],
-            "description": "The normal map texture.",
-            "gltf_detailedDescription": "A tangent space normal map. The texture contains RGB components in linear space. Each texel represents the XYZ components of a normal vector in tangent space. Red [0 to 255] maps to X [-1 to 1]. Green [0 to 255] maps to Y [-1 to 1]. Blue [128 to 255] maps to Z [1/255 to 1]. The normal vectors use OpenGL conventions where +X is right and +Y is up. +Z points toward the viewer. In GLSL, this vector would be unpacked like so: `float3 normalVector = tex2D(<sampled normal map texture value>, texCoord) * 2 - 1`. Client implementations should normalize the normal vectors before using them in lighting equations."
-        },
-        "occlusionTexture": {
-            "allOf": [ { "$ref": "material.occlusionTextureInfo.schema.json" } ],
-            "description": "The occlusion map texture.",
-            "gltf_detailedDescription": "The occlusion map texture. The occlusion values are sampled from the R channel. Higher values indicate areas that should receive full indirect lighting and lower values indicate no indirect lighting. These values are linear. If other channels are present (GBA), they are ignored for occlusion calculations."
-        },
-        "emissiveTexture": {
-            "allOf": [ { "$ref": "textureInfo.schema.json" } ],
-            "description": "The emissive map texture.",
-            "gltf_detailedDescription": "The emissive map controls the color and intensity of the light being emitted by the material. This texture contains RGB components in sRGB color space. If a fourth component (A) is present, it is ignored."
-        },
-        "emissiveFactor": {
-            "type": "array",
-            "items": {
-                "type": "number",
-                "minimum": 0.0,
-                "maximum": 1.0
-            },
-            "minItems": 3,
-            "maxItems": 3,
-            "default": [ 0.0, 0.0, 0.0 ],
-            "description": "The emissive color of the material.",
-            "gltf_detailedDescription": "The RGB components of the emissive color of the material. These values are linear. If an emissiveTexture is specified, this value is multiplied with the texel values."
-        },
-        "alphaMode": {
-            "default": "OPAQUE",
-            "description": "The alpha rendering mode of the material.",
-            "gltf_detailedDescription": "The material's alpha rendering mode enumeration specifying the interpretation of the alpha value of the main factor and texture.",
-            "anyOf": [
-                {
-                    "enum": [ "OPAQUE" ],
-                    "description": "The alpha value is ignored and the rendered output is fully opaque."
-                },
-                {
-                    "enum": [ "MASK" ],
-                    "description": "The rendered output is either fully opaque or fully transparent depending on the alpha value and the specified alpha cutoff value."
-                },
-                {
-                    "enum": [ "BLEND" ],
-                    "description": "The alpha value is used to composite the source and destination areas. The rendered output is combined with the background using the normal painting operation (i.e. the Porter and Duff over operator)."
-                },
-                {
-                    "type": "string"
-                }
-            ]
-        },
-        "alphaCutoff": {
-            "type": "number",
-            "minimum": 0.0,
-            "default": 0.5,
-            "description": "The alpha cutoff value of the material.",
-            "gltf_detailedDescription": "Specifies the cutoff threshold when in `MASK` mode. If the alpha value is greater than or equal to this value then it is rendered as fully opaque, otherwise, it is rendered as fully transparent. A value greater than 1.0 will render the entire material as fully transparent. This value is ignored for other modes."
-        },
-        "doubleSided": {
-            "type": "boolean",
-            "default": false,
-            "description": "Specifies whether the material is double sided.",
-            "gltf_detailedDescription": "Specifies whether the material is double sided. When this value is false, back-face culling is enabled. When this value is true, back-face culling is disabled and double sided lighting is enabled. The back-face must have its normals reversed before the lighting equation is evaluated."
-        }
-    },
-     "dependencies" : {
-        "alphaCutoff" : ["alphaMode"]
-    }
-}
diff --git a/thirdparty/GLTFSDK/schema/mesh.primitive.schema.json b/thirdparty/GLTFSDK/schema/mesh.primitive.schema.json
deleted file mode 100644
index 78c89da..0000000
--- a/thirdparty/GLTFSDK/schema/mesh.primitive.schema.json
+++ /dev/null
@@ -1,81 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Mesh Primitive",
-    "type": "object",
-    "description": "Geometry to be rendered with the given material.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "attributes": {
-            "type": "object",
-            "description": "A dictionary object, where each key corresponds to mesh attribute semantic and each value is the index of the accessor containing attribute's data.",
-            "minProperties": 1,
-            "additionalProperties": {
-                "$ref": "glTFid.schema.json"
-            }
-        },
-        "indices": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the accessor that contains the indices.",
-            "gltf_detailedDescription": "The index of the accessor that contains mesh indices.  When this is not defined, the primitives should be rendered without indices using `drawArrays()`.  When defined, the accessor must contain indices: the `bufferView` referenced by the accessor should have a `target` equal to 34963 (ELEMENT_ARRAY_BUFFER); `componentType` must be 5121 (UNSIGNED_BYTE), 5123 (UNSIGNED_SHORT) or 5125 (UNSIGNED_INT), the latter may require enabling additional hardware support; `type` must be `\"SCALAR\"`. For triangle primitives, the front face has a counter-clockwise (CCW) winding order."
-        },
-        "material": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the material to apply to this primitive when rendering."
-        },
-        "mode": {
-            "description": "The type of primitives to render.",
-            "default": 4,
-            "gltf_detailedDescription": "The type of primitives to render. All valid values correspond to WebGL enums.",
-            "anyOf": [
-                {
-                    "enum": [ 0 ],
-                    "description": "POINTS"
-                },
-                {
-                    "enum": [ 1 ],
-                    "description": "LINES"
-                },
-                {
-                    "enum": [ 2 ],
-                    "description": "LINE_LOOP"
-                },
-                {
-                    "enum": [ 3 ],
-                    "description": "LINE_STRIP"
-                },
-                {
-                    "enum": [ 4 ],
-                    "description": "TRIANGLES"
-                },
-                {
-                    "enum": [ 5 ],
-                    "description": "TRIANGLE_STRIP"
-                },
-                {
-                    "enum": [ 6 ],
-                    "description": "TRIANGLE_FAN"
-                },
-                {
-                    "type": "integer"
-                }
-            ]
-        },
-        "targets": {
-            "type": "array",
-            "description": "An array of Morph Targets, each  Morph Target is a dictionary mapping attributes (only `POSITION`, `NORMAL`, and `TANGENT` supported) to their deviations in the Morph Target.",
-            "items": {
-                "type": "object",
-                "minProperties": 1,
-                "additionalProperties": {
-                    "$ref": "glTFid.schema.json"
-                },
-                "description": "A dictionary object specifying attributes displacements in a Morph Target, where each key corresponds to one of the three supported attribute semantic (`POSITION`, `NORMAL`, or `TANGENT`) and each value is the index of the accessor containing the attribute displacements' data."
-            },
-            "minItems": 1
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "gltf_webgl": "`drawElements()` and `drawArrays()`",
-    "required": [ "attributes" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/mesh.schema.json b/thirdparty/GLTFSDK/schema/mesh.schema.json
deleted file mode 100644
index 929eae2..0000000
--- a/thirdparty/GLTFSDK/schema/mesh.schema.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Mesh",
-    "type": "object",
-    "description": "A set of primitives to be rendered.  A node can contain one mesh.  A node's transform places the mesh in the scene.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "primitives": {
-            "type": "array",
-            "description": "An array of primitives, each defining geometry to be rendered with a material.",
-            "items": {
-                "$ref": "mesh.primitive.schema.json"
-            },
-            "minItems": 1
-        },
-        "weights": {
-            "type": "array",
-            "description": "Array of weights to be applied to the Morph Targets.",
-            "items": {
-                "type": "number"
-            },
-            "minItems": 1
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "primitives" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/node.schema.json b/thirdparty/GLTFSDK/schema/node.schema.json
deleted file mode 100644
index ee9225c..0000000
--- a/thirdparty/GLTFSDK/schema/node.schema.json
+++ /dev/null
@@ -1,96 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Node",
-    "type": "object",
-    "description": "A node in the node hierarchy.  When the node contains `skin`, all `mesh.primitives` must contain `JOINTS_0` and `WEIGHTS_0` attributes.  A node can have either a `matrix` or any combination of `translation`/`rotation`/`scale` (TRS) properties. TRS properties are converted to matrices and postmultiplied in the `T * R * S` order to compose the transformation matrix; first the scale is applied to the vertices, then the rotation, and then the translation. If none are provided, the transform is the identity. When a node is targeted for animation (referenced by an animation.channel.target), only TRS properties may be present; `matrix` will not be present.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "camera": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the camera referenced by this node."
-        },
-        "children": {
-            "type": "array",
-            "description": "The indices of this node's children.",
-            "items": {
-                "$ref": "glTFid.schema.json"
-            },
-            "uniqueItems": true,
-            "minItems": 1
-        },
-        "skin": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the skin referenced by this node."
-        },
-        "matrix": {
-            "type": "array",
-            "description": "A floating-point 4x4 transformation matrix stored in column-major order.",
-            "items": {
-                "type": "number"
-            },
-            "minItems": 16,
-            "maxItems": 16,
-            "default": [ 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 ],
-            "gltf_detailedDescription": "A floating-point 4x4 transformation matrix stored in column-major order.",
-            "gltf_webgl": "`uniformMatrix4fv()` with the transpose parameter equal to false"
-        },
-        "mesh": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the mesh in this node."
-        },
-        "rotation": {
-            "type": "array",
-            "description": "The node's unit quaternion rotation in the order (x, y, z, w), where w is the scalar.",
-            "items": {
-                "type": "number",
-                "minimum": -1.0,
-                "maximum": 1.0
-            },
-            "minItems": 4,
-            "maxItems": 4,
-            "default": [ 0.0, 0.0, 0.0, 1.0 ]
-        },
-        "scale": {
-            "type": "array",
-            "description": "The node's non-uniform scale, given as the scaling factors along the x, y, and z axes.",
-            "items": {
-                "type": "number"
-            },
-            "minItems": 3,
-            "maxItems": 3,
-            "default": [ 1.0, 1.0, 1.0 ]
-        },
-        "translation": {
-            "type": "array",
-            "description": "The node's translation along the x, y, and z axes.",
-            "items": {
-                "type": "number"
-            },
-            "minItems": 3,
-            "maxItems": 3,
-            "default": [ 0.0, 0.0, 0.0 ]
-        },
-        "weights": {
-            "type": "array",
-            "description": "The weights of the instantiated Morph Target. Number of elements must match number of Morph Targets of used mesh.",
-            "minItems": 1,
-            "items": {
-                "type": "number"
-            }
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "dependencies": {
-        "weights": [ "mesh" ],
-        "skin": [ "mesh" ]
-    },
-    "not": {
-        "anyOf": [
-            { "required": [ "matrix", "translation" ] },
-            { "required": [ "matrix", "rotation" ] },
-            { "required": [ "matrix", "scale" ] }
-        ]
-    }
-}
diff --git a/thirdparty/GLTFSDK/schema/sampler.schema.json b/thirdparty/GLTFSDK/schema/sampler.schema.json
deleted file mode 100644
index fb6da83..0000000
--- a/thirdparty/GLTFSDK/schema/sampler.schema.json
+++ /dev/null
@@ -1,111 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Sampler",
-    "type": "object",
-    "description": "Texture sampler properties for filtering and wrapping modes.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "magFilter": {
-            "description": "Magnification filter.",
-            "gltf_detailedDescription": "Magnification filter.  Valid values correspond to WebGL enums: `9728` (NEAREST) and `9729` (LINEAR).",
-            "gltf_webgl": "`texParameterf()` with pname equal to TEXTURE_MAG_FILTER",
-            "anyOf": [
-                {
-                    "enum": [ 9728 ],
-                    "description": "NEAREST"
-                },
-                {
-                    "enum": [ 9729 ],
-                    "description": "LINEAR"
-                },
-                {
-                    "type": "integer"
-                }
-            ]
-        },
-        "minFilter": {
-            "description": "Minification filter.",
-            "gltf_detailedDescription": "Minification filter.  All valid values correspond to WebGL enums.",
-            "gltf_webgl": "`texParameterf()` with pname equal to TEXTURE_MIN_FILTER",
-            "anyOf": [
-                {
-                    "enum": [ 9728 ],
-                    "description": "NEAREST"
-                },
-                {
-                    "enum": [ 9729 ],
-                    "description": "LINEAR"
-                },
-                {
-                    "enum": [ 9984 ],
-                    "description": "NEAREST_MIPMAP_NEAREST"
-                },
-                {
-                    "enum": [ 9985 ],
-                    "description": "LINEAR_MIPMAP_NEAREST"
-                },
-                {
-                    "enum": [ 9986 ],
-                    "description": "NEAREST_MIPMAP_LINEAR"
-                },
-                {
-                    "enum": [ 9987 ],
-                    "description": "LINEAR_MIPMAP_LINEAR"
-                },
-                {
-                    "type": "integer"
-                }
-            ]
-        },
-        "wrapS": {
-            "description": "s wrapping mode.",
-            "default": 10497,
-            "gltf_detailedDescription": "S (U) wrapping mode.  All valid values correspond to WebGL enums.",
-            "gltf_webgl": "`texParameterf()` with pname equal to TEXTURE_WRAP_S",
-            "anyOf": [
-                {
-                    "enum": [ 33071 ],
-                    "description": "CLAMP_TO_EDGE"
-                },
-                {
-                    "enum": [ 33648 ],
-                    "description": "MIRRORED_REPEAT"
-                },
-                {
-                    "enum": [ 10497 ],
-                    "description": "REPEAT"
-                },
-                {
-                    "type": "integer"
-                }
-            ]
-        },
-        "wrapT": {
-            "description": "t wrapping mode.",
-            "default": 10497,
-            "gltf_detailedDescription": "T (V) wrapping mode.  All valid values correspond to WebGL enums.",
-            "gltf_webgl": "`texParameterf()` with pname equal to TEXTURE_WRAP_T",
-            "anyOf": [
-                {
-                    "enum": [ 33071 ],
-                    "description": "CLAMP_TO_EDGE"
-                },
-                {
-                    "enum": [ 33648 ],
-                    "description": "MIRRORED_REPEAT"
-                },
-                {
-                    "enum": [ 10497 ],
-                    "description": "REPEAT"
-                },
-                {
-                    "type": "integer"
-                }
-            ]
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "gltf_webgl": "`texParameterf()`"
-}
diff --git a/thirdparty/GLTFSDK/schema/scene.schema.json b/thirdparty/GLTFSDK/schema/scene.schema.json
deleted file mode 100644
index 91a31f5..0000000
--- a/thirdparty/GLTFSDK/schema/scene.schema.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Scene",
-    "type": "object",
-    "description": "The root nodes of a scene.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "nodes": {
-            "type": "array",
-            "description": "The indices of each root node.",
-            "items": {
-                "$ref": "glTFid.schema.json"
-            },
-            "uniqueItems": true,
-            "minItems": 1
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    }
-}
diff --git a/thirdparty/GLTFSDK/schema/skin.schema.json b/thirdparty/GLTFSDK/schema/skin.schema.json
deleted file mode 100644
index b02b3c7..0000000
--- a/thirdparty/GLTFSDK/schema/skin.schema.json
+++ /dev/null
@@ -1,31 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Skin",
-    "type": "object",
-    "description": "Joints and matrices defining a skin.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "inverseBindMatrices": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the accessor containing the floating-point 4x4 inverse-bind matrices.  The default is that each matrix is a 4x4 identity matrix, which implies that inverse-bind matrices were pre-applied."
-        },
-        "skeleton": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the node used as a skeleton root. When undefined, joints transforms resolve to scene root."
-        },
-        "joints": {
-            "type": "array",
-            "description": "Indices of skeleton nodes, used as joints in this skin.",
-            "items": {
-                "$ref": "glTFid.schema.json"
-            },
-            "uniqueItems": true,
-            "minItems": 1,
-            "gltf_detailedDescription": "Indices of skeleton nodes, used as joints in this skin.  The array length must be the same as the `count` property of the `inverseBindMatrices` accessor (when defined)."
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "joints" ]
-}
diff --git a/thirdparty/GLTFSDK/schema/texture.schema.json b/thirdparty/GLTFSDK/schema/texture.schema.json
deleted file mode 100644
index d5390c4..0000000
--- a/thirdparty/GLTFSDK/schema/texture.schema.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Texture",
-    "type": "object",
-    "description": "A texture and its sampler.",
-    "allOf": [ { "$ref": "glTFChildOfRootProperty.schema.json" } ],
-    "properties": {
-        "sampler": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the sampler used by this texture. When undefined, a sampler with repeat wrapping and auto filtering should be used."
-        },
-        "source": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the image used by this texture."
-        },
-        "name": { },
-        "extensions": { },
-        "extras": { }
-    },
-    "gltf_webgl": "`createTexture()`, `deleteTexture()`, `bindTexture()`, `texImage2D()`, and `texParameterf()`"
-}
diff --git a/thirdparty/GLTFSDK/schema/textureInfo.schema.json b/thirdparty/GLTFSDK/schema/textureInfo.schema.json
deleted file mode 100644
index 86a2df5..0000000
--- a/thirdparty/GLTFSDK/schema/textureInfo.schema.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema",
-    "title": "Texture Info",
-    "type": "object",
-    "description": "Reference to a texture.",
-    "allOf": [ { "$ref": "glTFProperty.schema.json" } ],
-    "properties": {
-        "index": {
-            "allOf": [ { "$ref": "glTFid.schema.json" } ],
-            "description": "The index of the texture."
-        },
-        "texCoord": {
-            "type": "integer",
-            "description": "The set index of texture's TEXCOORD attribute used for texture coordinate mapping.",
-            "default": 0,
-            "minimum": 0,
-            "gltf_detailedDescription": "This integer value is used to construct a string in the format `TEXCOORD_<set index>` which is a reference to a key in mesh.primitives.attributes (e.g. A value of `0` corresponds to `TEXCOORD_0`). Mesh must have corresponding texture coordinate attributes for the material to be applicable to it."
-        },
-        "extensions": { },
-        "extras": { }
-    },
-    "required": [ "index" ]
-}
\ No newline at end of file
diff --git a/thirdparty/directxmath/DirectXCollision.h b/thirdparty/directxmath/DirectXCollision.h
deleted file mode 100644
index 9cf5e27..0000000
--- a/thirdparty/directxmath/DirectXCollision.h
+++ /dev/null
@@ -1,359 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXCollision.h -- C++ Collision Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-#include "./DirectXMath.h"
-
-namespace DirectX
-{
-
-    enum ContainmentType
-    {
-        DISJOINT = 0,
-        INTERSECTS = 1,
-        CONTAINS = 2
-    };
-
-    enum PlaneIntersectionType
-    {
-        FRONT = 0,
-        INTERSECTING = 1,
-        BACK = 2
-    };
-
-    struct BoundingBox;
-    struct BoundingOrientedBox;
-    struct BoundingFrustum;
-
-#ifdef _MSC_VER
-    #pragma warning(push)
-#pragma warning(disable:4324 4820)
-    // C4324: alignment padding warnings
-    // C4820: Off by default noise
-#endif
-
-    //-------------------------------------------------------------------------------------
-    // Bounding sphere
-    //-------------------------------------------------------------------------------------
-    struct BoundingSphere
-    {
-        XMFLOAT3 Center;            // Center of the sphere.
-        float Radius;               // Radius of the sphere.
-
-        // Creators
-        BoundingSphere() noexcept : Center(0, 0, 0), Radius(1.f) {}
-
-        BoundingSphere(const BoundingSphere&) = default;
-        BoundingSphere& operator=(const BoundingSphere&) = default;
-
-        BoundingSphere(BoundingSphere&&) = default;
-        BoundingSphere& operator=(BoundingSphere&&) = default;
-
-        constexpr BoundingSphere(_In_ const XMFLOAT3& center, _In_ float radius) noexcept
-                : Center(center), Radius(radius) {}
-
-        // Methods
-        void    XM_CALLCONV     Transform(_Out_ BoundingSphere& Out, _In_ FXMMATRIX M) const noexcept;
-        void    XM_CALLCONV     Transform(_Out_ BoundingSphere& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation) const noexcept;
-        // Transform the sphere
-
-        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR Point) const noexcept;
-        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
-        ContainmentType Contains(_In_ const BoundingSphere& sh) const noexcept;
-        ContainmentType Contains(_In_ const BoundingBox& box) const noexcept;
-        ContainmentType Contains(_In_ const BoundingOrientedBox& box) const noexcept;
-        ContainmentType Contains(_In_ const BoundingFrustum& fr) const noexcept;
-
-        bool Intersects(_In_ const BoundingSphere& sh) const noexcept;
-        bool Intersects(_In_ const BoundingBox& box) const noexcept;
-        bool Intersects(_In_ const BoundingOrientedBox& box) const noexcept;
-        bool Intersects(_In_ const BoundingFrustum& fr) const noexcept;
-
-        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
-        // Triangle-sphere test
-
-        PlaneIntersectionType    XM_CALLCONV     Intersects(_In_ FXMVECTOR Plane) const noexcept;
-        // Plane-sphere test
-
-        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist) const noexcept;
-        // Ray-sphere test
-
-        ContainmentType     XM_CALLCONV     ContainedBy(_In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
-                                                        _In_ GXMVECTOR Plane3, _In_ HXMVECTOR Plane4, _In_ HXMVECTOR Plane5) const noexcept;
-        // Test sphere against six planes (see BoundingFrustum::GetPlanes)
-
-        // Static methods
-        static void CreateMerged(_Out_ BoundingSphere& Out, _In_ const BoundingSphere& S1, _In_ const BoundingSphere& S2) noexcept;
-
-        static void CreateFromBoundingBox(_Out_ BoundingSphere& Out, _In_ const BoundingBox& box) noexcept;
-        static void CreateFromBoundingBox(_Out_ BoundingSphere& Out, _In_ const BoundingOrientedBox& box) noexcept;
-
-        static void CreateFromPoints(_Out_ BoundingSphere& Out, _In_ size_t Count,
-                                     _In_reads_bytes_(sizeof(XMFLOAT3) + Stride * (Count - 1)) const XMFLOAT3* pPoints, _In_ size_t Stride) noexcept;
-
-        static void CreateFromFrustum(_Out_ BoundingSphere& Out, _In_ const BoundingFrustum& fr) noexcept;
-    };
-
-    //-------------------------------------------------------------------------------------
-    // Axis-aligned bounding box
-    //-------------------------------------------------------------------------------------
-    struct BoundingBox
-    {
-        static constexpr size_t CORNER_COUNT = 8;
-
-        XMFLOAT3 Center;            // Center of the box.
-        XMFLOAT3 Extents;           // Distance from the center to each side.
-
-        // Creators
-        BoundingBox() noexcept : Center(0, 0, 0), Extents(1.f, 1.f, 1.f) {}
-
-        BoundingBox(const BoundingBox&) = default;
-        BoundingBox& operator=(const BoundingBox&) = default;
-
-        BoundingBox(BoundingBox&&) = default;
-        BoundingBox& operator=(BoundingBox&&) = default;
-
-        constexpr BoundingBox(_In_ const XMFLOAT3& center, _In_ const XMFLOAT3& extents) noexcept
-                : Center(center), Extents(extents) {}
-
-        // Methods
-        void    XM_CALLCONV     Transform(_Out_ BoundingBox& Out, _In_ FXMMATRIX M) const noexcept;
-        void    XM_CALLCONV     Transform(_Out_ BoundingBox& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation) const noexcept;
-
-        void GetCorners(_Out_writes_(8) XMFLOAT3* Corners) const noexcept;
-        // Gets the 8 corners of the box
-
-        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR Point) const noexcept;
-        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
-        ContainmentType Contains(_In_ const BoundingSphere& sh) const noexcept;
-        ContainmentType Contains(_In_ const BoundingBox& box) const noexcept;
-        ContainmentType Contains(_In_ const BoundingOrientedBox& box) const noexcept;
-        ContainmentType Contains(_In_ const BoundingFrustum& fr) const noexcept;
-
-        bool Intersects(_In_ const BoundingSphere& sh) const noexcept;
-        bool Intersects(_In_ const BoundingBox& box) const noexcept;
-        bool Intersects(_In_ const BoundingOrientedBox& box) const noexcept;
-        bool Intersects(_In_ const BoundingFrustum& fr) const noexcept;
-
-        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
-        // Triangle-Box test
-
-        PlaneIntersectionType    XM_CALLCONV     Intersects(_In_ FXMVECTOR Plane) const noexcept;
-        // Plane-box test
-
-        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist) const noexcept;
-        // Ray-Box test
-
-        ContainmentType     XM_CALLCONV     ContainedBy(_In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
-                                                        _In_ GXMVECTOR Plane3, _In_ HXMVECTOR Plane4, _In_ HXMVECTOR Plane5) const noexcept;
-        // Test box against six planes (see BoundingFrustum::GetPlanes)
-
-        // Static methods
-        static void CreateMerged(_Out_ BoundingBox& Out, _In_ const BoundingBox& b1, _In_ const BoundingBox& b2) noexcept;
-
-        static void CreateFromSphere(_Out_ BoundingBox& Out, _In_ const BoundingSphere& sh) noexcept;
-
-        static void    XM_CALLCONV     CreateFromPoints(_Out_ BoundingBox& Out, _In_ FXMVECTOR pt1, _In_ FXMVECTOR pt2) noexcept;
-        static void CreateFromPoints(_Out_ BoundingBox& Out, _In_ size_t Count,
-                                     _In_reads_bytes_(sizeof(XMFLOAT3) + Stride * (Count - 1)) const XMFLOAT3* pPoints, _In_ size_t Stride) noexcept;
-    };
-
-    //-------------------------------------------------------------------------------------
-    // Oriented bounding box
-    //-------------------------------------------------------------------------------------
-    struct BoundingOrientedBox
-    {
-        static constexpr size_t CORNER_COUNT = 8;
-
-        XMFLOAT3 Center;            // Center of the box.
-        XMFLOAT3 Extents;           // Distance from the center to each side.
-        XMFLOAT4 Orientation;       // Unit quaternion representing rotation (box -> world).
-
-        // Creators
-        BoundingOrientedBox() noexcept : Center(0, 0, 0), Extents(1.f, 1.f, 1.f), Orientation(0, 0, 0, 1.f) {}
-
-        BoundingOrientedBox(const BoundingOrientedBox&) = default;
-        BoundingOrientedBox& operator=(const BoundingOrientedBox&) = default;
-
-        BoundingOrientedBox(BoundingOrientedBox&&) = default;
-        BoundingOrientedBox& operator=(BoundingOrientedBox&&) = default;
-
-        constexpr BoundingOrientedBox(_In_ const XMFLOAT3& center, _In_ const XMFLOAT3& extents, _In_ const XMFLOAT4& orientation) noexcept
-                : Center(center), Extents(extents), Orientation(orientation) {}
-
-        // Methods
-        void    XM_CALLCONV     Transform(_Out_ BoundingOrientedBox& Out, _In_ FXMMATRIX M) const noexcept;
-        void    XM_CALLCONV     Transform(_Out_ BoundingOrientedBox& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation) const noexcept;
-
-        void GetCorners(_Out_writes_(8) XMFLOAT3* Corners) const noexcept;
-        // Gets the 8 corners of the box
-
-        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR Point) const noexcept;
-        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
-        ContainmentType Contains(_In_ const BoundingSphere& sh) const noexcept;
-        ContainmentType Contains(_In_ const BoundingBox& box) const noexcept;
-        ContainmentType Contains(_In_ const BoundingOrientedBox& box) const noexcept;
-        ContainmentType Contains(_In_ const BoundingFrustum& fr) const noexcept;
-
-        bool Intersects(_In_ const BoundingSphere& sh) const noexcept;
-        bool Intersects(_In_ const BoundingBox& box) const noexcept;
-        bool Intersects(_In_ const BoundingOrientedBox& box) const noexcept;
-        bool Intersects(_In_ const BoundingFrustum& fr) const noexcept;
-
-        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
-        // Triangle-OrientedBox test
-
-        PlaneIntersectionType    XM_CALLCONV     Intersects(_In_ FXMVECTOR Plane) const noexcept;
-        // Plane-OrientedBox test
-
-        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist) const noexcept;
-        // Ray-OrientedBox test
-
-        ContainmentType     XM_CALLCONV     ContainedBy(_In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
-                                                        _In_ GXMVECTOR Plane3, _In_ HXMVECTOR Plane4, _In_ HXMVECTOR Plane5) const noexcept;
-        // Test OrientedBox against six planes (see BoundingFrustum::GetPlanes)
-
-        // Static methods
-        static void CreateFromBoundingBox(_Out_ BoundingOrientedBox& Out, _In_ const BoundingBox& box) noexcept;
-
-        static void CreateFromPoints(_Out_ BoundingOrientedBox& Out, _In_ size_t Count,
-                                     _In_reads_bytes_(sizeof(XMFLOAT3) + Stride * (Count - 1)) const XMFLOAT3* pPoints, _In_ size_t Stride) noexcept;
-    };
-
-    //-------------------------------------------------------------------------------------
-    // Bounding frustum
-    //-------------------------------------------------------------------------------------
-    struct BoundingFrustum
-    {
-        static constexpr size_t CORNER_COUNT = 8;
-
-        XMFLOAT3 Origin;            // Origin of the frustum (and projection).
-        XMFLOAT4 Orientation;       // Quaternion representing rotation.
-
-        float RightSlope;           // Positive X (X/Z)
-        float LeftSlope;            // Negative X
-        float TopSlope;             // Positive Y (Y/Z)
-        float BottomSlope;          // Negative Y
-        float Near, Far;            // Z of the near plane and far plane.
-
-        // Creators
-        BoundingFrustum() noexcept :
-                Origin(0, 0, 0), Orientation(0, 0, 0, 1.f), RightSlope(1.f), LeftSlope(-1.f),
-                TopSlope(1.f), BottomSlope(-1.f), Near(0), Far(1.f) {}
-
-        BoundingFrustum(const BoundingFrustum&) = default;
-        BoundingFrustum& operator=(const BoundingFrustum&) = default;
-
-        BoundingFrustum(BoundingFrustum&&) = default;
-        BoundingFrustum& operator=(BoundingFrustum&&) = default;
-
-        constexpr BoundingFrustum(_In_ const XMFLOAT3& origin, _In_ const XMFLOAT4& orientation,
-                                  _In_ float rightSlope, _In_ float leftSlope, _In_ float topSlope, _In_ float bottomSlope,
-                                  _In_ float nearPlane, _In_ float farPlane) noexcept
-                : Origin(origin), Orientation(orientation),
-                  RightSlope(rightSlope), LeftSlope(leftSlope), TopSlope(topSlope), BottomSlope(bottomSlope),
-                  Near(nearPlane), Far(farPlane) {}
-        BoundingFrustum(_In_ CXMMATRIX Projection, bool rhcoords = false) noexcept;
-
-        // Methods
-        void    XM_CALLCONV     Transform(_Out_ BoundingFrustum& Out, _In_ FXMMATRIX M) const noexcept;
-        void    XM_CALLCONV     Transform(_Out_ BoundingFrustum& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation) const noexcept;
-
-        void GetCorners(_Out_writes_(8) XMFLOAT3* Corners) const noexcept;
-        // Gets the 8 corners of the frustum
-
-        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR Point) const noexcept;
-        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
-        ContainmentType Contains(_In_ const BoundingSphere& sp) const noexcept;
-        ContainmentType Contains(_In_ const BoundingBox& box) const noexcept;
-        ContainmentType Contains(_In_ const BoundingOrientedBox& box) const noexcept;
-        ContainmentType Contains(_In_ const BoundingFrustum& fr) const noexcept;
-        // Frustum-Frustum test
-
-        bool Intersects(_In_ const BoundingSphere& sh) const noexcept;
-        bool Intersects(_In_ const BoundingBox& box) const noexcept;
-        bool Intersects(_In_ const BoundingOrientedBox& box) const noexcept;
-        bool Intersects(_In_ const BoundingFrustum& fr) const noexcept;
-
-        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
-        // Triangle-Frustum test
-
-        PlaneIntersectionType    XM_CALLCONV     Intersects(_In_ FXMVECTOR Plane) const noexcept;
-        // Plane-Frustum test
-
-        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR rayOrigin, _In_ FXMVECTOR Direction, _Out_ float& Dist) const noexcept;
-        // Ray-Frustum test
-
-        ContainmentType     XM_CALLCONV     ContainedBy(_In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
-                                                        _In_ GXMVECTOR Plane3, _In_ HXMVECTOR Plane4, _In_ HXMVECTOR Plane5) const noexcept;
-        // Test frustum against six planes (see BoundingFrustum::GetPlanes)
-
-        void GetPlanes(_Out_opt_ XMVECTOR* NearPlane, _Out_opt_ XMVECTOR* FarPlane, _Out_opt_ XMVECTOR* RightPlane,
-                       _Out_opt_ XMVECTOR* LeftPlane, _Out_opt_ XMVECTOR* TopPlane, _Out_opt_ XMVECTOR* BottomPlane) const noexcept;
-        // Create 6 Planes representation of Frustum
-
-        // Static methods
-        static void     XM_CALLCONV     CreateFromMatrix(_Out_ BoundingFrustum& Out, _In_ FXMMATRIX Projection, bool rhcoords = false) noexcept;
-    };
-
-    //-----------------------------------------------------------------------------
-    // Triangle intersection testing routines.
-    //-----------------------------------------------------------------------------
-    namespace TriangleTests
-    {
-        bool                    XM_CALLCONV     Intersects(_In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _In_ FXMVECTOR V0, _In_ GXMVECTOR V1, _In_ HXMVECTOR V2, _Out_ float& Dist) noexcept;
-        // Ray-Triangle
-
-        bool                    XM_CALLCONV     Intersects(_In_ FXMVECTOR A0, _In_ FXMVECTOR A1, _In_ FXMVECTOR A2, _In_ GXMVECTOR B0, _In_ HXMVECTOR B1, _In_ HXMVECTOR B2) noexcept;
-        // Triangle-Triangle
-
-        PlaneIntersectionType   XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2, _In_ GXMVECTOR Plane) noexcept;
-        // Plane-Triangle
-
-        ContainmentType         XM_CALLCONV     ContainedBy(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2,
-                                                            _In_ GXMVECTOR Plane0, _In_ HXMVECTOR Plane1, _In_ HXMVECTOR Plane2,
-                                                            _In_ CXMVECTOR Plane3, _In_ CXMVECTOR Plane4, _In_ CXMVECTOR Plane5) noexcept;
-        // Test a triangle against six planes at once (see BoundingFrustum::GetPlanes)
-    }
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-    /****************************************************************************
-     *
-     * Implementation
-     *
-     ****************************************************************************/
-
-#ifdef _MSC_VER
-    #pragma warning(push)
-#pragma warning(disable : 4068 4365 4616 6001)
-     // C4068/4616: ignore unknown pragmas
-     // C4365: Off by default noise
-     // C6001: False positives
-#endif
-#ifdef _PREFAST_
-    #pragma prefast(push)
-#pragma prefast(disable : 25000, "FXMVECTOR is 16 bytes")
-#pragma prefast(disable : 26495, "Union initialization confuses /analyze")
-#endif
-
-#include "DirectXCollision.inl"
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-} // namespace DirectX
-
diff --git a/thirdparty/directxmath/DirectXCollision.inl b/thirdparty/directxmath/DirectXCollision.inl
deleted file mode 100644
index c4347f4..0000000
--- a/thirdparty/directxmath/DirectXCollision.inl
+++ /dev/null
@@ -1,4816 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXCollision.inl -- C++ Collision Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-XMGLOBALCONST XMVECTORF32 g_BoxOffset[8] =
-{
-{ { { -1.0f, -1.0f,  1.0f, 0.0f } } },
-{ { {  1.0f, -1.0f,  1.0f, 0.0f } } },
-{ { {  1.0f,  1.0f,  1.0f, 0.0f } } },
-{ { { -1.0f,  1.0f,  1.0f, 0.0f } } },
-{ { { -1.0f, -1.0f, -1.0f, 0.0f } } },
-{ { {  1.0f, -1.0f, -1.0f, 0.0f } } },
-{ { {  1.0f,  1.0f, -1.0f, 0.0f } } },
-{ { { -1.0f,  1.0f, -1.0f, 0.0f } } },
-};
-
-XMGLOBALCONST XMVECTORF32 g_RayEpsilon = { { { 1e-20f, 1e-20f, 1e-20f, 1e-20f } } };
-XMGLOBALCONST XMVECTORF32 g_RayNegEpsilon = { { { -1e-20f, -1e-20f, -1e-20f, -1e-20f } } };
-XMGLOBALCONST XMVECTORF32 g_FltMin = { { { -FLT_MAX, -FLT_MAX, -FLT_MAX, -FLT_MAX } } };
-XMGLOBALCONST XMVECTORF32 g_FltMax = { { { FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX } } };
-
-namespace Internal
-{
-
-    //-----------------------------------------------------------------------------
-    // Return true if any of the elements of a 3 vector are equal to 0xffffffff.
-    // Slightly more efficient than using XMVector3EqualInt.
-    //-----------------------------------------------------------------------------
-    inline bool XMVector3AnyTrue(_In_ FXMVECTOR V) noexcept
-    {
-        // Duplicate the fourth element from the first element.
-        XMVECTOR C = XMVectorSwizzle<XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_X>(V);
-
-        return XMComparisonAnyTrue(XMVector4EqualIntR(C, XMVectorTrueInt()));
-    }
-
-
-    //-----------------------------------------------------------------------------
-    // Return true if all of the elements of a 3 vector are equal to 0xffffffff.
-    // Slightly more efficient than using XMVector3EqualInt.
-    //-----------------------------------------------------------------------------
-    inline bool XMVector3AllTrue(_In_ FXMVECTOR V) noexcept
-    {
-        // Duplicate the fourth element from the first element.
-        XMVECTOR C = XMVectorSwizzle<XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_X>(V);
-
-        return XMComparisonAllTrue(XMVector4EqualIntR(C, XMVectorTrueInt()));
-    }
-
-#if defined(_PREFAST_) || !defined(NDEBUG)
-
-    XMGLOBALCONST XMVECTORF32 g_UnitVectorEpsilon = { { { 1.0e-4f, 1.0e-4f, 1.0e-4f, 1.0e-4f } } };
-    XMGLOBALCONST XMVECTORF32 g_UnitQuaternionEpsilon = { { { 1.0e-4f, 1.0e-4f, 1.0e-4f, 1.0e-4f } } };
-    XMGLOBALCONST XMVECTORF32 g_UnitPlaneEpsilon = { { { 1.0e-4f, 1.0e-4f, 1.0e-4f, 1.0e-4f } } };
-
-    //-----------------------------------------------------------------------------
-    // Return true if the vector is a unit vector (length == 1).
-    //-----------------------------------------------------------------------------
-    inline bool XMVector3IsUnit(_In_ FXMVECTOR V) noexcept
-    {
-        XMVECTOR Difference = XMVectorSubtract(XMVector3Length(V), XMVectorSplatOne());
-        return XMVector4Less(XMVectorAbs(Difference), g_UnitVectorEpsilon);
-    }
-
-    //-----------------------------------------------------------------------------
-    // Return true if the quaterion is a unit quaternion.
-    //-----------------------------------------------------------------------------
-    inline bool XMQuaternionIsUnit(_In_ FXMVECTOR Q) noexcept
-    {
-        XMVECTOR Difference = XMVectorSubtract(XMVector4Length(Q), XMVectorSplatOne());
-        return XMVector4Less(XMVectorAbs(Difference), g_UnitQuaternionEpsilon);
-    }
-
-    //-----------------------------------------------------------------------------
-    // Return true if the plane is a unit plane.
-    //-----------------------------------------------------------------------------
-    inline bool XMPlaneIsUnit(_In_ FXMVECTOR Plane) noexcept
-    {
-        XMVECTOR Difference = XMVectorSubtract(XMVector3Length(Plane), XMVectorSplatOne());
-        return XMVector4Less(XMVectorAbs(Difference), g_UnitPlaneEpsilon);
-    }
-
-#endif // _PREFAST_ || !NDEBUG
-
-    //-----------------------------------------------------------------------------
-    inline XMVECTOR XMPlaneTransform(_In_ FXMVECTOR Plane, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation) noexcept
-    {
-        XMVECTOR vNormal = XMVector3Rotate(Plane, Rotation);
-        XMVECTOR vD = XMVectorSubtract(XMVectorSplatW(Plane), XMVector3Dot(vNormal, Translation));
-
-        return XMVectorInsert<0, 0, 0, 0, 1>(vNormal, vD);
-    }
-
-    //-----------------------------------------------------------------------------
-    // Return the point on the line segement (S1, S2) nearest the point P.
-    //-----------------------------------------------------------------------------
-    inline XMVECTOR PointOnLineSegmentNearestPoint(_In_ FXMVECTOR S1, _In_ FXMVECTOR S2, _In_ FXMVECTOR P) noexcept
-    {
-        XMVECTOR Dir = XMVectorSubtract(S2, S1);
-        XMVECTOR Projection = XMVectorSubtract(XMVector3Dot(P, Dir), XMVector3Dot(S1, Dir));
-        XMVECTOR LengthSq = XMVector3Dot(Dir, Dir);
-
-        XMVECTOR t = XMVectorMultiply(Projection, XMVectorReciprocal(LengthSq));
-        XMVECTOR Point = XMVectorMultiplyAdd(t, Dir, S1);
-
-        // t < 0
-        XMVECTOR SelectS1 = XMVectorLess(Projection, XMVectorZero());
-        Point = XMVectorSelect(Point, S1, SelectS1);
-
-        // t > 1
-        XMVECTOR SelectS2 = XMVectorGreater(Projection, LengthSq);
-        Point = XMVectorSelect(Point, S2, SelectS2);
-
-        return Point;
-    }
-
-    //-----------------------------------------------------------------------------
-    // Test if the point (P) on the plane of the triangle is inside the triangle
-    // (V0, V1, V2).
-    //-----------------------------------------------------------------------------
-    inline XMVECTOR XM_CALLCONV PointOnPlaneInsideTriangle(_In_ FXMVECTOR P, _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ GXMVECTOR V2) noexcept
-{
-    // Compute the triangle normal.
-    XMVECTOR N = XMVector3Cross(XMVectorSubtract(V2, V0), XMVectorSubtract(V1, V0));
-
-    // Compute the cross products of the vector from the base of each edge to
-    // the point with each edge vector.
-    XMVECTOR C0 = XMVector3Cross(XMVectorSubtract(P, V0), XMVectorSubtract(V1, V0));
-    XMVECTOR C1 = XMVector3Cross(XMVectorSubtract(P, V1), XMVectorSubtract(V2, V1));
-    XMVECTOR C2 = XMVector3Cross(XMVectorSubtract(P, V2), XMVectorSubtract(V0, V2));
-
-    // If the cross product points in the same direction as the normal the the
-    // point is inside the edge (it is zero if is on the edge).
-    XMVECTOR Zero = XMVectorZero();
-    XMVECTOR Inside0 = XMVectorGreaterOrEqual(XMVector3Dot(C0, N), Zero);
-    XMVECTOR Inside1 = XMVectorGreaterOrEqual(XMVector3Dot(C1, N), Zero);
-    XMVECTOR Inside2 = XMVectorGreaterOrEqual(XMVector3Dot(C2, N), Zero);
-
-    // If the point inside all of the edges it is inside.
-    return XMVectorAndInt(XMVectorAndInt(Inside0, Inside1), Inside2);
-}
-
-//-----------------------------------------------------------------------------
-inline bool SolveCubic(_In_ float e, _In_ float f, _In_ float g, _Out_ float* t, _Out_ float* u, _Out_ float* v) noexcept
-{
-    float p, q, h, rc, d, theta, costh3, sinth3;
-
-    p = f - e * e / 3.0f;
-    q = g - e * f / 3.0f + e * e * e * 2.0f / 27.0f;
-    h = q * q / 4.0f + p * p * p / 27.0f;
-
-    if (h > 0)
-    {
-        *t = *u = *v = 0.f;
-        return false; // only one real root
-    }
-
-    if ((h == 0) && (q == 0)) // all the same root
-    {
-        *t = -e / 3;
-        *u = -e / 3;
-        *v = -e / 3;
-
-        return true;
-    }
-
-    d = sqrtf(q * q / 4.0f - h);
-    if (d < 0)
-        rc = -powf(-d, 1.0f / 3.0f);
-    else
-        rc = powf(d, 1.0f / 3.0f);
-
-    theta = XMScalarACos(-q / (2.0f * d));
-    costh3 = XMScalarCos(theta / 3.0f);
-    sinth3 = sqrtf(3.0f) * XMScalarSin(theta / 3.0f);
-    *t = 2.0f * rc * costh3 - e / 3.0f;
-    *u = -rc * (costh3 + sinth3) - e / 3.0f;
-    *v = -rc * (costh3 - sinth3) - e / 3.0f;
-
-    return true;
-}
-
-//-----------------------------------------------------------------------------
-inline XMVECTOR CalculateEigenVector(_In_ float m11, _In_ float m12, _In_ float m13,
-                                     _In_ float m22, _In_ float m23, _In_ float m33, _In_ float e) noexcept
-{
-    float fTmp[3];
-    fTmp[0] = m12 * m23 - m13 * (m22 - e);
-    fTmp[1] = m13 * m12 - m23 * (m11 - e);
-    fTmp[2] = (m11 - e) * (m22 - e) - m12 * m12;
-
-    XMVECTOR vTmp = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(fTmp));
-
-    if (XMVector3Equal(vTmp, XMVectorZero())) // planar or linear
-    {
-        float f1, f2, f3;
-
-        // we only have one equation - find a valid one
-        if ((m11 - e != 0) || (m12 != 0) || (m13 != 0))
-        {
-            f1 = m11 - e; f2 = m12; f3 = m13;
-        }
-        else if ((m12 != 0) || (m22 - e != 0) || (m23 != 0))
-        {
-            f1 = m12; f2 = m22 - e; f3 = m23;
-        }
-        else if ((m13 != 0) || (m23 != 0) || (m33 - e != 0))
-        {
-            f1 = m13; f2 = m23; f3 = m33 - e;
-        }
-        else
-        {
-            // error, we'll just make something up - we have NO context
-            f1 = 1.0f; f2 = 0.0f; f3 = 0.0f;
-        }
-
-        if (f1 == 0)
-            vTmp = XMVectorSetX(vTmp, 0.0f);
-        else
-            vTmp = XMVectorSetX(vTmp, 1.0f);
-
-        if (f2 == 0)
-            vTmp = XMVectorSetY(vTmp, 0.0f);
-        else
-            vTmp = XMVectorSetY(vTmp, 1.0f);
-
-        if (f3 == 0)
-        {
-            vTmp = XMVectorSetZ(vTmp, 0.0f);
-            // recalculate y to make equation work
-            if (m12 != 0)
-                vTmp = XMVectorSetY(vTmp, -f1 / f2);
-        }
-        else
-        {
-            vTmp = XMVectorSetZ(vTmp, (f2 - f1) / f3);
-        }
-    }
-
-    if (XMVectorGetX(XMVector3LengthSq(vTmp)) > 1e-5f)
-    {
-        return XMVector3Normalize(vTmp);
-    }
-    else
-    {
-        // Multiply by a value large enough to make the vector non-zero.
-        vTmp = XMVectorScale(vTmp, 1e5f);
-        return XMVector3Normalize(vTmp);
-    }
-}
-
-//-----------------------------------------------------------------------------
-inline bool CalculateEigenVectors(_In_ float m11, _In_ float m12, _In_ float m13,
-                                  _In_ float m22, _In_ float m23, _In_ float m33,
-                                  _In_ float e1, _In_ float e2, _In_ float e3,
-                                  _Out_ XMVECTOR* pV1, _Out_ XMVECTOR* pV2, _Out_ XMVECTOR* pV3) noexcept
-{
-*pV1 = DirectX::Internal::CalculateEigenVector(m11, m12, m13, m22, m23, m33, e1);
-*pV2 = DirectX::Internal::CalculateEigenVector(m11, m12, m13, m22, m23, m33, e2);
-*pV3 = DirectX::Internal::CalculateEigenVector(m11, m12, m13, m22, m23, m33, e3);
-
-bool v1z = false;
-bool v2z = false;
-bool v3z = false;
-
-XMVECTOR Zero = XMVectorZero();
-
-if (XMVector3Equal(*pV1, Zero))
-v1z = true;
-
-if (XMVector3Equal(*pV2, Zero))
-v2z = true;
-
-if (XMVector3Equal(*pV3, Zero))
-v3z = true;
-
-bool e12 = (fabsf(XMVectorGetX(XMVector3Dot(*pV1, *pV2))) > 0.1f); // check for non-orthogonal vectors
-bool e13 = (fabsf(XMVectorGetX(XMVector3Dot(*pV1, *pV3))) > 0.1f);
-bool e23 = (fabsf(XMVectorGetX(XMVector3Dot(*pV2, *pV3))) > 0.1f);
-
-if ((v1z && v2z && v3z) || (e12 && e13 && e23) ||
-(e12 && v3z) || (e13 && v2z) || (e23 && v1z)) // all eigenvectors are 0- any basis set
-{
-*pV1 = g_XMIdentityR0.v;
-*pV2 = g_XMIdentityR1.v;
-*pV3 = g_XMIdentityR2.v;
-return true;
-}
-
-if (v1z && v2z)
-{
-XMVECTOR vTmp = XMVector3Cross(g_XMIdentityR1, *pV3);
-if (XMVectorGetX(XMVector3LengthSq(vTmp)) < 1e-5f)
-{
-vTmp = XMVector3Cross(g_XMIdentityR0, *pV3);
-}
-*pV1 = XMVector3Normalize(vTmp);
-*pV2 = XMVector3Cross(*pV3, *pV1);
-return true;
-}
-
-if (v3z && v1z)
-{
-XMVECTOR vTmp = XMVector3Cross(g_XMIdentityR1, *pV2);
-if (XMVectorGetX(XMVector3LengthSq(vTmp)) < 1e-5f)
-{
-vTmp = XMVector3Cross(g_XMIdentityR0, *pV2);
-}
-*pV3 = XMVector3Normalize(vTmp);
-*pV1 = XMVector3Cross(*pV2, *pV3);
-return true;
-}
-
-if (v2z && v3z)
-{
-XMVECTOR vTmp = XMVector3Cross(g_XMIdentityR1, *pV1);
-if (XMVectorGetX(XMVector3LengthSq(vTmp)) < 1e-5f)
-{
-vTmp = XMVector3Cross(g_XMIdentityR0, *pV1);
-}
-*pV2 = XMVector3Normalize(vTmp);
-*pV3 = XMVector3Cross(*pV1, *pV2);
-return true;
-}
-
-if ((v1z) || e12)
-{
-*pV1 = XMVector3Cross(*pV2, *pV3);
-return true;
-}
-
-if ((v2z) || e23)
-{
-*pV2 = XMVector3Cross(*pV3, *pV1);
-return true;
-}
-
-if ((v3z) || e13)
-{
-*pV3 = XMVector3Cross(*pV1, *pV2);
-return true;
-}
-
-return true;
-}
-
-//-----------------------------------------------------------------------------
-inline bool CalculateEigenVectorsFromCovarianceMatrix(_In_ float Cxx, _In_ float Cyy, _In_ float Czz,
-                                                      _In_ float Cxy, _In_ float Cxz, _In_ float Cyz,
-                                                      _Out_ XMVECTOR* pV1, _Out_ XMVECTOR* pV2, _Out_ XMVECTOR* pV3) noexcept
-{
-// Calculate the eigenvalues by solving a cubic equation.
-float e = -(Cxx + Cyy + Czz);
-float f = Cxx * Cyy + Cyy * Czz + Czz * Cxx - Cxy * Cxy - Cxz * Cxz - Cyz * Cyz;
-float g = Cxy * Cxy * Czz + Cxz * Cxz * Cyy + Cyz * Cyz * Cxx - Cxy * Cyz * Cxz * 2.0f - Cxx * Cyy * Czz;
-
-float ev1, ev2, ev3;
-if (!DirectX::Internal::SolveCubic(e, f, g, &ev1, &ev2, &ev3))
-{
-// set them to arbitrary orthonormal basis set
-*pV1 = g_XMIdentityR0.v;
-*pV2 = g_XMIdentityR1.v;
-*pV3 = g_XMIdentityR2.v;
-return false;
-}
-
-return DirectX::Internal::CalculateEigenVectors(Cxx, Cxy, Cxz, Cyy, Cyz, Czz, ev1, ev2, ev3, pV1, pV2, pV3);
-}
-
-//-----------------------------------------------------------------------------
-inline void XM_CALLCONV FastIntersectTrianglePlane(
-        FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2,
-GXMVECTOR Plane,
-        XMVECTOR& Outside, XMVECTOR& Inside) noexcept
-{
-// Plane0
-XMVECTOR Dist0 = XMVector4Dot(V0, Plane);
-XMVECTOR Dist1 = XMVector4Dot(V1, Plane);
-XMVECTOR Dist2 = XMVector4Dot(V2, Plane);
-
-XMVECTOR MinDist = XMVectorMin(Dist0, Dist1);
-MinDist = XMVectorMin(MinDist, Dist2);
-
-XMVECTOR MaxDist = XMVectorMax(Dist0, Dist1);
-MaxDist = XMVectorMax(MaxDist, Dist2);
-
-XMVECTOR Zero = XMVectorZero();
-
-// Outside the plane?
-Outside = XMVectorGreater(MinDist, Zero);
-
-// Fully inside the plane?
-Inside = XMVectorLess(MaxDist, Zero);
-}
-
-//-----------------------------------------------------------------------------
-inline void FastIntersectSpherePlane(_In_ FXMVECTOR Center, _In_ FXMVECTOR Radius, _In_ FXMVECTOR Plane,
-                                     _Out_ XMVECTOR& Outside, _Out_ XMVECTOR& Inside) noexcept
-{
-XMVECTOR Dist = XMVector4Dot(Center, Plane);
-
-// Outside the plane?
-Outside = XMVectorGreater(Dist, Radius);
-
-// Fully inside the plane?
-Inside = XMVectorLess(Dist, XMVectorNegate(Radius));
-}
-
-//-----------------------------------------------------------------------------
-inline void FastIntersectAxisAlignedBoxPlane(_In_ FXMVECTOR Center, _In_ FXMVECTOR Extents, _In_ FXMVECTOR Plane,
-                                             _Out_ XMVECTOR& Outside, _Out_ XMVECTOR& Inside) noexcept
-{
-// Compute the distance to the center of the box.
-XMVECTOR Dist = XMVector4Dot(Center, Plane);
-
-// Project the axes of the box onto the normal of the plane.  Half the
-// length of the projection (sometime called the "radius") is equal to
-// h(u) * abs(n dot b(u))) + h(v) * abs(n dot b(v)) + h(w) * abs(n dot b(w))
-// where h(i) are extents of the box, n is the plane normal, and b(i) are the
-// axes of the box. In this case b(i) = [(1,0,0), (0,1,0), (0,0,1)].
-XMVECTOR Radius = XMVector3Dot(Extents, XMVectorAbs(Plane));
-
-// Outside the plane?
-Outside = XMVectorGreater(Dist, Radius);
-
-// Fully inside the plane?
-Inside = XMVectorLess(Dist, XMVectorNegate(Radius));
-}
-
-//-----------------------------------------------------------------------------
-inline void XM_CALLCONV FastIntersectOrientedBoxPlane(
-        _In_ FXMVECTOR Center, _In_ FXMVECTOR Extents, _In_ FXMVECTOR Axis0,
-        _In_ GXMVECTOR Axis1,
-        _In_ HXMVECTOR Axis2, _In_ HXMVECTOR Plane,
-        _Out_ XMVECTOR& Outside, _Out_ XMVECTOR& Inside) noexcept
-{
-// Compute the distance to the center of the box.
-XMVECTOR Dist = XMVector4Dot(Center, Plane);
-
-// Project the axes of the box onto the normal of the plane.  Half the
-// length of the projection (sometime called the "radius") is equal to
-// h(u) * abs(n dot b(u))) + h(v) * abs(n dot b(v)) + h(w) * abs(n dot b(w))
-// where h(i) are extents of the box, n is the plane normal, and b(i) are the
-// axes of the box.
-XMVECTOR Radius = XMVector3Dot(Plane, Axis0);
-Radius = XMVectorInsert<0, 0, 1, 0, 0>(Radius, XMVector3Dot(Plane, Axis1));
-Radius = XMVectorInsert<0, 0, 0, 1, 0>(Radius, XMVector3Dot(Plane, Axis2));
-Radius = XMVector3Dot(Extents, XMVectorAbs(Radius));
-
-// Outside the plane?
-Outside = XMVectorGreater(Dist, Radius);
-
-// Fully inside the plane?
-Inside = XMVectorLess(Dist, XMVectorNegate(Radius));
-}
-
-//-----------------------------------------------------------------------------
-inline void XM_CALLCONV FastIntersectFrustumPlane(
-        _In_ FXMVECTOR Point0, _In_ FXMVECTOR Point1, _In_ FXMVECTOR Point2,
-        _In_ GXMVECTOR Point3,
-        _In_ HXMVECTOR Point4, _In_ HXMVECTOR Point5,
-        _In_ CXMVECTOR Point6, _In_ CXMVECTOR Point7, _In_ CXMVECTOR Plane,
-        _Out_ XMVECTOR& Outside, _Out_ XMVECTOR& Inside) noexcept
-{
-// Find the min/max projection of the frustum onto the plane normal.
-XMVECTOR Min, Max, Dist;
-
-Min = Max = XMVector3Dot(Plane, Point0);
-
-Dist = XMVector3Dot(Plane, Point1);
-Min = XMVectorMin(Min, Dist);
-Max = XMVectorMax(Max, Dist);
-
-Dist = XMVector3Dot(Plane, Point2);
-Min = XMVectorMin(Min, Dist);
-Max = XMVectorMax(Max, Dist);
-
-Dist = XMVector3Dot(Plane, Point3);
-Min = XMVectorMin(Min, Dist);
-Max = XMVectorMax(Max, Dist);
-
-Dist = XMVector3Dot(Plane, Point4);
-Min = XMVectorMin(Min, Dist);
-Max = XMVectorMax(Max, Dist);
-
-Dist = XMVector3Dot(Plane, Point5);
-Min = XMVectorMin(Min, Dist);
-Max = XMVectorMax(Max, Dist);
-
-Dist = XMVector3Dot(Plane, Point6);
-Min = XMVectorMin(Min, Dist);
-Max = XMVectorMax(Max, Dist);
-
-Dist = XMVector3Dot(Plane, Point7);
-Min = XMVectorMin(Min, Dist);
-Max = XMVectorMax(Max, Dist);
-
-XMVECTOR PlaneDist = XMVectorNegate(XMVectorSplatW(Plane));
-
-// Outside the plane?
-Outside = XMVectorGreater(Min, PlaneDist);
-
-// Fully inside the plane?
-Inside = XMVectorLess(Max, PlaneDist);
-}
-
-} // namespace Internal
-
-
-/****************************************************************************
- *
- * BoundingSphere
- *
- ****************************************************************************/
-
-//-----------------------------------------------------------------------------
-// Transform a sphere by an angle preserving transform.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingSphere::Transform(BoundingSphere& Out, FXMMATRIX M) const noexcept
-{
-// Load the center of the sphere.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-
-// Transform the center of the sphere.
-XMVECTOR C = XMVector3Transform(vCenter, M);
-
-XMVECTOR dX = XMVector3Dot(M.r[0], M.r[0]);
-XMVECTOR dY = XMVector3Dot(M.r[1], M.r[1]);
-XMVECTOR dZ = XMVector3Dot(M.r[2], M.r[2]);
-
-XMVECTOR d = XMVectorMax(dX, XMVectorMax(dY, dZ));
-
-// Store the center sphere.
-XMStoreFloat3(&Out.Center, C);
-
-// Scale the radius of the pshere.
-float Scale = sqrtf(XMVectorGetX(d));
-Out.Radius = Radius * Scale;
-}
-
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingSphere::Transform(BoundingSphere& Out, float Scale, FXMVECTOR Rotation, FXMVECTOR Translation) const noexcept
-{
-// Load the center of the sphere.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-
-// Transform the center of the sphere.
-vCenter = XMVectorAdd(XMVector3Rotate(XMVectorScale(vCenter, Scale), Rotation), Translation);
-
-// Store the center sphere.
-XMStoreFloat3(&Out.Center, vCenter);
-
-// Scale the radius of the pshere.
-Out.Radius = Radius * Scale;
-}
-
-
-//-----------------------------------------------------------------------------
-// Point in sphere test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingSphere::Contains(FXMVECTOR Point) const noexcept
-{
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vRadius = XMVectorReplicatePtr(&Radius);
-
-XMVECTOR DistanceSquared = XMVector3LengthSq(XMVectorSubtract(Point, vCenter));
-XMVECTOR RadiusSquared = XMVectorMultiply(vRadius, vRadius);
-
-return XMVector3LessOrEqual(DistanceSquared, RadiusSquared) ? CONTAINS : DISJOINT;
-}
-
-
-//-----------------------------------------------------------------------------
-// Triangle in sphere test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingSphere::Contains(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2) const noexcept
-{
-if (!Intersects(V0, V1, V2))
-return DISJOINT;
-
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vRadius = XMVectorReplicatePtr(&Radius);
-XMVECTOR RadiusSquared = XMVectorMultiply(vRadius, vRadius);
-
-XMVECTOR DistanceSquared = XMVector3LengthSq(XMVectorSubtract(V0, vCenter));
-XMVECTOR Inside = XMVectorLessOrEqual(DistanceSquared, RadiusSquared);
-
-DistanceSquared = XMVector3LengthSq(XMVectorSubtract(V1, vCenter));
-Inside = XMVectorAndInt(Inside, XMVectorLessOrEqual(DistanceSquared, RadiusSquared));
-
-DistanceSquared = XMVector3LengthSq(XMVectorSubtract(V2, vCenter));
-Inside = XMVectorAndInt(Inside, XMVectorLessOrEqual(DistanceSquared, RadiusSquared));
-
-return (XMVector3EqualInt(Inside, XMVectorTrueInt())) ? CONTAINS : INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Sphere in sphere test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingSphere::Contains(const BoundingSphere& sh) const noexcept
-{
-    XMVECTOR Center1 = XMLoadFloat3(&Center);
-    float r1 = Radius;
-
-    XMVECTOR Center2 = XMLoadFloat3(&sh.Center);
-    float r2 = sh.Radius;
-
-    XMVECTOR V = XMVectorSubtract(Center2, Center1);
-
-    XMVECTOR Dist = XMVector3Length(V);
-
-    float d = XMVectorGetX(Dist);
-
-    return (r1 + r2 >= d) ? ((r1 - r2 >= d) ? CONTAINS : INTERSECTS) : DISJOINT;
-}
-
-
-//-----------------------------------------------------------------------------
-// Axis-aligned box in sphere test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingSphere::Contains(const BoundingBox& box) const noexcept
-{
-    if (!box.Intersects(*this))
-        return DISJOINT;
-
-    XMVECTOR vCenter = XMLoadFloat3(&Center);
-    XMVECTOR vRadius = XMVectorReplicatePtr(&Radius);
-    XMVECTOR RadiusSq = XMVectorMultiply(vRadius, vRadius);
-
-    XMVECTOR boxCenter = XMLoadFloat3(&box.Center);
-    XMVECTOR boxExtents = XMLoadFloat3(&box.Extents);
-
-    XMVECTOR InsideAll = XMVectorTrueInt();
-
-    XMVECTOR offset = XMVectorSubtract(boxCenter, vCenter);
-
-    for (size_t i = 0; i < BoundingBox::CORNER_COUNT; ++i)
-    {
-        XMVECTOR C = XMVectorMultiplyAdd(boxExtents, g_BoxOffset[i], offset);
-        XMVECTOR d = XMVector3LengthSq(C);
-        InsideAll = XMVectorAndInt(InsideAll, XMVectorLessOrEqual(d, RadiusSq));
-    }
-
-    return (XMVector3EqualInt(InsideAll, XMVectorTrueInt())) ? CONTAINS : INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Oriented box in sphere test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingSphere::Contains(const BoundingOrientedBox& box) const noexcept
-{
-    if (!box.Intersects(*this))
-        return DISJOINT;
-
-    XMVECTOR vCenter = XMLoadFloat3(&Center);
-    XMVECTOR vRadius = XMVectorReplicatePtr(&Radius);
-    XMVECTOR RadiusSq = XMVectorMultiply(vRadius, vRadius);
-
-    XMVECTOR boxCenter = XMLoadFloat3(&box.Center);
-    XMVECTOR boxExtents = XMLoadFloat3(&box.Extents);
-    XMVECTOR boxOrientation = XMLoadFloat4(&box.Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(boxOrientation));
-
-    XMVECTOR InsideAll = XMVectorTrueInt();
-
-    for (size_t i = 0; i < BoundingOrientedBox::CORNER_COUNT; ++i)
-    {
-        XMVECTOR C = XMVectorAdd(XMVector3Rotate(XMVectorMultiply(boxExtents, g_BoxOffset[i]), boxOrientation), boxCenter);
-        XMVECTOR d = XMVector3LengthSq(XMVectorSubtract(vCenter, C));
-        InsideAll = XMVectorAndInt(InsideAll, XMVectorLessOrEqual(d, RadiusSq));
-    }
-
-    return (XMVector3EqualInt(InsideAll, XMVectorTrueInt())) ? CONTAINS : INTERSECTS;
-
-}
-
-
-//-----------------------------------------------------------------------------
-// Frustum in sphere test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingSphere::Contains(const BoundingFrustum& fr) const noexcept
-{
-    if (!fr.Intersects(*this))
-        return DISJOINT;
-
-    XMVECTOR vCenter = XMLoadFloat3(&Center);
-    XMVECTOR vRadius = XMVectorReplicatePtr(&Radius);
-    XMVECTOR RadiusSq = XMVectorMultiply(vRadius, vRadius);
-
-    XMVECTOR vOrigin = XMLoadFloat3(&fr.Origin);
-    XMVECTOR vOrientation = XMLoadFloat4(&fr.Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-    // Build the corners of the frustum.
-    XMVECTOR vRightTop = XMVectorSet(fr.RightSlope, fr.TopSlope, 1.0f, 0.0f);
-    XMVECTOR vRightBottom = XMVectorSet(fr.RightSlope, fr.BottomSlope, 1.0f, 0.0f);
-    XMVECTOR vLeftTop = XMVectorSet(fr.LeftSlope, fr.TopSlope, 1.0f, 0.0f);
-    XMVECTOR vLeftBottom = XMVectorSet(fr.LeftSlope, fr.BottomSlope, 1.0f, 0.0f);
-    XMVECTOR vNear = XMVectorReplicatePtr(&fr.Near);
-    XMVECTOR vFar = XMVectorReplicatePtr(&fr.Far);
-
-    XMVECTOR Corners[BoundingFrustum::CORNER_COUNT];
-    Corners[0] = XMVectorMultiply(vRightTop, vNear);
-    Corners[1] = XMVectorMultiply(vRightBottom, vNear);
-    Corners[2] = XMVectorMultiply(vLeftTop, vNear);
-    Corners[3] = XMVectorMultiply(vLeftBottom, vNear);
-    Corners[4] = XMVectorMultiply(vRightTop, vFar);
-    Corners[5] = XMVectorMultiply(vRightBottom, vFar);
-    Corners[6] = XMVectorMultiply(vLeftTop, vFar);
-    Corners[7] = XMVectorMultiply(vLeftBottom, vFar);
-
-    XMVECTOR InsideAll = XMVectorTrueInt();
-    for (size_t i = 0; i < BoundingFrustum::CORNER_COUNT; ++i)
-    {
-        XMVECTOR C = XMVectorAdd(XMVector3Rotate(Corners[i], vOrientation), vOrigin);
-        XMVECTOR d = XMVector3LengthSq(XMVectorSubtract(vCenter, C));
-        InsideAll = XMVectorAndInt(InsideAll, XMVectorLessOrEqual(d, RadiusSq));
-    }
-
-    return (XMVector3EqualInt(InsideAll, XMVectorTrueInt())) ? CONTAINS : INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Sphere vs. sphere test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingSphere::Intersects(const BoundingSphere& sh) const noexcept
-{
-    // Load A.
-    XMVECTOR vCenterA = XMLoadFloat3(&Center);
-    XMVECTOR vRadiusA = XMVectorReplicatePtr(&Radius);
-
-    // Load B.
-    XMVECTOR vCenterB = XMLoadFloat3(&sh.Center);
-    XMVECTOR vRadiusB = XMVectorReplicatePtr(&sh.Radius);
-
-    // Distance squared between centers.
-    XMVECTOR Delta = XMVectorSubtract(vCenterB, vCenterA);
-    XMVECTOR DistanceSquared = XMVector3LengthSq(Delta);
-
-    // Sum of the radii squared.
-    XMVECTOR RadiusSquared = XMVectorAdd(vRadiusA, vRadiusB);
-    RadiusSquared = XMVectorMultiply(RadiusSquared, RadiusSquared);
-
-    return XMVector3LessOrEqual(DistanceSquared, RadiusSquared);
-}
-
-
-//-----------------------------------------------------------------------------
-// Box vs. sphere test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingSphere::Intersects(const BoundingBox& box) const noexcept
-{
-    return box.Intersects(*this);
-}
-
-_Use_decl_annotations_
-inline bool BoundingSphere::Intersects(const BoundingOrientedBox& box) const noexcept
-{
-    return box.Intersects(*this);
-}
-
-
-//-----------------------------------------------------------------------------
-// Frustum vs. sphere test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingSphere::Intersects(const BoundingFrustum& fr) const noexcept
-{
-    return fr.Intersects(*this);
-}
-
-
-//-----------------------------------------------------------------------------
-// Triangle vs sphere test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool XM_CALLCONV BoundingSphere::Intersects(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2) const noexcept
-{
-// Load the sphere.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vRadius = XMVectorReplicatePtr(&Radius);
-
-// Compute the plane of the triangle (has to be normalized).
-XMVECTOR N = XMVector3Normalize(XMVector3Cross(XMVectorSubtract(V1, V0), XMVectorSubtract(V2, V0)));
-
-// Assert that the triangle is not degenerate.
-assert(!XMVector3Equal(N, XMVectorZero()));
-
-// Find the nearest feature on the triangle to the sphere.
-XMVECTOR Dist = XMVector3Dot(XMVectorSubtract(vCenter, V0), N);
-
-// If the center of the sphere is farther from the plane of the triangle than
-// the radius of the sphere, then there cannot be an intersection.
-XMVECTOR NoIntersection = XMVectorLess(Dist, XMVectorNegate(vRadius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Dist, vRadius));
-
-// Project the center of the sphere onto the plane of the triangle.
-XMVECTOR Point = XMVectorNegativeMultiplySubtract(N, Dist, vCenter);
-
-// Is it inside all the edges? If so we intersect because the distance
-// to the plane is less than the radius.
-XMVECTOR Intersection = DirectX::Internal::PointOnPlaneInsideTriangle(Point, V0, V1, V2);
-
-// Find the nearest point on each edge.
-XMVECTOR RadiusSq = XMVectorMultiply(vRadius, vRadius);
-
-// Edge 0,1
-Point = DirectX::Internal::PointOnLineSegmentNearestPoint(V0, V1, vCenter);
-
-// If the distance to the center of the sphere to the point is less than
-// the radius of the sphere then it must intersect.
-Intersection = XMVectorOrInt(Intersection, XMVectorLessOrEqual(XMVector3LengthSq(XMVectorSubtract(vCenter, Point)), RadiusSq));
-
-// Edge 1,2
-Point = DirectX::Internal::PointOnLineSegmentNearestPoint(V1, V2, vCenter);
-
-// If the distance to the center of the sphere to the point is less than
-// the radius of the sphere then it must intersect.
-Intersection = XMVectorOrInt(Intersection, XMVectorLessOrEqual(XMVector3LengthSq(XMVectorSubtract(vCenter, Point)), RadiusSq));
-
-// Edge 2,0
-Point = DirectX::Internal::PointOnLineSegmentNearestPoint(V2, V0, vCenter);
-
-// If the distance to the center of the sphere to the point is less than
-// the radius of the sphere then it must intersect.
-Intersection = XMVectorOrInt(Intersection, XMVectorLessOrEqual(XMVector3LengthSq(XMVectorSubtract(vCenter, Point)), RadiusSq));
-
-return XMVector4EqualInt(XMVectorAndCInt(Intersection, NoIntersection), XMVectorTrueInt());
-}
-
-
-//-----------------------------------------------------------------------------
-// Sphere-plane intersection
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline PlaneIntersectionType XM_CALLCONV BoundingSphere::Intersects(FXMVECTOR Plane) const noexcept
-{
-assert(DirectX::Internal::XMPlaneIsUnit(Plane));
-
-// Load the sphere.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vRadius = XMVectorReplicatePtr(&Radius);
-
-// Set w of the center to one so we can dot4 with a plane.
-vCenter = XMVectorInsert<0, 0, 0, 0, 1>(vCenter, XMVectorSplatOne());
-
-XMVECTOR Outside, Inside;
-DirectX::Internal::FastIntersectSpherePlane(vCenter, vRadius, Plane, Outside, Inside);
-
-// If the sphere is outside any plane it is outside.
-if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-return FRONT;
-
-// If the sphere is inside all planes it is inside.
-if (XMVector4EqualInt(Inside, XMVectorTrueInt()))
-return BACK;
-
-// The sphere is not inside all planes or outside a plane it intersects.
-return INTERSECTING;
-}
-
-
-//-----------------------------------------------------------------------------
-// Compute the intersection of a ray (Origin, Direction) with a sphere.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool XM_CALLCONV BoundingSphere::Intersects(FXMVECTOR Origin, FXMVECTOR Direction, float& Dist) const noexcept
-{
-assert(DirectX::Internal::XMVector3IsUnit(Direction));
-
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vRadius = XMVectorReplicatePtr(&Radius);
-
-// l is the vector from the ray origin to the center of the sphere.
-XMVECTOR l = XMVectorSubtract(vCenter, Origin);
-
-// s is the projection of the l onto the ray direction.
-XMVECTOR s = XMVector3Dot(l, Direction);
-
-XMVECTOR l2 = XMVector3Dot(l, l);
-
-XMVECTOR r2 = XMVectorMultiply(vRadius, vRadius);
-
-// m2 is squared distance from the center of the sphere to the projection.
-XMVECTOR m2 = XMVectorNegativeMultiplySubtract(s, s, l2);
-
-XMVECTOR NoIntersection;
-
-// If the ray origin is outside the sphere and the center of the sphere is
-// behind the ray origin there is no intersection.
-NoIntersection = XMVectorAndInt(XMVectorLess(s, XMVectorZero()), XMVectorGreater(l2, r2));
-
-// If the squared distance from the center of the sphere to the projection
-// is greater than the radius squared the ray will miss the sphere.
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(m2, r2));
-
-// The ray hits the sphere, compute the nearest intersection point.
-XMVECTOR q = XMVectorSqrt(XMVectorSubtract(r2, m2));
-XMVECTOR t1 = XMVectorSubtract(s, q);
-XMVECTOR t2 = XMVectorAdd(s, q);
-
-XMVECTOR OriginInside = XMVectorLessOrEqual(l2, r2);
-XMVECTOR t = XMVectorSelect(t1, t2, OriginInside);
-
-if (XMVector4NotEqualInt(NoIntersection, XMVectorTrueInt()))
-{
-// Store the x-component to *pDist.
-XMStoreFloat(&Dist, t);
-return true;
-}
-
-Dist = 0.f;
-return false;
-}
-
-
-//-----------------------------------------------------------------------------
-// Test a sphere vs 6 planes (typically forming a frustum).
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingSphere::ContainedBy(
-        FXMVECTOR Plane0, FXMVECTOR Plane1, FXMVECTOR Plane2,
-GXMVECTOR Plane3,
-        HXMVECTOR Plane4, HXMVECTOR Plane5) const noexcept
-{
-// Load the sphere.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vRadius = XMVectorReplicatePtr(&Radius);
-
-// Set w of the center to one so we can dot4 with a plane.
-vCenter = XMVectorInsert<0, 0, 0, 0, 1>(vCenter, XMVectorSplatOne());
-
-XMVECTOR Outside, Inside;
-
-// Test against each plane.
-DirectX::Internal::FastIntersectSpherePlane(vCenter, vRadius, Plane0, Outside, Inside);
-
-XMVECTOR AnyOutside = Outside;
-XMVECTOR AllInside = Inside;
-
-DirectX::Internal::FastIntersectSpherePlane(vCenter, vRadius, Plane1, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectSpherePlane(vCenter, vRadius, Plane2, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectSpherePlane(vCenter, vRadius, Plane3, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectSpherePlane(vCenter, vRadius, Plane4, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectSpherePlane(vCenter, vRadius, Plane5, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-// If the sphere is outside any plane it is outside.
-if (XMVector4EqualInt(AnyOutside, XMVectorTrueInt()))
-return DISJOINT;
-
-// If the sphere is inside all planes it is inside.
-if (XMVector4EqualInt(AllInside, XMVectorTrueInt()))
-return CONTAINS;
-
-// The sphere is not inside all planes or outside a plane, it may intersect.
-return INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Creates a bounding sphere that contains two other bounding spheres
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingSphere::CreateMerged(BoundingSphere& Out, const BoundingSphere& S1, const BoundingSphere& S2) noexcept
-{
-XMVECTOR Center1 = XMLoadFloat3(&S1.Center);
-float r1 = S1.Radius;
-
-XMVECTOR Center2 = XMLoadFloat3(&S2.Center);
-float r2 = S2.Radius;
-
-XMVECTOR V = XMVectorSubtract(Center2, Center1);
-
-XMVECTOR Dist = XMVector3Length(V);
-
-float d = XMVectorGetX(Dist);
-
-if (r1 + r2 >= d)
-{
-if (r1 - r2 >= d)
-{
-Out = S1;
-return;
-}
-else if (r2 - r1 >= d)
-{
-Out = S2;
-return;
-}
-}
-
-XMVECTOR N = XMVectorDivide(V, Dist);
-
-float t1 = XMMin(-r1, d - r2);
-float t2 = XMMax(r1, d + r2);
-float t_5 = (t2 - t1) * 0.5f;
-
-XMVECTOR NCenter = XMVectorAdd(Center1, XMVectorMultiply(N, XMVectorReplicate(t_5 + t1)));
-
-XMStoreFloat3(&Out.Center, NCenter);
-Out.Radius = t_5;
-}
-
-
-//-----------------------------------------------------------------------------
-// Create sphere enscribing bounding box
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingSphere::CreateFromBoundingBox(BoundingSphere& Out, const BoundingBox& box) noexcept
-{
-Out.Center = box.Center;
-XMVECTOR vExtents = XMLoadFloat3(&box.Extents);
-Out.Radius = XMVectorGetX(XMVector3Length(vExtents));
-}
-
-_Use_decl_annotations_
-inline void BoundingSphere::CreateFromBoundingBox(BoundingSphere& Out, const BoundingOrientedBox& box) noexcept
-{
-// Bounding box orientation is irrelevant because a sphere is rotationally invariant
-Out.Center = box.Center;
-XMVECTOR vExtents = XMLoadFloat3(&box.Extents);
-Out.Radius = XMVectorGetX(XMVector3Length(vExtents));
-}
-
-
-//-----------------------------------------------------------------------------
-// Find the approximate smallest enclosing bounding sphere for a set of
-// points. Exact computation of the smallest enclosing bounding sphere is
-// possible but is slower and requires a more complex algorithm.
-// The algorithm is based on  Jack Ritter, "An Efficient Bounding Sphere",
-// Graphics Gems.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingSphere::CreateFromPoints(BoundingSphere& Out, size_t Count, const XMFLOAT3* pPoints, size_t Stride) noexcept
-{
-assert(Count > 0);
-assert(pPoints);
-
-// Find the points with minimum and maximum x, y, and z
-XMVECTOR MinX, MaxX, MinY, MaxY, MinZ, MaxZ;
-
-MinX = MaxX = MinY = MaxY = MinZ = MaxZ = XMLoadFloat3(pPoints);
-
-for (size_t i = 1; i < Count; ++i)
-{
-XMVECTOR Point = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(reinterpret_cast<const uint8_t*>(pPoints) + i * Stride));
-
-float px = XMVectorGetX(Point);
-float py = XMVectorGetY(Point);
-float pz = XMVectorGetZ(Point);
-
-if (px < XMVectorGetX(MinX))
-MinX = Point;
-
-if (px > XMVectorGetX(MaxX))
-MaxX = Point;
-
-if (py < XMVectorGetY(MinY))
-MinY = Point;
-
-if (py > XMVectorGetY(MaxY))
-MaxY = Point;
-
-if (pz < XMVectorGetZ(MinZ))
-MinZ = Point;
-
-if (pz > XMVectorGetZ(MaxZ))
-MaxZ = Point;
-}
-
-// Use the min/max pair that are farthest apart to form the initial sphere.
-XMVECTOR DeltaX = XMVectorSubtract(MaxX, MinX);
-XMVECTOR DistX = XMVector3Length(DeltaX);
-
-XMVECTOR DeltaY = XMVectorSubtract(MaxY, MinY);
-XMVECTOR DistY = XMVector3Length(DeltaY);
-
-XMVECTOR DeltaZ = XMVectorSubtract(MaxZ, MinZ);
-XMVECTOR DistZ = XMVector3Length(DeltaZ);
-
-XMVECTOR vCenter;
-XMVECTOR vRadius;
-
-if (XMVector3Greater(DistX, DistY))
-{
-if (XMVector3Greater(DistX, DistZ))
-{
-// Use min/max x.
-vCenter = XMVectorLerp(MaxX, MinX, 0.5f);
-vRadius = XMVectorScale(DistX, 0.5f);
-}
-else
-{
-// Use min/max z.
-vCenter = XMVectorLerp(MaxZ, MinZ, 0.5f);
-vRadius = XMVectorScale(DistZ, 0.5f);
-}
-}
-else // Y >= X
-{
-if (XMVector3Greater(DistY, DistZ))
-{
-// Use min/max y.
-vCenter = XMVectorLerp(MaxY, MinY, 0.5f);
-vRadius = XMVectorScale(DistY, 0.5f);
-}
-else
-{
-// Use min/max z.
-vCenter = XMVectorLerp(MaxZ, MinZ, 0.5f);
-vRadius = XMVectorScale(DistZ, 0.5f);
-}
-}
-
-// Add any points not inside the sphere.
-for (size_t i = 0; i < Count; ++i)
-{
-XMVECTOR Point = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(reinterpret_cast<const uint8_t*>(pPoints) + i * Stride));
-
-XMVECTOR Delta = XMVectorSubtract(Point, vCenter);
-
-XMVECTOR Dist = XMVector3Length(Delta);
-
-if (XMVector3Greater(Dist, vRadius))
-{
-// Adjust sphere to include the new point.
-vRadius = XMVectorScale(XMVectorAdd(vRadius, Dist), 0.5f);
-vCenter = XMVectorAdd(vCenter, XMVectorMultiply(XMVectorSubtract(XMVectorReplicate(1.0f), XMVectorDivide(vRadius, Dist)), Delta));
-}
-}
-
-XMStoreFloat3(&Out.Center, vCenter);
-XMStoreFloat(&Out.Radius, vRadius);
-}
-
-
-//-----------------------------------------------------------------------------
-// Create sphere containing frustum
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingSphere::CreateFromFrustum(BoundingSphere& Out, const BoundingFrustum& fr) noexcept
-{
-XMFLOAT3 Corners[BoundingFrustum::CORNER_COUNT];
-fr.GetCorners(Corners);
-CreateFromPoints(Out, BoundingFrustum::CORNER_COUNT, Corners, sizeof(XMFLOAT3));
-}
-
-
-/****************************************************************************
- *
- * BoundingBox
- *
- ****************************************************************************/
-
-//-----------------------------------------------------------------------------
-// Transform an axis aligned box by an angle preserving transform.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingBox::Transform(BoundingBox& Out, FXMMATRIX M) const noexcept
-{
-// Load center and extents.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-// Compute and transform the corners and find new min/max bounds.
-XMVECTOR Corner = XMVectorMultiplyAdd(vExtents, g_BoxOffset[0], vCenter);
-Corner = XMVector3Transform(Corner, M);
-
-XMVECTOR Min, Max;
-Min = Max = Corner;
-
-for (size_t i = 1; i < CORNER_COUNT; ++i)
-{
-Corner = XMVectorMultiplyAdd(vExtents, g_BoxOffset[i], vCenter);
-Corner = XMVector3Transform(Corner, M);
-
-Min = XMVectorMin(Min, Corner);
-Max = XMVectorMax(Max, Corner);
-}
-
-// Store center and extents.
-XMStoreFloat3(&Out.Center, XMVectorScale(XMVectorAdd(Min, Max), 0.5f));
-XMStoreFloat3(&Out.Extents, XMVectorScale(XMVectorSubtract(Max, Min), 0.5f));
-}
-
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingBox::Transform(BoundingBox& Out, float Scale, FXMVECTOR Rotation, FXMVECTOR Translation) const noexcept
-{
-assert(DirectX::Internal::XMQuaternionIsUnit(Rotation));
-
-// Load center and extents.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-XMVECTOR VectorScale = XMVectorReplicate(Scale);
-
-// Compute and transform the corners and find new min/max bounds.
-XMVECTOR Corner = XMVectorMultiplyAdd(vExtents, g_BoxOffset[0], vCenter);
-Corner = XMVectorAdd(XMVector3Rotate(XMVectorMultiply(Corner, VectorScale), Rotation), Translation);
-
-XMVECTOR Min, Max;
-Min = Max = Corner;
-
-for (size_t i = 1; i < CORNER_COUNT; ++i)
-{
-Corner = XMVectorMultiplyAdd(vExtents, g_BoxOffset[i], vCenter);
-Corner = XMVectorAdd(XMVector3Rotate(XMVectorMultiply(Corner, VectorScale), Rotation), Translation);
-
-Min = XMVectorMin(Min, Corner);
-Max = XMVectorMax(Max, Corner);
-}
-
-// Store center and extents.
-XMStoreFloat3(&Out.Center, XMVectorScale(XMVectorAdd(Min, Max), 0.5f));
-XMStoreFloat3(&Out.Extents, XMVectorScale(XMVectorSubtract(Max, Min), 0.5f));
-}
-
-
-//-----------------------------------------------------------------------------
-// Get the corner points of the box
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingBox::GetCorners(XMFLOAT3* Corners) const noexcept
-{
-    assert(Corners != nullptr);
-
-    // Load the box
-    XMVECTOR vCenter = XMLoadFloat3(&Center);
-    XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-    for (size_t i = 0; i < CORNER_COUNT; ++i)
-    {
-        XMVECTOR C = XMVectorMultiplyAdd(vExtents, g_BoxOffset[i], vCenter);
-        XMStoreFloat3(&Corners[i], C);
-    }
-}
-
-
-//-----------------------------------------------------------------------------
-// Point in axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingBox::Contains(FXMVECTOR Point) const noexcept
-{
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-return XMVector3InBounds(XMVectorSubtract(Point, vCenter), vExtents) ? CONTAINS : DISJOINT;
-}
-
-
-//-----------------------------------------------------------------------------
-// Triangle in axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingBox::Contains(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2) const noexcept
-{
-if (!Intersects(V0, V1, V2))
-return DISJOINT;
-
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-XMVECTOR d = XMVectorAbs(XMVectorSubtract(V0, vCenter));
-XMVECTOR Inside = XMVectorLessOrEqual(d, vExtents);
-
-d = XMVectorAbs(XMVectorSubtract(V1, vCenter));
-Inside = XMVectorAndInt(Inside, XMVectorLessOrEqual(d, vExtents));
-
-d = XMVectorAbs(XMVectorSubtract(V2, vCenter));
-Inside = XMVectorAndInt(Inside, XMVectorLessOrEqual(d, vExtents));
-
-return (XMVector3EqualInt(Inside, XMVectorTrueInt())) ? CONTAINS : INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Sphere in axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingBox::Contains(const BoundingSphere& sh) const noexcept
-{
-    XMVECTOR SphereCenter = XMLoadFloat3(&sh.Center);
-    XMVECTOR SphereRadius = XMVectorReplicatePtr(&sh.Radius);
-
-    XMVECTOR BoxCenter = XMLoadFloat3(&Center);
-    XMVECTOR BoxExtents = XMLoadFloat3(&Extents);
-
-    XMVECTOR BoxMin = XMVectorSubtract(BoxCenter, BoxExtents);
-    XMVECTOR BoxMax = XMVectorAdd(BoxCenter, BoxExtents);
-
-    // Find the distance to the nearest point on the box.
-    // for each i in (x, y, z)
-    // if (SphereCenter(i) < BoxMin(i)) d2 += (SphereCenter(i) - BoxMin(i)) ^ 2
-    // else if (SphereCenter(i) > BoxMax(i)) d2 += (SphereCenter(i) - BoxMax(i)) ^ 2
-
-    XMVECTOR d = XMVectorZero();
-
-    // Compute d for each dimension.
-    XMVECTOR LessThanMin = XMVectorLess(SphereCenter, BoxMin);
-    XMVECTOR GreaterThanMax = XMVectorGreater(SphereCenter, BoxMax);
-
-    XMVECTOR MinDelta = XMVectorSubtract(SphereCenter, BoxMin);
-    XMVECTOR MaxDelta = XMVectorSubtract(SphereCenter, BoxMax);
-
-    // Choose value for each dimension based on the comparison.
-    d = XMVectorSelect(d, MinDelta, LessThanMin);
-    d = XMVectorSelect(d, MaxDelta, GreaterThanMax);
-
-    // Use a dot-product to square them and sum them together.
-    XMVECTOR d2 = XMVector3Dot(d, d);
-
-    if (XMVector3Greater(d2, XMVectorMultiply(SphereRadius, SphereRadius)))
-        return DISJOINT;
-
-    XMVECTOR InsideAll = XMVectorLessOrEqual(XMVectorAdd(BoxMin, SphereRadius), SphereCenter);
-    InsideAll = XMVectorAndInt(InsideAll, XMVectorLessOrEqual(SphereCenter, XMVectorSubtract(BoxMax, SphereRadius)));
-    InsideAll = XMVectorAndInt(InsideAll, XMVectorGreater(XMVectorSubtract(BoxMax, BoxMin), SphereRadius));
-
-    return (XMVector3EqualInt(InsideAll, XMVectorTrueInt())) ? CONTAINS : INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Axis-aligned box in axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingBox::Contains(const BoundingBox& box) const noexcept
-{
-    XMVECTOR CenterA = XMLoadFloat3(&Center);
-    XMVECTOR ExtentsA = XMLoadFloat3(&Extents);
-
-    XMVECTOR CenterB = XMLoadFloat3(&box.Center);
-    XMVECTOR ExtentsB = XMLoadFloat3(&box.Extents);
-
-    XMVECTOR MinA = XMVectorSubtract(CenterA, ExtentsA);
-    XMVECTOR MaxA = XMVectorAdd(CenterA, ExtentsA);
-
-    XMVECTOR MinB = XMVectorSubtract(CenterB, ExtentsB);
-    XMVECTOR MaxB = XMVectorAdd(CenterB, ExtentsB);
-
-    // for each i in (x, y, z) if a_min(i) > b_max(i) or b_min(i) > a_max(i) then return false
-    XMVECTOR Disjoint = XMVectorOrInt(XMVectorGreater(MinA, MaxB), XMVectorGreater(MinB, MaxA));
-
-    if (DirectX::Internal::XMVector3AnyTrue(Disjoint))
-        return DISJOINT;
-
-    // for each i in (x, y, z) if a_min(i) <= b_min(i) and b_max(i) <= a_max(i) then A contains B
-    XMVECTOR Inside = XMVectorAndInt(XMVectorLessOrEqual(MinA, MinB), XMVectorLessOrEqual(MaxB, MaxA));
-
-    return DirectX::Internal::XMVector3AllTrue(Inside) ? CONTAINS : INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Oriented box in axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingBox::Contains(const BoundingOrientedBox& box) const noexcept
-{
-    if (!box.Intersects(*this))
-        return DISJOINT;
-
-    XMVECTOR vCenter = XMLoadFloat3(&Center);
-    XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-    // Subtract off the AABB center to remove a subtract below
-    XMVECTOR oCenter = XMVectorSubtract(XMLoadFloat3(&box.Center), vCenter);
-
-    XMVECTOR oExtents = XMLoadFloat3(&box.Extents);
-    XMVECTOR oOrientation = XMLoadFloat4(&box.Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(oOrientation));
-
-    XMVECTOR Inside = XMVectorTrueInt();
-
-    for (size_t i = 0; i < BoundingOrientedBox::CORNER_COUNT; ++i)
-    {
-        XMVECTOR C = XMVectorAdd(XMVector3Rotate(XMVectorMultiply(oExtents, g_BoxOffset[i]), oOrientation), oCenter);
-        XMVECTOR d = XMVectorAbs(C);
-        Inside = XMVectorAndInt(Inside, XMVectorLessOrEqual(d, vExtents));
-    }
-
-    return (XMVector3EqualInt(Inside, XMVectorTrueInt())) ? CONTAINS : INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Frustum in axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingBox::Contains(const BoundingFrustum& fr) const noexcept
-{
-    if (!fr.Intersects(*this))
-        return DISJOINT;
-
-    XMFLOAT3 Corners[BoundingFrustum::CORNER_COUNT];
-    fr.GetCorners(Corners);
-
-    XMVECTOR vCenter = XMLoadFloat3(&Center);
-    XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-    XMVECTOR Inside = XMVectorTrueInt();
-
-    for (size_t i = 0; i < BoundingFrustum::CORNER_COUNT; ++i)
-    {
-        XMVECTOR Point = XMLoadFloat3(&Corners[i]);
-        XMVECTOR d = XMVectorAbs(XMVectorSubtract(Point, vCenter));
-        Inside = XMVectorAndInt(Inside, XMVectorLessOrEqual(d, vExtents));
-    }
-
-    return (XMVector3EqualInt(Inside, XMVectorTrueInt())) ? CONTAINS : INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Sphere vs axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingBox::Intersects(const BoundingSphere& sh) const noexcept
-{
-    XMVECTOR SphereCenter = XMLoadFloat3(&sh.Center);
-    XMVECTOR SphereRadius = XMVectorReplicatePtr(&sh.Radius);
-
-    XMVECTOR BoxCenter = XMLoadFloat3(&Center);
-    XMVECTOR BoxExtents = XMLoadFloat3(&Extents);
-
-    XMVECTOR BoxMin = XMVectorSubtract(BoxCenter, BoxExtents);
-    XMVECTOR BoxMax = XMVectorAdd(BoxCenter, BoxExtents);
-
-    // Find the distance to the nearest point on the box.
-    // for each i in (x, y, z)
-    // if (SphereCenter(i) < BoxMin(i)) d2 += (SphereCenter(i) - BoxMin(i)) ^ 2
-    // else if (SphereCenter(i) > BoxMax(i)) d2 += (SphereCenter(i) - BoxMax(i)) ^ 2
-
-    XMVECTOR d = XMVectorZero();
-
-    // Compute d for each dimension.
-    XMVECTOR LessThanMin = XMVectorLess(SphereCenter, BoxMin);
-    XMVECTOR GreaterThanMax = XMVectorGreater(SphereCenter, BoxMax);
-
-    XMVECTOR MinDelta = XMVectorSubtract(SphereCenter, BoxMin);
-    XMVECTOR MaxDelta = XMVectorSubtract(SphereCenter, BoxMax);
-
-    // Choose value for each dimension based on the comparison.
-    d = XMVectorSelect(d, MinDelta, LessThanMin);
-    d = XMVectorSelect(d, MaxDelta, GreaterThanMax);
-
-    // Use a dot-product to square them and sum them together.
-    XMVECTOR d2 = XMVector3Dot(d, d);
-
-    return XMVector3LessOrEqual(d2, XMVectorMultiply(SphereRadius, SphereRadius));
-}
-
-
-//-----------------------------------------------------------------------------
-// Axis-aligned box vs. axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingBox::Intersects(const BoundingBox& box) const noexcept
-{
-    XMVECTOR CenterA = XMLoadFloat3(&Center);
-    XMVECTOR ExtentsA = XMLoadFloat3(&Extents);
-
-    XMVECTOR CenterB = XMLoadFloat3(&box.Center);
-    XMVECTOR ExtentsB = XMLoadFloat3(&box.Extents);
-
-    XMVECTOR MinA = XMVectorSubtract(CenterA, ExtentsA);
-    XMVECTOR MaxA = XMVectorAdd(CenterA, ExtentsA);
-
-    XMVECTOR MinB = XMVectorSubtract(CenterB, ExtentsB);
-    XMVECTOR MaxB = XMVectorAdd(CenterB, ExtentsB);
-
-    // for each i in (x, y, z) if a_min(i) > b_max(i) or b_min(i) > a_max(i) then return false
-    XMVECTOR Disjoint = XMVectorOrInt(XMVectorGreater(MinA, MaxB), XMVectorGreater(MinB, MaxA));
-
-    return !DirectX::Internal::XMVector3AnyTrue(Disjoint);
-}
-
-
-//-----------------------------------------------------------------------------
-// Oriented box vs. axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingBox::Intersects(const BoundingOrientedBox& box) const noexcept
-{
-    return box.Intersects(*this);
-}
-
-
-//-----------------------------------------------------------------------------
-// Frustum vs. axis-aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingBox::Intersects(const BoundingFrustum& fr) const noexcept
-{
-    return fr.Intersects(*this);
-}
-
-
-//-----------------------------------------------------------------------------
-// Triangle vs. axis aligned box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool XM_CALLCONV BoundingBox::Intersects(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2) const noexcept
-{
-XMVECTOR Zero = XMVectorZero();
-
-// Load the box.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-XMVECTOR BoxMin = XMVectorSubtract(vCenter, vExtents);
-XMVECTOR BoxMax = XMVectorAdd(vCenter, vExtents);
-
-// Test the axes of the box (in effect test the AAB against the minimal AAB
-// around the triangle).
-XMVECTOR TriMin = XMVectorMin(XMVectorMin(V0, V1), V2);
-XMVECTOR TriMax = XMVectorMax(XMVectorMax(V0, V1), V2);
-
-// for each i in (x, y, z) if a_min(i) > b_max(i) or b_min(i) > a_max(i) then disjoint
-XMVECTOR Disjoint = XMVectorOrInt(XMVectorGreater(TriMin, BoxMax), XMVectorGreater(BoxMin, TriMax));
-if (DirectX::Internal::XMVector3AnyTrue(Disjoint))
-return false;
-
-// Test the plane of the triangle.
-XMVECTOR Normal = XMVector3Cross(XMVectorSubtract(V1, V0), XMVectorSubtract(V2, V0));
-XMVECTOR Dist = XMVector3Dot(Normal, V0);
-
-// Assert that the triangle is not degenerate.
-assert(!XMVector3Equal(Normal, Zero));
-
-// for each i in (x, y, z) if n(i) >= 0 then v_min(i)=b_min(i), v_max(i)=b_max(i)
-// else v_min(i)=b_max(i), v_max(i)=b_min(i)
-XMVECTOR NormalSelect = XMVectorGreater(Normal, Zero);
-XMVECTOR V_Min = XMVectorSelect(BoxMax, BoxMin, NormalSelect);
-XMVECTOR V_Max = XMVectorSelect(BoxMin, BoxMax, NormalSelect);
-
-// if n dot v_min + d > 0 || n dot v_max + d < 0 then disjoint
-XMVECTOR MinDist = XMVector3Dot(V_Min, Normal);
-XMVECTOR MaxDist = XMVector3Dot(V_Max, Normal);
-
-XMVECTOR NoIntersection = XMVectorGreater(MinDist, Dist);
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(MaxDist, Dist));
-
-// Move the box center to zero to simplify the following tests.
-XMVECTOR TV0 = XMVectorSubtract(V0, vCenter);
-XMVECTOR TV1 = XMVectorSubtract(V1, vCenter);
-XMVECTOR TV2 = XMVectorSubtract(V2, vCenter);
-
-// Test the edge/edge axes (3*3).
-XMVECTOR e0 = XMVectorSubtract(TV1, TV0);
-XMVECTOR e1 = XMVectorSubtract(TV2, TV1);
-XMVECTOR e2 = XMVectorSubtract(TV0, TV2);
-
-// Make w zero.
-e0 = XMVectorInsert<0, 0, 0, 0, 1>(e0, Zero);
-e1 = XMVectorInsert<0, 0, 0, 0, 1>(e1, Zero);
-e2 = XMVectorInsert<0, 0, 0, 0, 1>(e2, Zero);
-
-XMVECTOR Axis;
-XMVECTOR p0, p1, p2;
-XMVECTOR Min, Max;
-XMVECTOR Radius;
-
-// Axis == (1,0,0) x e0 = (0, -e0.z, e0.y)
-Axis = XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_0X>(e0, XMVectorNegate(e0));
-p0 = XMVector3Dot(TV0, Axis);
-// p1 = XMVector3Dot( V1, Axis ); // p1 = p0;
-p2 = XMVector3Dot(TV2, Axis);
-Min = XMVectorMin(p0, p2);
-Max = XMVectorMax(p0, p2);
-Radius = XMVector3Dot(vExtents, XMVectorAbs(Axis));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Min, Radius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(Max, XMVectorNegate(Radius)));
-
-// Axis == (1,0,0) x e1 = (0, -e1.z, e1.y)
-Axis = XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_0X>(e1, XMVectorNegate(e1));
-p0 = XMVector3Dot(TV0, Axis);
-p1 = XMVector3Dot(TV1, Axis);
-// p2 = XMVector3Dot( V2, Axis ); // p2 = p1;
-Min = XMVectorMin(p0, p1);
-Max = XMVectorMax(p0, p1);
-Radius = XMVector3Dot(vExtents, XMVectorAbs(Axis));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Min, Radius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(Max, XMVectorNegate(Radius)));
-
-// Axis == (1,0,0) x e2 = (0, -e2.z, e2.y)
-Axis = XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_0X>(e2, XMVectorNegate(e2));
-p0 = XMVector3Dot(TV0, Axis);
-p1 = XMVector3Dot(TV1, Axis);
-// p2 = XMVector3Dot( V2, Axis ); // p2 = p0;
-Min = XMVectorMin(p0, p1);
-Max = XMVectorMax(p0, p1);
-Radius = XMVector3Dot(vExtents, XMVectorAbs(Axis));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Min, Radius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(Max, XMVectorNegate(Radius)));
-
-// Axis == (0,1,0) x e0 = (e0.z, 0, -e0.x)
-Axis = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0Y>(e0, XMVectorNegate(e0));
-p0 = XMVector3Dot(TV0, Axis);
-// p1 = XMVector3Dot( V1, Axis ); // p1 = p0;
-p2 = XMVector3Dot(TV2, Axis);
-Min = XMVectorMin(p0, p2);
-Max = XMVectorMax(p0, p2);
-Radius = XMVector3Dot(vExtents, XMVectorAbs(Axis));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Min, Radius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(Max, XMVectorNegate(Radius)));
-
-// Axis == (0,1,0) x e1 = (e1.z, 0, -e1.x)
-Axis = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0Y>(e1, XMVectorNegate(e1));
-p0 = XMVector3Dot(TV0, Axis);
-p1 = XMVector3Dot(TV1, Axis);
-// p2 = XMVector3Dot( V2, Axis ); // p2 = p1;
-Min = XMVectorMin(p0, p1);
-Max = XMVectorMax(p0, p1);
-Radius = XMVector3Dot(vExtents, XMVectorAbs(Axis));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Min, Radius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(Max, XMVectorNegate(Radius)));
-
-// Axis == (0,0,1) x e2 = (e2.z, 0, -e2.x)
-Axis = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0Y>(e2, XMVectorNegate(e2));
-p0 = XMVector3Dot(TV0, Axis);
-p1 = XMVector3Dot(TV1, Axis);
-// p2 = XMVector3Dot( V2, Axis ); // p2 = p0;
-Min = XMVectorMin(p0, p1);
-Max = XMVectorMax(p0, p1);
-Radius = XMVector3Dot(vExtents, XMVectorAbs(Axis));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Min, Radius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(Max, XMVectorNegate(Radius)));
-
-// Axis == (0,0,1) x e0 = (-e0.y, e0.x, 0)
-Axis = XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0Z>(e0, XMVectorNegate(e0));
-p0 = XMVector3Dot(TV0, Axis);
-// p1 = XMVector3Dot( V1, Axis ); // p1 = p0;
-p2 = XMVector3Dot(TV2, Axis);
-Min = XMVectorMin(p0, p2);
-Max = XMVectorMax(p0, p2);
-Radius = XMVector3Dot(vExtents, XMVectorAbs(Axis));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Min, Radius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(Max, XMVectorNegate(Radius)));
-
-// Axis == (0,0,1) x e1 = (-e1.y, e1.x, 0)
-Axis = XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0Z>(e1, XMVectorNegate(e1));
-p0 = XMVector3Dot(TV0, Axis);
-p1 = XMVector3Dot(TV1, Axis);
-// p2 = XMVector3Dot( V2, Axis ); // p2 = p1;
-Min = XMVectorMin(p0, p1);
-Max = XMVectorMax(p0, p1);
-Radius = XMVector3Dot(vExtents, XMVectorAbs(Axis));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Min, Radius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(Max, XMVectorNegate(Radius)));
-
-// Axis == (0,0,1) x e2 = (-e2.y, e2.x, 0)
-Axis = XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0Z>(e2, XMVectorNegate(e2));
-p0 = XMVector3Dot(TV0, Axis);
-p1 = XMVector3Dot(TV1, Axis);
-// p2 = XMVector3Dot( V2, Axis ); // p2 = p0;
-Min = XMVectorMin(p0, p1);
-Max = XMVectorMax(p0, p1);
-Radius = XMVector3Dot(vExtents, XMVectorAbs(Axis));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(Min, Radius));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(Max, XMVectorNegate(Radius)));
-
-return XMVector4NotEqualInt(NoIntersection, XMVectorTrueInt());
-}
-
-
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline PlaneIntersectionType XM_CALLCONV BoundingBox::Intersects(FXMVECTOR Plane) const noexcept
-{
-assert(DirectX::Internal::XMPlaneIsUnit(Plane));
-
-// Load the box.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-// Set w of the center to one so we can dot4 with a plane.
-vCenter = XMVectorInsert<0, 0, 0, 0, 1>(vCenter, XMVectorSplatOne());
-
-XMVECTOR Outside, Inside;
-DirectX::Internal::FastIntersectAxisAlignedBoxPlane(vCenter, vExtents, Plane, Outside, Inside);
-
-// If the box is outside any plane it is outside.
-if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-return FRONT;
-
-// If the box is inside all planes it is inside.
-if (XMVector4EqualInt(Inside, XMVectorTrueInt()))
-return BACK;
-
-// The box is not inside all planes or outside a plane it intersects.
-return INTERSECTING;
-}
-
-
-//-----------------------------------------------------------------------------
-// Compute the intersection of a ray (Origin, Direction) with an axis aligned
-// box using the slabs method.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool XM_CALLCONV BoundingBox::Intersects(FXMVECTOR Origin, FXMVECTOR Direction, float& Dist) const noexcept
-{
-assert(DirectX::Internal::XMVector3IsUnit(Direction));
-
-// Load the box.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-// Adjust ray origin to be relative to center of the box.
-XMVECTOR TOrigin = XMVectorSubtract(vCenter, Origin);
-
-// Compute the dot product againt each axis of the box.
-// Since the axii are (1,0,0), (0,1,0), (0,0,1) no computation is necessary.
-XMVECTOR AxisDotOrigin = TOrigin;
-XMVECTOR AxisDotDirection = Direction;
-
-// if (fabs(AxisDotDirection) <= Epsilon) the ray is nearly parallel to the slab.
-XMVECTOR IsParallel = XMVectorLessOrEqual(XMVectorAbs(AxisDotDirection), g_RayEpsilon);
-
-// Test against all three axii simultaneously.
-XMVECTOR InverseAxisDotDirection = XMVectorReciprocal(AxisDotDirection);
-XMVECTOR t1 = XMVectorMultiply(XMVectorSubtract(AxisDotOrigin, vExtents), InverseAxisDotDirection);
-XMVECTOR t2 = XMVectorMultiply(XMVectorAdd(AxisDotOrigin, vExtents), InverseAxisDotDirection);
-
-// Compute the max of min(t1,t2) and the min of max(t1,t2) ensuring we don't
-// use the results from any directions parallel to the slab.
-XMVECTOR t_min = XMVectorSelect(XMVectorMin(t1, t2), g_FltMin, IsParallel);
-XMVECTOR t_max = XMVectorSelect(XMVectorMax(t1, t2), g_FltMax, IsParallel);
-
-// t_min.x = maximum( t_min.x, t_min.y, t_min.z );
-// t_max.x = minimum( t_max.x, t_max.y, t_max.z );
-t_min = XMVectorMax(t_min, XMVectorSplatY(t_min));  // x = max(x,y)
-t_min = XMVectorMax(t_min, XMVectorSplatZ(t_min));  // x = max(max(x,y),z)
-t_max = XMVectorMin(t_max, XMVectorSplatY(t_max));  // x = min(x,y)
-t_max = XMVectorMin(t_max, XMVectorSplatZ(t_max));  // x = min(min(x,y),z)
-
-// if ( t_min > t_max ) return false;
-XMVECTOR NoIntersection = XMVectorGreater(XMVectorSplatX(t_min), XMVectorSplatX(t_max));
-
-// if ( t_max < 0.0f ) return false;
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(XMVectorSplatX(t_max), XMVectorZero()));
-
-// if (IsParallel && (-Extents > AxisDotOrigin || Extents < AxisDotOrigin)) return false;
-XMVECTOR ParallelOverlap = XMVectorInBounds(AxisDotOrigin, vExtents);
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorAndCInt(IsParallel, ParallelOverlap));
-
-if (!DirectX::Internal::XMVector3AnyTrue(NoIntersection))
-{
-// Store the x-component to *pDist
-XMStoreFloat(&Dist, t_min);
-return true;
-}
-
-Dist = 0.f;
-return false;
-}
-
-
-//-----------------------------------------------------------------------------
-// Test an axis alinged box vs 6 planes (typically forming a frustum).
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingBox::ContainedBy(
-        FXMVECTOR Plane0, FXMVECTOR Plane1, FXMVECTOR Plane2,
-GXMVECTOR Plane3,
-        HXMVECTOR Plane4, HXMVECTOR Plane5) const noexcept
-{
-// Load the box.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-
-// Set w of the center to one so we can dot4 with a plane.
-vCenter = XMVectorInsert<0, 0, 0, 0, 1>(vCenter, XMVectorSplatOne());
-
-XMVECTOR Outside, Inside;
-
-// Test against each plane.
-DirectX::Internal::FastIntersectAxisAlignedBoxPlane(vCenter, vExtents, Plane0, Outside, Inside);
-
-XMVECTOR AnyOutside = Outside;
-XMVECTOR AllInside = Inside;
-
-DirectX::Internal::FastIntersectAxisAlignedBoxPlane(vCenter, vExtents, Plane1, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectAxisAlignedBoxPlane(vCenter, vExtents, Plane2, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectAxisAlignedBoxPlane(vCenter, vExtents, Plane3, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectAxisAlignedBoxPlane(vCenter, vExtents, Plane4, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectAxisAlignedBoxPlane(vCenter, vExtents, Plane5, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-// If the box is outside any plane it is outside.
-if (XMVector4EqualInt(AnyOutside, XMVectorTrueInt()))
-return DISJOINT;
-
-// If the box is inside all planes it is inside.
-if (XMVector4EqualInt(AllInside, XMVectorTrueInt()))
-return CONTAINS;
-
-// The box is not inside all planes or outside a plane, it may intersect.
-return INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Create axis-aligned box that contains two other bounding boxes
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingBox::CreateMerged(BoundingBox& Out, const BoundingBox& b1, const BoundingBox& b2) noexcept
-{
-XMVECTOR b1Center = XMLoadFloat3(&b1.Center);
-XMVECTOR b1Extents = XMLoadFloat3(&b1.Extents);
-
-XMVECTOR b2Center = XMLoadFloat3(&b2.Center);
-XMVECTOR b2Extents = XMLoadFloat3(&b2.Extents);
-
-XMVECTOR Min = XMVectorSubtract(b1Center, b1Extents);
-Min = XMVectorMin(Min, XMVectorSubtract(b2Center, b2Extents));
-
-XMVECTOR Max = XMVectorAdd(b1Center, b1Extents);
-Max = XMVectorMax(Max, XMVectorAdd(b2Center, b2Extents));
-
-assert(XMVector3LessOrEqual(Min, Max));
-
-XMStoreFloat3(&Out.Center, XMVectorScale(XMVectorAdd(Min, Max), 0.5f));
-XMStoreFloat3(&Out.Extents, XMVectorScale(XMVectorSubtract(Max, Min), 0.5f));
-}
-
-
-//-----------------------------------------------------------------------------
-// Create axis-aligned box that contains a bounding sphere
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingBox::CreateFromSphere(BoundingBox& Out, const BoundingSphere& sh) noexcept
-{
-XMVECTOR spCenter = XMLoadFloat3(&sh.Center);
-XMVECTOR shRadius = XMVectorReplicatePtr(&sh.Radius);
-
-XMVECTOR Min = XMVectorSubtract(spCenter, shRadius);
-XMVECTOR Max = XMVectorAdd(spCenter, shRadius);
-
-assert(XMVector3LessOrEqual(Min, Max));
-
-XMStoreFloat3(&Out.Center, XMVectorScale(XMVectorAdd(Min, Max), 0.5f));
-XMStoreFloat3(&Out.Extents, XMVectorScale(XMVectorSubtract(Max, Min), 0.5f));
-}
-
-
-//-----------------------------------------------------------------------------
-// Create axis-aligned box from min/max points
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingBox::CreateFromPoints(BoundingBox& Out, FXMVECTOR pt1, FXMVECTOR pt2) noexcept
-{
-XMVECTOR Min = XMVectorMin(pt1, pt2);
-XMVECTOR Max = XMVectorMax(pt1, pt2);
-
-// Store center and extents.
-XMStoreFloat3(&Out.Center, XMVectorScale(XMVectorAdd(Min, Max), 0.5f));
-XMStoreFloat3(&Out.Extents, XMVectorScale(XMVectorSubtract(Max, Min), 0.5f));
-}
-
-
-//-----------------------------------------------------------------------------
-// Find the minimum axis aligned bounding box containing a set of points.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingBox::CreateFromPoints(BoundingBox& Out, size_t Count, const XMFLOAT3* pPoints, size_t Stride) noexcept
-{
-assert(Count > 0);
-assert(pPoints);
-
-// Find the minimum and maximum x, y, and z
-XMVECTOR vMin, vMax;
-
-vMin = vMax = XMLoadFloat3(pPoints);
-
-for (size_t i = 1; i < Count; ++i)
-{
-XMVECTOR Point = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(reinterpret_cast<const uint8_t*>(pPoints) + i * Stride));
-
-vMin = XMVectorMin(vMin, Point);
-vMax = XMVectorMax(vMax, Point);
-}
-
-// Store center and extents.
-XMStoreFloat3(&Out.Center, XMVectorScale(XMVectorAdd(vMin, vMax), 0.5f));
-XMStoreFloat3(&Out.Extents, XMVectorScale(XMVectorSubtract(vMax, vMin), 0.5f));
-}
-
-
-/****************************************************************************
- *
- * BoundingOrientedBox
- *
- ****************************************************************************/
-
-//-----------------------------------------------------------------------------
-// Transform an oriented box by an angle preserving transform.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingOrientedBox::Transform(BoundingOrientedBox& Out, FXMMATRIX M) const noexcept
-{
-// Load the box.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-// Composite the box rotation and the transform rotation.
-XMMATRIX nM;
-nM.r[0] = XMVector3Normalize(M.r[0]);
-nM.r[1] = XMVector3Normalize(M.r[1]);
-nM.r[2] = XMVector3Normalize(M.r[2]);
-nM.r[3] = g_XMIdentityR3;
-XMVECTOR Rotation = XMQuaternionRotationMatrix(nM);
-vOrientation = XMQuaternionMultiply(vOrientation, Rotation);
-
-// Transform the center.
-vCenter = XMVector3Transform(vCenter, M);
-
-// Scale the box extents.
-XMVECTOR dX = XMVector3Length(M.r[0]);
-XMVECTOR dY = XMVector3Length(M.r[1]);
-XMVECTOR dZ = XMVector3Length(M.r[2]);
-
-XMVECTOR VectorScale = XMVectorSelect(dY, dX, g_XMSelect1000);
-VectorScale = XMVectorSelect(dZ, VectorScale, g_XMSelect1100);
-vExtents = XMVectorMultiply(vExtents, VectorScale);
-
-// Store the box.
-XMStoreFloat3(&Out.Center, vCenter);
-XMStoreFloat3(&Out.Extents, vExtents);
-XMStoreFloat4(&Out.Orientation, vOrientation);
-}
-
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingOrientedBox::Transform(BoundingOrientedBox& Out, float Scale, FXMVECTOR Rotation, FXMVECTOR Translation) const noexcept
-{
-assert(DirectX::Internal::XMQuaternionIsUnit(Rotation));
-
-// Load the box.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-// Composite the box rotation and the transform rotation.
-vOrientation = XMQuaternionMultiply(vOrientation, Rotation);
-
-// Transform the center.
-XMVECTOR VectorScale = XMVectorReplicate(Scale);
-vCenter = XMVectorAdd(XMVector3Rotate(XMVectorMultiply(vCenter, VectorScale), Rotation), Translation);
-
-// Scale the box extents.
-vExtents = XMVectorMultiply(vExtents, VectorScale);
-
-// Store the box.
-XMStoreFloat3(&Out.Center, vCenter);
-XMStoreFloat3(&Out.Extents, vExtents);
-XMStoreFloat4(&Out.Orientation, vOrientation);
-}
-
-
-//-----------------------------------------------------------------------------
-// Get the corner points of the box
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingOrientedBox::GetCorners(XMFLOAT3* Corners) const noexcept
-{
-    assert(Corners != nullptr);
-
-    // Load the box
-    XMVECTOR vCenter = XMLoadFloat3(&Center);
-    XMVECTOR vExtents = XMLoadFloat3(&Extents);
-    XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-    for (size_t i = 0; i < CORNER_COUNT; ++i)
-    {
-        XMVECTOR C = XMVectorAdd(XMVector3Rotate(XMVectorMultiply(vExtents, g_BoxOffset[i]), vOrientation), vCenter);
-        XMStoreFloat3(&Corners[i], C);
-    }
-}
-
-
-//-----------------------------------------------------------------------------
-// Point in oriented box test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingOrientedBox::Contains(FXMVECTOR Point) const noexcept
-{
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-// Transform the point to be local to the box.
-XMVECTOR TPoint = XMVector3InverseRotate(XMVectorSubtract(Point, vCenter), vOrientation);
-
-return XMVector3InBounds(TPoint, vExtents) ? CONTAINS : DISJOINT;
-}
-
-
-//-----------------------------------------------------------------------------
-// Triangle in oriented bounding box
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingOrientedBox::Contains(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2) const noexcept
-{
-// Load the box center & orientation.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-// Transform the triangle vertices into the space of the box.
-XMVECTOR TV0 = XMVector3InverseRotate(XMVectorSubtract(V0, vCenter), vOrientation);
-XMVECTOR TV1 = XMVector3InverseRotate(XMVectorSubtract(V1, vCenter), vOrientation);
-XMVECTOR TV2 = XMVector3InverseRotate(XMVectorSubtract(V2, vCenter), vOrientation);
-
-BoundingBox box;
-box.Center = XMFLOAT3(0.0f, 0.0f, 0.0f);
-box.Extents = Extents;
-
-// Use the triangle vs axis aligned box intersection routine.
-return box.Contains(TV0, TV1, TV2);
-}
-
-
-//-----------------------------------------------------------------------------
-// Sphere in oriented bounding box
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingOrientedBox::Contains(const BoundingSphere& sh) const noexcept
-{
-    XMVECTOR SphereCenter = XMLoadFloat3(&sh.Center);
-    XMVECTOR SphereRadius = XMVectorReplicatePtr(&sh.Radius);
-
-    XMVECTOR BoxCenter = XMLoadFloat3(&Center);
-    XMVECTOR BoxExtents = XMLoadFloat3(&Extents);
-    XMVECTOR BoxOrientation = XMLoadFloat4(&Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(BoxOrientation));
-
-    // Transform the center of the sphere to be local to the box.
-    // BoxMin = -BoxExtents
-    // BoxMax = +BoxExtents
-    SphereCenter = XMVector3InverseRotate(XMVectorSubtract(SphereCenter, BoxCenter), BoxOrientation);
-
-    // Find the distance to the nearest point on the box.
-    // for each i in (x, y, z)
-    // if (SphereCenter(i) < BoxMin(i)) d2 += (SphereCenter(i) - BoxMin(i)) ^ 2
-    // else if (SphereCenter(i) > BoxMax(i)) d2 += (SphereCenter(i) - BoxMax(i)) ^ 2
-
-    XMVECTOR d = XMVectorZero();
-
-    // Compute d for each dimension.
-    XMVECTOR LessThanMin = XMVectorLess(SphereCenter, XMVectorNegate(BoxExtents));
-    XMVECTOR GreaterThanMax = XMVectorGreater(SphereCenter, BoxExtents);
-
-    XMVECTOR MinDelta = XMVectorAdd(SphereCenter, BoxExtents);
-    XMVECTOR MaxDelta = XMVectorSubtract(SphereCenter, BoxExtents);
-
-    // Choose value for each dimension based on the comparison.
-    d = XMVectorSelect(d, MinDelta, LessThanMin);
-    d = XMVectorSelect(d, MaxDelta, GreaterThanMax);
-
-    // Use a dot-product to square them and sum them together.
-    XMVECTOR d2 = XMVector3Dot(d, d);
-    XMVECTOR SphereRadiusSq = XMVectorMultiply(SphereRadius, SphereRadius);
-
-    if (XMVector4Greater(d2, SphereRadiusSq))
-        return DISJOINT;
-
-    // See if we are completely inside the box
-    XMVECTOR SMin = XMVectorSubtract(SphereCenter, SphereRadius);
-    XMVECTOR SMax = XMVectorAdd(SphereCenter, SphereRadius);
-
-    return (XMVector3InBounds(SMin, BoxExtents) && XMVector3InBounds(SMax, BoxExtents)) ? CONTAINS : INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Axis aligned box vs. oriented box. Constructs an oriented box and uses
-// the oriented box vs. oriented box test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingOrientedBox::Contains(const BoundingBox& box) const noexcept
-{
-    // Make the axis aligned box oriented and do an OBB vs OBB test.
-    BoundingOrientedBox obox(box.Center, box.Extents, XMFLOAT4(0.f, 0.f, 0.f, 1.f));
-    return Contains(obox);
-}
-
-
-//-----------------------------------------------------------------------------
-// Oriented bounding box in oriented bounding box
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingOrientedBox::Contains(const BoundingOrientedBox& box) const noexcept
-{
-    if (!Intersects(box))
-        return DISJOINT;
-
-    // Load the boxes
-    XMVECTOR aCenter = XMLoadFloat3(&Center);
-    XMVECTOR aExtents = XMLoadFloat3(&Extents);
-    XMVECTOR aOrientation = XMLoadFloat4(&Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(aOrientation));
-
-    XMVECTOR bCenter = XMLoadFloat3(&box.Center);
-    XMVECTOR bExtents = XMLoadFloat3(&box.Extents);
-    XMVECTOR bOrientation = XMLoadFloat4(&box.Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(bOrientation));
-
-    XMVECTOR offset = XMVectorSubtract(bCenter, aCenter);
-
-    for (size_t i = 0; i < CORNER_COUNT; ++i)
-    {
-        // Cb = rotate( bExtents * corneroffset[i], bOrientation ) + bcenter
-        // Ca = invrotate( Cb - aCenter, aOrientation )
-
-        XMVECTOR C = XMVectorAdd(XMVector3Rotate(XMVectorMultiply(bExtents, g_BoxOffset[i]), bOrientation), offset);
-        C = XMVector3InverseRotate(C, aOrientation);
-
-        if (!XMVector3InBounds(C, aExtents))
-            return INTERSECTS;
-    }
-
-    return CONTAINS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Frustum in oriented bounding box
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingOrientedBox::Contains(const BoundingFrustum& fr) const noexcept
-{
-    if (!fr.Intersects(*this))
-        return DISJOINT;
-
-    XMFLOAT3 Corners[BoundingFrustum::CORNER_COUNT];
-    fr.GetCorners(Corners);
-
-    // Load the box
-    XMVECTOR vCenter = XMLoadFloat3(&Center);
-    XMVECTOR vExtents = XMLoadFloat3(&Extents);
-    XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-    for (size_t i = 0; i < BoundingFrustum::CORNER_COUNT; ++i)
-    {
-        XMVECTOR C = XMVector3InverseRotate(XMVectorSubtract(XMLoadFloat3(&Corners[i]), vCenter), vOrientation);
-
-        if (!XMVector3InBounds(C, vExtents))
-            return INTERSECTS;
-    }
-
-    return CONTAINS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Sphere vs. oriented box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingOrientedBox::Intersects(const BoundingSphere& sh) const noexcept
-{
-    XMVECTOR SphereCenter = XMLoadFloat3(&sh.Center);
-    XMVECTOR SphereRadius = XMVectorReplicatePtr(&sh.Radius);
-
-    XMVECTOR BoxCenter = XMLoadFloat3(&Center);
-    XMVECTOR BoxExtents = XMLoadFloat3(&Extents);
-    XMVECTOR BoxOrientation = XMLoadFloat4(&Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(BoxOrientation));
-
-    // Transform the center of the sphere to be local to the box.
-    // BoxMin = -BoxExtents
-    // BoxMax = +BoxExtents
-    SphereCenter = XMVector3InverseRotate(XMVectorSubtract(SphereCenter, BoxCenter), BoxOrientation);
-
-    // Find the distance to the nearest point on the box.
-    // for each i in (x, y, z)
-    // if (SphereCenter(i) < BoxMin(i)) d2 += (SphereCenter(i) - BoxMin(i)) ^ 2
-    // else if (SphereCenter(i) > BoxMax(i)) d2 += (SphereCenter(i) - BoxMax(i)) ^ 2
-
-    XMVECTOR d = XMVectorZero();
-
-    // Compute d for each dimension.
-    XMVECTOR LessThanMin = XMVectorLess(SphereCenter, XMVectorNegate(BoxExtents));
-    XMVECTOR GreaterThanMax = XMVectorGreater(SphereCenter, BoxExtents);
-
-    XMVECTOR MinDelta = XMVectorAdd(SphereCenter, BoxExtents);
-    XMVECTOR MaxDelta = XMVectorSubtract(SphereCenter, BoxExtents);
-
-    // Choose value for each dimension based on the comparison.
-    d = XMVectorSelect(d, MinDelta, LessThanMin);
-    d = XMVectorSelect(d, MaxDelta, GreaterThanMax);
-
-    // Use a dot-product to square them and sum them together.
-    XMVECTOR d2 = XMVector3Dot(d, d);
-
-    return XMVector4LessOrEqual(d2, XMVectorMultiply(SphereRadius, SphereRadius)) ? true : false;
-}
-
-
-//-----------------------------------------------------------------------------
-// Axis aligned box vs. oriented box. Constructs an oriented box and uses
-// the oriented box vs. oriented box test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingOrientedBox::Intersects(const BoundingBox& box) const noexcept
-{
-    // Make the axis aligned box oriented and do an OBB vs OBB test.
-    BoundingOrientedBox obox(box.Center, box.Extents, XMFLOAT4(0.f, 0.f, 0.f, 1.f));
-    return Intersects(obox);
-}
-
-
-//-----------------------------------------------------------------------------
-// Fast oriented box / oriented box intersection test using the separating axis
-// theorem.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingOrientedBox::Intersects(const BoundingOrientedBox& box) const noexcept
-{
-    // Build the 3x3 rotation matrix that defines the orientation of B relative to A.
-    XMVECTOR A_quat = XMLoadFloat4(&Orientation);
-    XMVECTOR B_quat = XMLoadFloat4(&box.Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(A_quat));
-    assert(DirectX::Internal::XMQuaternionIsUnit(B_quat));
-
-    XMVECTOR Q = XMQuaternionMultiply(A_quat, XMQuaternionConjugate(B_quat));
-    XMMATRIX R = XMMatrixRotationQuaternion(Q);
-
-    // Compute the translation of B relative to A.
-    XMVECTOR A_cent = XMLoadFloat3(&Center);
-    XMVECTOR B_cent = XMLoadFloat3(&box.Center);
-    XMVECTOR t = XMVector3InverseRotate(XMVectorSubtract(B_cent, A_cent), A_quat);
-
-    //
-    // h(A) = extents of A.
-    // h(B) = extents of B.
-    //
-    // a(u) = axes of A = (1,0,0), (0,1,0), (0,0,1)
-    // b(u) = axes of B relative to A = (r00,r10,r20), (r01,r11,r21), (r02,r12,r22)
-    //
-    // For each possible separating axis l:
-    //   d(A) = sum (for i = u,v,w) h(A)(i) * abs( a(i) dot l )
-    //   d(B) = sum (for i = u,v,w) h(B)(i) * abs( b(i) dot l )
-    //   if abs( t dot l ) > d(A) + d(B) then disjoint
-    //
-
-    // Load extents of A and B.
-    XMVECTOR h_A = XMLoadFloat3(&Extents);
-    XMVECTOR h_B = XMLoadFloat3(&box.Extents);
-
-    // Rows. Note R[0,1,2]X.w = 0.
-    XMVECTOR R0X = R.r[0];
-    XMVECTOR R1X = R.r[1];
-    XMVECTOR R2X = R.r[2];
-
-    R = XMMatrixTranspose(R);
-
-    // Columns. Note RX[0,1,2].w = 0.
-    XMVECTOR RX0 = R.r[0];
-    XMVECTOR RX1 = R.r[1];
-    XMVECTOR RX2 = R.r[2];
-
-    // Absolute value of rows.
-    XMVECTOR AR0X = XMVectorAbs(R0X);
-    XMVECTOR AR1X = XMVectorAbs(R1X);
-    XMVECTOR AR2X = XMVectorAbs(R2X);
-
-    // Absolute value of columns.
-    XMVECTOR ARX0 = XMVectorAbs(RX0);
-    XMVECTOR ARX1 = XMVectorAbs(RX1);
-    XMVECTOR ARX2 = XMVectorAbs(RX2);
-
-    // Test each of the 15 possible seperating axii.
-    XMVECTOR d, d_A, d_B;
-
-    // l = a(u) = (1, 0, 0)
-    // t dot l = t.x
-    // d(A) = h(A).x
-    // d(B) = h(B) dot abs(r00, r01, r02)
-    d = XMVectorSplatX(t);
-    d_A = XMVectorSplatX(h_A);
-    d_B = XMVector3Dot(h_B, AR0X);
-    XMVECTOR NoIntersection = XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B));
-
-    // l = a(v) = (0, 1, 0)
-    // t dot l = t.y
-    // d(A) = h(A).y
-    // d(B) = h(B) dot abs(r10, r11, r12)
-    d = XMVectorSplatY(t);
-    d_A = XMVectorSplatY(h_A);
-    d_B = XMVector3Dot(h_B, AR1X);
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(w) = (0, 0, 1)
-    // t dot l = t.z
-    // d(A) = h(A).z
-    // d(B) = h(B) dot abs(r20, r21, r22)
-    d = XMVectorSplatZ(t);
-    d_A = XMVectorSplatZ(h_A);
-    d_B = XMVector3Dot(h_B, AR2X);
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = b(u) = (r00, r10, r20)
-    // d(A) = h(A) dot abs(r00, r10, r20)
-    // d(B) = h(B).x
-    d = XMVector3Dot(t, RX0);
-    d_A = XMVector3Dot(h_A, ARX0);
-    d_B = XMVectorSplatX(h_B);
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = b(v) = (r01, r11, r21)
-    // d(A) = h(A) dot abs(r01, r11, r21)
-    // d(B) = h(B).y
-    d = XMVector3Dot(t, RX1);
-    d_A = XMVector3Dot(h_A, ARX1);
-    d_B = XMVectorSplatY(h_B);
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = b(w) = (r02, r12, r22)
-    // d(A) = h(A) dot abs(r02, r12, r22)
-    // d(B) = h(B).z
-    d = XMVector3Dot(t, RX2);
-    d_A = XMVector3Dot(h_A, ARX2);
-    d_B = XMVectorSplatZ(h_B);
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(u) x b(u) = (0, -r20, r10)
-    // d(A) = h(A) dot abs(0, r20, r10)
-    // d(B) = h(B) dot abs(0, r02, r01)
-    d = XMVector3Dot(t, XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_0X>(RX0, XMVectorNegate(RX0)));
-    d_A = XMVector3Dot(h_A, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>(ARX0));
-    d_B = XMVector3Dot(h_B, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>(AR0X));
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(u) x b(v) = (0, -r21, r11)
-    // d(A) = h(A) dot abs(0, r21, r11)
-    // d(B) = h(B) dot abs(r02, 0, r00)
-    d = XMVector3Dot(t, XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_0X>(RX1, XMVectorNegate(RX1)));
-    d_A = XMVector3Dot(h_A, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>(ARX1));
-    d_B = XMVector3Dot(h_B, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>(AR0X));
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(u) x b(w) = (0, -r22, r12)
-    // d(A) = h(A) dot abs(0, r22, r12)
-    // d(B) = h(B) dot abs(r01, r00, 0)
-    d = XMVector3Dot(t, XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_0X>(RX2, XMVectorNegate(RX2)));
-    d_A = XMVector3Dot(h_A, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>(ARX2));
-    d_B = XMVector3Dot(h_B, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>(AR0X));
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(v) x b(u) = (r20, 0, -r00)
-    // d(A) = h(A) dot abs(r20, 0, r00)
-    // d(B) = h(B) dot abs(0, r12, r11)
-    d = XMVector3Dot(t, XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0Y>(RX0, XMVectorNegate(RX0)));
-    d_A = XMVector3Dot(h_A, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>(ARX0));
-    d_B = XMVector3Dot(h_B, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>(AR1X));
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(v) x b(v) = (r21, 0, -r01)
-    // d(A) = h(A) dot abs(r21, 0, r01)
-    // d(B) = h(B) dot abs(r12, 0, r10)
-    d = XMVector3Dot(t, XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0Y>(RX1, XMVectorNegate(RX1)));
-    d_A = XMVector3Dot(h_A, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>(ARX1));
-    d_B = XMVector3Dot(h_B, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>(AR1X));
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(v) x b(w) = (r22, 0, -r02)
-    // d(A) = h(A) dot abs(r22, 0, r02)
-    // d(B) = h(B) dot abs(r11, r10, 0)
-    d = XMVector3Dot(t, XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0Y>(RX2, XMVectorNegate(RX2)));
-    d_A = XMVector3Dot(h_A, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>(ARX2));
-    d_B = XMVector3Dot(h_B, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>(AR1X));
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(w) x b(u) = (-r10, r00, 0)
-    // d(A) = h(A) dot abs(r10, r00, 0)
-    // d(B) = h(B) dot abs(0, r22, r21)
-    d = XMVector3Dot(t, XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0Z>(RX0, XMVectorNegate(RX0)));
-    d_A = XMVector3Dot(h_A, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>(ARX0));
-    d_B = XMVector3Dot(h_B, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>(AR2X));
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(w) x b(v) = (-r11, r01, 0)
-    // d(A) = h(A) dot abs(r11, r01, 0)
-    // d(B) = h(B) dot abs(r22, 0, r20)
-    d = XMVector3Dot(t, XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0Z>(RX1, XMVectorNegate(RX1)));
-    d_A = XMVector3Dot(h_A, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>(ARX1));
-    d_B = XMVector3Dot(h_B, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>(AR2X));
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // l = a(w) x b(w) = (-r12, r02, 0)
-    // d(A) = h(A) dot abs(r12, r02, 0)
-    // d(B) = h(B) dot abs(r21, r20, 0)
-    d = XMVector3Dot(t, XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0Z>(RX2, XMVectorNegate(RX2)));
-    d_A = XMVector3Dot(h_A, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>(ARX2));
-    d_B = XMVector3Dot(h_B, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>(AR2X));
-    NoIntersection = XMVectorOrInt(NoIntersection,
-                                   XMVectorGreater(XMVectorAbs(d), XMVectorAdd(d_A, d_B)));
-
-    // No seperating axis found, boxes must intersect.
-    return XMVector4NotEqualInt(NoIntersection, XMVectorTrueInt()) ? true : false;
-}
-
-
-//-----------------------------------------------------------------------------
-// Frustum vs. oriented box test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingOrientedBox::Intersects(const BoundingFrustum& fr) const noexcept
-{
-    return fr.Intersects(*this);
-}
-
-
-//-----------------------------------------------------------------------------
-// Triangle vs. oriented box test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool XM_CALLCONV BoundingOrientedBox::Intersects(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2) const noexcept
-{
-// Load the box center & orientation.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-// Transform the triangle vertices into the space of the box.
-XMVECTOR TV0 = XMVector3InverseRotate(XMVectorSubtract(V0, vCenter), vOrientation);
-XMVECTOR TV1 = XMVector3InverseRotate(XMVectorSubtract(V1, vCenter), vOrientation);
-XMVECTOR TV2 = XMVector3InverseRotate(XMVectorSubtract(V2, vCenter), vOrientation);
-
-BoundingBox box;
-box.Center = XMFLOAT3(0.0f, 0.0f, 0.0f);
-box.Extents = Extents;
-
-// Use the triangle vs axis aligned box intersection routine.
-return box.Intersects(TV0, TV1, TV2);
-}
-
-
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline PlaneIntersectionType XM_CALLCONV BoundingOrientedBox::Intersects(FXMVECTOR Plane) const noexcept
-{
-assert(DirectX::Internal::XMPlaneIsUnit(Plane));
-
-// Load the box.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-XMVECTOR BoxOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(BoxOrientation));
-
-// Set w of the center to one so we can dot4 with a plane.
-vCenter = XMVectorInsert<0, 0, 0, 0, 1>(vCenter, XMVectorSplatOne());
-
-// Build the 3x3 rotation matrix that defines the box axes.
-XMMATRIX R = XMMatrixRotationQuaternion(BoxOrientation);
-
-XMVECTOR Outside, Inside;
-DirectX::Internal::FastIntersectOrientedBoxPlane(vCenter, vExtents, R.r[0], R.r[1], R.r[2], Plane, Outside, Inside);
-
-// If the box is outside any plane it is outside.
-if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-return FRONT;
-
-// If the box is inside all planes it is inside.
-if (XMVector4EqualInt(Inside, XMVectorTrueInt()))
-return BACK;
-
-// The box is not inside all planes or outside a plane it intersects.
-return INTERSECTING;
-}
-
-
-//-----------------------------------------------------------------------------
-// Compute the intersection of a ray (Origin, Direction) with an oriented box
-// using the slabs method.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool XM_CALLCONV BoundingOrientedBox::Intersects(FXMVECTOR Origin, FXMVECTOR Direction, float& Dist) const noexcept
-{
-assert(DirectX::Internal::XMVector3IsUnit(Direction));
-
-static const XMVECTORU32 SelectY = { { { XM_SELECT_0, XM_SELECT_1, XM_SELECT_0, XM_SELECT_0 } } };
-static const XMVECTORU32 SelectZ = { { { XM_SELECT_0, XM_SELECT_0, XM_SELECT_1, XM_SELECT_0 } } };
-
-// Load the box.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-// Get the boxes normalized side directions.
-XMMATRIX R = XMMatrixRotationQuaternion(vOrientation);
-
-// Adjust ray origin to be relative to center of the box.
-XMVECTOR TOrigin = XMVectorSubtract(vCenter, Origin);
-
-// Compute the dot product againt each axis of the box.
-XMVECTOR AxisDotOrigin = XMVector3Dot(R.r[0], TOrigin);
-AxisDotOrigin = XMVectorSelect(AxisDotOrigin, XMVector3Dot(R.r[1], TOrigin), SelectY);
-AxisDotOrigin = XMVectorSelect(AxisDotOrigin, XMVector3Dot(R.r[2], TOrigin), SelectZ);
-
-XMVECTOR AxisDotDirection = XMVector3Dot(R.r[0], Direction);
-AxisDotDirection = XMVectorSelect(AxisDotDirection, XMVector3Dot(R.r[1], Direction), SelectY);
-AxisDotDirection = XMVectorSelect(AxisDotDirection, XMVector3Dot(R.r[2], Direction), SelectZ);
-
-// if (fabs(AxisDotDirection) <= Epsilon) the ray is nearly parallel to the slab.
-XMVECTOR IsParallel = XMVectorLessOrEqual(XMVectorAbs(AxisDotDirection), g_RayEpsilon);
-
-// Test against all three axes simultaneously.
-XMVECTOR InverseAxisDotDirection = XMVectorReciprocal(AxisDotDirection);
-XMVECTOR t1 = XMVectorMultiply(XMVectorSubtract(AxisDotOrigin, vExtents), InverseAxisDotDirection);
-XMVECTOR t2 = XMVectorMultiply(XMVectorAdd(AxisDotOrigin, vExtents), InverseAxisDotDirection);
-
-// Compute the max of min(t1,t2) and the min of max(t1,t2) ensuring we don't
-// use the results from any directions parallel to the slab.
-XMVECTOR t_min = XMVectorSelect(XMVectorMin(t1, t2), g_FltMin, IsParallel);
-XMVECTOR t_max = XMVectorSelect(XMVectorMax(t1, t2), g_FltMax, IsParallel);
-
-// t_min.x = maximum( t_min.x, t_min.y, t_min.z );
-// t_max.x = minimum( t_max.x, t_max.y, t_max.z );
-t_min = XMVectorMax(t_min, XMVectorSplatY(t_min));  // x = max(x,y)
-t_min = XMVectorMax(t_min, XMVectorSplatZ(t_min));  // x = max(max(x,y),z)
-t_max = XMVectorMin(t_max, XMVectorSplatY(t_max));  // x = min(x,y)
-t_max = XMVectorMin(t_max, XMVectorSplatZ(t_max));  // x = min(min(x,y),z)
-
-// if ( t_min > t_max ) return false;
-XMVECTOR NoIntersection = XMVectorGreater(XMVectorSplatX(t_min), XMVectorSplatX(t_max));
-
-// if ( t_max < 0.0f ) return false;
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(XMVectorSplatX(t_max), XMVectorZero()));
-
-// if (IsParallel && (-Extents > AxisDotOrigin || Extents < AxisDotOrigin)) return false;
-XMVECTOR ParallelOverlap = XMVectorInBounds(AxisDotOrigin, vExtents);
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorAndCInt(IsParallel, ParallelOverlap));
-
-if (!DirectX::Internal::XMVector3AnyTrue(NoIntersection))
-{
-// Store the x-component to *pDist
-XMStoreFloat(&Dist, t_min);
-return true;
-}
-
-Dist = 0.f;
-return false;
-}
-
-
-//-----------------------------------------------------------------------------
-// Test an oriented box vs 6 planes (typically forming a frustum).
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingOrientedBox::ContainedBy(
-        FXMVECTOR Plane0, FXMVECTOR Plane1, FXMVECTOR Plane2,
-GXMVECTOR Plane3,
-        HXMVECTOR Plane4, HXMVECTOR Plane5) const noexcept
-{
-// Load the box.
-XMVECTOR vCenter = XMLoadFloat3(&Center);
-XMVECTOR vExtents = XMLoadFloat3(&Extents);
-XMVECTOR BoxOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(BoxOrientation));
-
-// Set w of the center to one so we can dot4 with a plane.
-vCenter = XMVectorInsert<0, 0, 0, 0, 1>(vCenter, XMVectorSplatOne());
-
-// Build the 3x3 rotation matrix that defines the box axes.
-XMMATRIX R = XMMatrixRotationQuaternion(BoxOrientation);
-
-XMVECTOR Outside, Inside;
-
-// Test against each plane.
-DirectX::Internal::FastIntersectOrientedBoxPlane(vCenter, vExtents, R.r[0], R.r[1], R.r[2], Plane0, Outside, Inside);
-
-XMVECTOR AnyOutside = Outside;
-XMVECTOR AllInside = Inside;
-
-DirectX::Internal::FastIntersectOrientedBoxPlane(vCenter, vExtents, R.r[0], R.r[1], R.r[2], Plane1, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectOrientedBoxPlane(vCenter, vExtents, R.r[0], R.r[1], R.r[2], Plane2, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectOrientedBoxPlane(vCenter, vExtents, R.r[0], R.r[1], R.r[2], Plane3, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectOrientedBoxPlane(vCenter, vExtents, R.r[0], R.r[1], R.r[2], Plane4, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectOrientedBoxPlane(vCenter, vExtents, R.r[0], R.r[1], R.r[2], Plane5, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-// If the box is outside any plane it is outside.
-if (XMVector4EqualInt(AnyOutside, XMVectorTrueInt()))
-return DISJOINT;
-
-// If the box is inside all planes it is inside.
-if (XMVector4EqualInt(AllInside, XMVectorTrueInt()))
-return CONTAINS;
-
-// The box is not inside all planes or outside a plane, it may intersect.
-return INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Create oriented bounding box from axis-aligned bounding box
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingOrientedBox::CreateFromBoundingBox(BoundingOrientedBox& Out, const BoundingBox& box) noexcept
-{
-Out.Center = box.Center;
-Out.Extents = box.Extents;
-Out.Orientation = XMFLOAT4(0.f, 0.f, 0.f, 1.f);
-}
-
-
-//-----------------------------------------------------------------------------
-// Find the approximate minimum oriented bounding box containing a set of
-// points.  Exact computation of minimum oriented bounding box is possible but
-// is slower and requires a more complex algorithm.
-// The algorithm works by computing the inertia tensor of the points and then
-// using the eigenvectors of the intertia tensor as the axes of the box.
-// Computing the intertia tensor of the convex hull of the points will usually
-// result in better bounding box but the computation is more complex.
-// Exact computation of the minimum oriented bounding box is possible but the
-// best know algorithm is O(N^3) and is significanly more complex to implement.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingOrientedBox::CreateFromPoints(BoundingOrientedBox& Out, size_t Count, const XMFLOAT3* pPoints, size_t Stride) noexcept
-{
-assert(Count > 0);
-assert(pPoints != nullptr);
-
-XMVECTOR CenterOfMass = XMVectorZero();
-
-// Compute the center of mass and inertia tensor of the points.
-for (size_t i = 0; i < Count; ++i)
-{
-XMVECTOR Point = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(reinterpret_cast<const uint8_t*>(pPoints) + i * Stride));
-
-CenterOfMass = XMVectorAdd(CenterOfMass, Point);
-}
-
-CenterOfMass = XMVectorMultiply(CenterOfMass, XMVectorReciprocal(XMVectorReplicate(float(Count))));
-
-// Compute the inertia tensor of the points around the center of mass.
-// Using the center of mass is not strictly necessary, but will hopefully
-// improve the stability of finding the eigenvectors.
-XMVECTOR XX_YY_ZZ = XMVectorZero();
-XMVECTOR XY_XZ_YZ = XMVectorZero();
-
-for (size_t i = 0; i < Count; ++i)
-{
-XMVECTOR Point = XMVectorSubtract(XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(reinterpret_cast<const uint8_t*>(pPoints) + i * Stride)), CenterOfMass);
-
-XX_YY_ZZ = XMVectorAdd(XX_YY_ZZ, XMVectorMultiply(Point, Point));
-
-XMVECTOR XXY = XMVectorSwizzle<XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_W>(Point);
-XMVECTOR YZZ = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_Z, XM_SWIZZLE_W>(Point);
-
-XY_XZ_YZ = XMVectorAdd(XY_XZ_YZ, XMVectorMultiply(XXY, YZZ));
-}
-
-XMVECTOR v1, v2, v3;
-
-// Compute the eigenvectors of the inertia tensor.
-DirectX::Internal::CalculateEigenVectorsFromCovarianceMatrix(XMVectorGetX(XX_YY_ZZ), XMVectorGetY(XX_YY_ZZ),
-        XMVectorGetZ(XX_YY_ZZ),
-        XMVectorGetX(XY_XZ_YZ), XMVectorGetY(XY_XZ_YZ),
-        XMVectorGetZ(XY_XZ_YZ),
-        &v1, &v2, &v3);
-
-// Put them in a matrix.
-XMMATRIX R;
-
-R.r[0] = XMVectorSetW(v1, 0.f);
-R.r[1] = XMVectorSetW(v2, 0.f);
-R.r[2] = XMVectorSetW(v3, 0.f);
-R.r[3] = g_XMIdentityR3.v;
-
-// Multiply by -1 to convert the matrix into a right handed coordinate
-// system (Det ~= 1) in case the eigenvectors form a left handed
-// coordinate system (Det ~= -1) because XMQuaternionRotationMatrix only
-// works on right handed matrices.
-XMVECTOR Det = XMMatrixDeterminant(R);
-
-if (XMVector4Less(Det, XMVectorZero()))
-{
-R.r[0] = XMVectorMultiply(R.r[0], g_XMNegativeOne.v);
-R.r[1] = XMVectorMultiply(R.r[1], g_XMNegativeOne.v);
-R.r[2] = XMVectorMultiply(R.r[2], g_XMNegativeOne.v);
-}
-
-// Get the rotation quaternion from the matrix.
-XMVECTOR vOrientation = XMQuaternionRotationMatrix(R);
-
-// Make sure it is normal (in case the vectors are slightly non-orthogonal).
-vOrientation = XMQuaternionNormalize(vOrientation);
-
-// Rebuild the rotation matrix from the quaternion.
-R = XMMatrixRotationQuaternion(vOrientation);
-
-// Build the rotation into the rotated space.
-XMMATRIX InverseR = XMMatrixTranspose(R);
-
-// Find the minimum OBB using the eigenvectors as the axes.
-XMVECTOR vMin, vMax;
-
-vMin = vMax = XMVector3TransformNormal(XMLoadFloat3(pPoints), InverseR);
-
-for (size_t i = 1; i < Count; ++i)
-{
-XMVECTOR Point = XMVector3TransformNormal(XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(reinterpret_cast<const uint8_t*>(pPoints) + i * Stride)),
-                                          InverseR);
-
-vMin = XMVectorMin(vMin, Point);
-vMax = XMVectorMax(vMax, Point);
-}
-
-// Rotate the center into world space.
-XMVECTOR vCenter = XMVectorScale(XMVectorAdd(vMin, vMax), 0.5f);
-vCenter = XMVector3TransformNormal(vCenter, R);
-
-// Store center, extents, and orientation.
-XMStoreFloat3(&Out.Center, vCenter);
-XMStoreFloat3(&Out.Extents, XMVectorScale(XMVectorSubtract(vMax, vMin), 0.5f));
-XMStoreFloat4(&Out.Orientation, vOrientation);
-}
-
-
-/****************************************************************************
- *
- * BoundingFrustum
- *
- ****************************************************************************/
-
-_Use_decl_annotations_
-inline BoundingFrustum::BoundingFrustum(CXMMATRIX Projection, bool rhcoords) noexcept
-{
-    CreateFromMatrix(*this, Projection, rhcoords);
-}
-
-
-//-----------------------------------------------------------------------------
-// Transform a frustum by an angle preserving transform.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingFrustum::Transform(BoundingFrustum& Out, FXMMATRIX M) const noexcept
-{
-// Load the frustum.
-XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-// Composite the frustum rotation and the transform rotation
-XMMATRIX nM;
-nM.r[0] = XMVector3Normalize(M.r[0]);
-nM.r[1] = XMVector3Normalize(M.r[1]);
-nM.r[2] = XMVector3Normalize(M.r[2]);
-nM.r[3] = g_XMIdentityR3;
-XMVECTOR Rotation = XMQuaternionRotationMatrix(nM);
-vOrientation = XMQuaternionMultiply(vOrientation, Rotation);
-
-// Transform the center.
-vOrigin = XMVector3Transform(vOrigin, M);
-
-// Store the frustum.
-XMStoreFloat3(&Out.Origin, vOrigin);
-XMStoreFloat4(&Out.Orientation, vOrientation);
-
-// Scale the near and far distances (the slopes remain the same).
-XMVECTOR dX = XMVector3Dot(M.r[0], M.r[0]);
-XMVECTOR dY = XMVector3Dot(M.r[1], M.r[1]);
-XMVECTOR dZ = XMVector3Dot(M.r[2], M.r[2]);
-
-XMVECTOR d = XMVectorMax(dX, XMVectorMax(dY, dZ));
-float Scale = sqrtf(XMVectorGetX(d));
-
-Out.Near = Near * Scale;
-Out.Far = Far * Scale;
-
-// Copy the slopes.
-Out.RightSlope = RightSlope;
-Out.LeftSlope = LeftSlope;
-Out.TopSlope = TopSlope;
-Out.BottomSlope = BottomSlope;
-}
-
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingFrustum::Transform(BoundingFrustum& Out, float Scale, FXMVECTOR Rotation, FXMVECTOR Translation) const noexcept
-{
-assert(DirectX::Internal::XMQuaternionIsUnit(Rotation));
-
-// Load the frustum.
-XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-// Composite the frustum rotation and the transform rotation.
-vOrientation = XMQuaternionMultiply(vOrientation, Rotation);
-
-// Transform the origin.
-vOrigin = XMVectorAdd(XMVector3Rotate(XMVectorScale(vOrigin, Scale), Rotation), Translation);
-
-// Store the frustum.
-XMStoreFloat3(&Out.Origin, vOrigin);
-XMStoreFloat4(&Out.Orientation, vOrientation);
-
-// Scale the near and far distances (the slopes remain the same).
-Out.Near = Near * Scale;
-Out.Far = Far * Scale;
-
-// Copy the slopes.
-Out.RightSlope = RightSlope;
-Out.LeftSlope = LeftSlope;
-Out.TopSlope = TopSlope;
-Out.BottomSlope = BottomSlope;
-}
-
-
-//-----------------------------------------------------------------------------
-// Get the corner points of the frustum
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingFrustum::GetCorners(XMFLOAT3* Corners) const noexcept
-{
-    assert(Corners != nullptr);
-
-    // Load origin and orientation of the frustum.
-    XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-    XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-    // Build the corners of the frustum.
-    XMVECTOR vRightTop = XMVectorSet(RightSlope, TopSlope, 1.0f, 0.0f);
-    XMVECTOR vRightBottom = XMVectorSet(RightSlope, BottomSlope, 1.0f, 0.0f);
-    XMVECTOR vLeftTop = XMVectorSet(LeftSlope, TopSlope, 1.0f, 0.0f);
-    XMVECTOR vLeftBottom = XMVectorSet(LeftSlope, BottomSlope, 1.0f, 0.0f);
-    XMVECTOR vNear = XMVectorReplicatePtr(&Near);
-    XMVECTOR vFar = XMVectorReplicatePtr(&Far);
-
-    // Returns 8 corners position of bounding frustum.
-    //     Near    Far
-    //    0----1  4----5
-    //    |    |  |    |
-    //    |    |  |    |
-    //    3----2  7----6
-
-    XMVECTOR vCorners[CORNER_COUNT];
-    vCorners[0] = XMVectorMultiply(vLeftTop, vNear);
-    vCorners[1] = XMVectorMultiply(vRightTop, vNear);
-    vCorners[2] = XMVectorMultiply(vRightBottom, vNear);
-    vCorners[3] = XMVectorMultiply(vLeftBottom, vNear);
-    vCorners[4] = XMVectorMultiply(vLeftTop, vFar);
-    vCorners[5] = XMVectorMultiply(vRightTop, vFar);
-    vCorners[6] = XMVectorMultiply(vRightBottom, vFar);
-    vCorners[7] = XMVectorMultiply(vLeftBottom, vFar);
-
-    for (size_t i = 0; i < CORNER_COUNT; ++i)
-    {
-        XMVECTOR C = XMVectorAdd(XMVector3Rotate(vCorners[i], vOrientation), vOrigin);
-        XMStoreFloat3(&Corners[i], C);
-    }
-}
-
-
-//-----------------------------------------------------------------------------
-// Point in frustum test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingFrustum::Contains(FXMVECTOR Point) const noexcept
-{
-// Build frustum planes.
-XMVECTOR Planes[6];
-Planes[0] = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-Planes[1] = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-Planes[2] = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-Planes[3] = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-Planes[4] = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-Planes[5] = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-
-// Load origin and orientation.
-XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-// Transform point into local space of frustum.
-XMVECTOR TPoint = XMVector3InverseRotate(XMVectorSubtract(Point, vOrigin), vOrientation);
-
-// Set w to one.
-TPoint = XMVectorInsert<0, 0, 0, 0, 1>(TPoint, XMVectorSplatOne());
-
-XMVECTOR Zero = XMVectorZero();
-XMVECTOR Outside = Zero;
-
-// Test point against each plane of the frustum.
-for (size_t i = 0; i < 6; ++i)
-{
-XMVECTOR Dot = XMVector4Dot(TPoint, Planes[i]);
-Outside = XMVectorOrInt(Outside, XMVectorGreater(Dot, Zero));
-}
-
-return XMVector4NotEqualInt(Outside, XMVectorTrueInt()) ? CONTAINS : DISJOINT;
-}
-
-
-//-----------------------------------------------------------------------------
-// Triangle vs frustum test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingFrustum::Contains(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2) const noexcept
-{
-// Load origin and orientation of the frustum.
-XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-// Create 6 planes (do it inline to encourage use of registers)
-XMVECTOR NearPlane = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-NearPlane = DirectX::Internal::XMPlaneTransform(NearPlane, vOrientation, vOrigin);
-NearPlane = XMPlaneNormalize(NearPlane);
-
-XMVECTOR FarPlane = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-FarPlane = DirectX::Internal::XMPlaneTransform(FarPlane, vOrientation, vOrigin);
-FarPlane = XMPlaneNormalize(FarPlane);
-
-XMVECTOR RightPlane = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-RightPlane = DirectX::Internal::XMPlaneTransform(RightPlane, vOrientation, vOrigin);
-RightPlane = XMPlaneNormalize(RightPlane);
-
-XMVECTOR LeftPlane = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-LeftPlane = DirectX::Internal::XMPlaneTransform(LeftPlane, vOrientation, vOrigin);
-LeftPlane = XMPlaneNormalize(LeftPlane);
-
-XMVECTOR TopPlane = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-TopPlane = DirectX::Internal::XMPlaneTransform(TopPlane, vOrientation, vOrigin);
-TopPlane = XMPlaneNormalize(TopPlane);
-
-XMVECTOR BottomPlane = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-BottomPlane = DirectX::Internal::XMPlaneTransform(BottomPlane, vOrientation, vOrigin);
-BottomPlane = XMPlaneNormalize(BottomPlane);
-
-return TriangleTests::ContainedBy(V0, V1, V2, NearPlane, FarPlane, RightPlane, LeftPlane, TopPlane, BottomPlane);
-}
-
-
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingFrustum::Contains(const BoundingSphere& sh) const noexcept
-{
-    // Load origin and orientation of the frustum.
-    XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-    XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-    // Create 6 planes (do it inline to encourage use of registers)
-    XMVECTOR NearPlane = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-    NearPlane = DirectX::Internal::XMPlaneTransform(NearPlane, vOrientation, vOrigin);
-    NearPlane = XMPlaneNormalize(NearPlane);
-
-    XMVECTOR FarPlane = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-    FarPlane = DirectX::Internal::XMPlaneTransform(FarPlane, vOrientation, vOrigin);
-    FarPlane = XMPlaneNormalize(FarPlane);
-
-    XMVECTOR RightPlane = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-    RightPlane = DirectX::Internal::XMPlaneTransform(RightPlane, vOrientation, vOrigin);
-    RightPlane = XMPlaneNormalize(RightPlane);
-
-    XMVECTOR LeftPlane = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-    LeftPlane = DirectX::Internal::XMPlaneTransform(LeftPlane, vOrientation, vOrigin);
-    LeftPlane = XMPlaneNormalize(LeftPlane);
-
-    XMVECTOR TopPlane = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-    TopPlane = DirectX::Internal::XMPlaneTransform(TopPlane, vOrientation, vOrigin);
-    TopPlane = XMPlaneNormalize(TopPlane);
-
-    XMVECTOR BottomPlane = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-    BottomPlane = DirectX::Internal::XMPlaneTransform(BottomPlane, vOrientation, vOrigin);
-    BottomPlane = XMPlaneNormalize(BottomPlane);
-
-    return sh.ContainedBy(NearPlane, FarPlane, RightPlane, LeftPlane, TopPlane, BottomPlane);
-}
-
-
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingFrustum::Contains(const BoundingBox& box) const noexcept
-{
-    // Load origin and orientation of the frustum.
-    XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-    XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-    // Create 6 planes (do it inline to encourage use of registers)
-    XMVECTOR NearPlane = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-    NearPlane = DirectX::Internal::XMPlaneTransform(NearPlane, vOrientation, vOrigin);
-    NearPlane = XMPlaneNormalize(NearPlane);
-
-    XMVECTOR FarPlane = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-    FarPlane = DirectX::Internal::XMPlaneTransform(FarPlane, vOrientation, vOrigin);
-    FarPlane = XMPlaneNormalize(FarPlane);
-
-    XMVECTOR RightPlane = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-    RightPlane = DirectX::Internal::XMPlaneTransform(RightPlane, vOrientation, vOrigin);
-    RightPlane = XMPlaneNormalize(RightPlane);
-
-    XMVECTOR LeftPlane = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-    LeftPlane = DirectX::Internal::XMPlaneTransform(LeftPlane, vOrientation, vOrigin);
-    LeftPlane = XMPlaneNormalize(LeftPlane);
-
-    XMVECTOR TopPlane = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-    TopPlane = DirectX::Internal::XMPlaneTransform(TopPlane, vOrientation, vOrigin);
-    TopPlane = XMPlaneNormalize(TopPlane);
-
-    XMVECTOR BottomPlane = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-    BottomPlane = DirectX::Internal::XMPlaneTransform(BottomPlane, vOrientation, vOrigin);
-    BottomPlane = XMPlaneNormalize(BottomPlane);
-
-    return box.ContainedBy(NearPlane, FarPlane, RightPlane, LeftPlane, TopPlane, BottomPlane);
-}
-
-
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingFrustum::Contains(const BoundingOrientedBox& box) const noexcept
-{
-    // Load origin and orientation of the frustum.
-    XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-    XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-    // Create 6 planes (do it inline to encourage use of registers)
-    XMVECTOR NearPlane = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-    NearPlane = DirectX::Internal::XMPlaneTransform(NearPlane, vOrientation, vOrigin);
-    NearPlane = XMPlaneNormalize(NearPlane);
-
-    XMVECTOR FarPlane = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-    FarPlane = DirectX::Internal::XMPlaneTransform(FarPlane, vOrientation, vOrigin);
-    FarPlane = XMPlaneNormalize(FarPlane);
-
-    XMVECTOR RightPlane = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-    RightPlane = DirectX::Internal::XMPlaneTransform(RightPlane, vOrientation, vOrigin);
-    RightPlane = XMPlaneNormalize(RightPlane);
-
-    XMVECTOR LeftPlane = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-    LeftPlane = DirectX::Internal::XMPlaneTransform(LeftPlane, vOrientation, vOrigin);
-    LeftPlane = XMPlaneNormalize(LeftPlane);
-
-    XMVECTOR TopPlane = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-    TopPlane = DirectX::Internal::XMPlaneTransform(TopPlane, vOrientation, vOrigin);
-    TopPlane = XMPlaneNormalize(TopPlane);
-
-    XMVECTOR BottomPlane = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-    BottomPlane = DirectX::Internal::XMPlaneTransform(BottomPlane, vOrientation, vOrigin);
-    BottomPlane = XMPlaneNormalize(BottomPlane);
-
-    return box.ContainedBy(NearPlane, FarPlane, RightPlane, LeftPlane, TopPlane, BottomPlane);
-}
-
-
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType BoundingFrustum::Contains(const BoundingFrustum& fr) const noexcept
-{
-    // Load origin and orientation of the frustum.
-    XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-    XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-    // Create 6 planes (do it inline to encourage use of registers)
-    XMVECTOR NearPlane = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-    NearPlane = DirectX::Internal::XMPlaneTransform(NearPlane, vOrientation, vOrigin);
-    NearPlane = XMPlaneNormalize(NearPlane);
-
-    XMVECTOR FarPlane = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-    FarPlane = DirectX::Internal::XMPlaneTransform(FarPlane, vOrientation, vOrigin);
-    FarPlane = XMPlaneNormalize(FarPlane);
-
-    XMVECTOR RightPlane = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-    RightPlane = DirectX::Internal::XMPlaneTransform(RightPlane, vOrientation, vOrigin);
-    RightPlane = XMPlaneNormalize(RightPlane);
-
-    XMVECTOR LeftPlane = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-    LeftPlane = DirectX::Internal::XMPlaneTransform(LeftPlane, vOrientation, vOrigin);
-    LeftPlane = XMPlaneNormalize(LeftPlane);
-
-    XMVECTOR TopPlane = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-    TopPlane = DirectX::Internal::XMPlaneTransform(TopPlane, vOrientation, vOrigin);
-    TopPlane = XMPlaneNormalize(TopPlane);
-
-    XMVECTOR BottomPlane = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-    BottomPlane = DirectX::Internal::XMPlaneTransform(BottomPlane, vOrientation, vOrigin);
-    BottomPlane = XMPlaneNormalize(BottomPlane);
-
-    return fr.ContainedBy(NearPlane, FarPlane, RightPlane, LeftPlane, TopPlane, BottomPlane);
-}
-
-
-//-----------------------------------------------------------------------------
-// Exact sphere vs frustum test.  The algorithm first checks the sphere against
-// the planes of the frustum, then if the plane checks were indeterminate finds
-// the nearest feature (plane, line, point) on the frustum to the center of the
-// sphere and compares the distance to the nearest feature to the radius of the
-// sphere
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingFrustum::Intersects(const BoundingSphere& sh) const noexcept
-{
-    XMVECTOR Zero = XMVectorZero();
-
-    // Build the frustum planes.
-    XMVECTOR Planes[6];
-    Planes[0] = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-    Planes[1] = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-    Planes[2] = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-    Planes[3] = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-    Planes[4] = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-    Planes[5] = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-
-    // Normalize the planes so we can compare to the sphere radius.
-    Planes[2] = XMVector3Normalize(Planes[2]);
-    Planes[3] = XMVector3Normalize(Planes[3]);
-    Planes[4] = XMVector3Normalize(Planes[4]);
-    Planes[5] = XMVector3Normalize(Planes[5]);
-
-    // Load origin and orientation of the frustum.
-    XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-    XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-    // Load the sphere.
-    XMVECTOR vCenter = XMLoadFloat3(&sh.Center);
-    XMVECTOR vRadius = XMVectorReplicatePtr(&sh.Radius);
-
-    // Transform the center of the sphere into the local space of frustum.
-    vCenter = XMVector3InverseRotate(XMVectorSubtract(vCenter, vOrigin), vOrientation);
-
-    // Set w of the center to one so we can dot4 with the plane.
-    vCenter = XMVectorInsert<0, 0, 0, 0, 1>(vCenter, XMVectorSplatOne());
-
-    // Check against each plane of the frustum.
-    XMVECTOR Outside = XMVectorFalseInt();
-    XMVECTOR InsideAll = XMVectorTrueInt();
-    XMVECTOR CenterInsideAll = XMVectorTrueInt();
-
-    XMVECTOR Dist[6];
-
-    for (size_t i = 0; i < 6; ++i)
-    {
-        Dist[i] = XMVector4Dot(vCenter, Planes[i]);
-
-        // Outside the plane?
-        Outside = XMVectorOrInt(Outside, XMVectorGreater(Dist[i], vRadius));
-
-        // Fully inside the plane?
-        InsideAll = XMVectorAndInt(InsideAll, XMVectorLessOrEqual(Dist[i], XMVectorNegate(vRadius)));
-
-        // Check if the center is inside the plane.
-        CenterInsideAll = XMVectorAndInt(CenterInsideAll, XMVectorLessOrEqual(Dist[i], Zero));
-    }
-
-    // If the sphere is outside any of the planes it is outside.
-    if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-        return false;
-
-    // If the sphere is inside all planes it is fully inside.
-    if (XMVector4EqualInt(InsideAll, XMVectorTrueInt()))
-        return true;
-
-    // If the center of the sphere is inside all planes and the sphere intersects
-    // one or more planes then it must intersect.
-    if (XMVector4EqualInt(CenterInsideAll, XMVectorTrueInt()))
-        return true;
-
-    // The sphere may be outside the frustum or intersecting the frustum.
-    // Find the nearest feature (face, edge, or corner) on the frustum
-    // to the sphere.
-
-    // The faces adjacent to each face are:
-    static const size_t adjacent_faces[6][4] =
-            {
-                    { 2, 3, 4, 5 },    // 0
-                    { 2, 3, 4, 5 },    // 1
-                    { 0, 1, 4, 5 },    // 2
-                    { 0, 1, 4, 5 },    // 3
-                    { 0, 1, 2, 3 },    // 4
-                    { 0, 1, 2, 3 }
-            };  // 5
-
-    XMVECTOR Intersects = XMVectorFalseInt();
-
-    // Check to see if the nearest feature is one of the planes.
-    for (size_t i = 0; i < 6; ++i)
-    {
-        // Find the nearest point on the plane to the center of the sphere.
-        XMVECTOR Point = XMVectorNegativeMultiplySubtract(Planes[i], Dist[i], vCenter);
-
-        // Set w of the point to one.
-        Point = XMVectorInsert<0, 0, 0, 0, 1>(Point, XMVectorSplatOne());
-
-        // If the point is inside the face (inside the adjacent planes) then
-        // this plane is the nearest feature.
-        XMVECTOR InsideFace = XMVectorTrueInt();
-
-        for (size_t j = 0; j < 4; j++)
-        {
-            size_t plane_index = adjacent_faces[i][j];
-
-            InsideFace = XMVectorAndInt(InsideFace,
-                                        XMVectorLessOrEqual(XMVector4Dot(Point, Planes[plane_index]), Zero));
-        }
-
-        // Since we have already checked distance from the plane we know that the
-        // sphere must intersect if this plane is the nearest feature.
-        Intersects = XMVectorOrInt(Intersects,
-                                   XMVectorAndInt(XMVectorGreater(Dist[i], Zero), InsideFace));
-    }
-
-    if (XMVector4EqualInt(Intersects, XMVectorTrueInt()))
-        return true;
-
-    // Build the corners of the frustum.
-    XMVECTOR vRightTop = XMVectorSet(RightSlope, TopSlope, 1.0f, 0.0f);
-    XMVECTOR vRightBottom = XMVectorSet(RightSlope, BottomSlope, 1.0f, 0.0f);
-    XMVECTOR vLeftTop = XMVectorSet(LeftSlope, TopSlope, 1.0f, 0.0f);
-    XMVECTOR vLeftBottom = XMVectorSet(LeftSlope, BottomSlope, 1.0f, 0.0f);
-    XMVECTOR vNear = XMVectorReplicatePtr(&Near);
-    XMVECTOR vFar = XMVectorReplicatePtr(&Far);
-
-    XMVECTOR Corners[CORNER_COUNT];
-    Corners[0] = XMVectorMultiply(vRightTop, vNear);
-    Corners[1] = XMVectorMultiply(vRightBottom, vNear);
-    Corners[2] = XMVectorMultiply(vLeftTop, vNear);
-    Corners[3] = XMVectorMultiply(vLeftBottom, vNear);
-    Corners[4] = XMVectorMultiply(vRightTop, vFar);
-    Corners[5] = XMVectorMultiply(vRightBottom, vFar);
-    Corners[6] = XMVectorMultiply(vLeftTop, vFar);
-    Corners[7] = XMVectorMultiply(vLeftBottom, vFar);
-
-    // The Edges are:
-    static const size_t edges[12][2] =
-            {
-                    { 0, 1 }, { 2, 3 }, { 0, 2 }, { 1, 3 },    // Near plane
-                    { 4, 5 }, { 6, 7 }, { 4, 6 }, { 5, 7 },    // Far plane
-                    { 0, 4 }, { 1, 5 }, { 2, 6 }, { 3, 7 },
-            }; // Near to far
-
-    XMVECTOR RadiusSq = XMVectorMultiply(vRadius, vRadius);
-
-    // Check to see if the nearest feature is one of the edges (or corners).
-    for (size_t i = 0; i < 12; ++i)
-    {
-        size_t ei0 = edges[i][0];
-        size_t ei1 = edges[i][1];
-
-        // Find the nearest point on the edge to the center of the sphere.
-        // The corners of the frustum are included as the endpoints of the edges.
-        XMVECTOR Point = DirectX::Internal::PointOnLineSegmentNearestPoint(Corners[ei0], Corners[ei1], vCenter);
-
-        XMVECTOR Delta = XMVectorSubtract(vCenter, Point);
-
-        XMVECTOR DistSq = XMVector3Dot(Delta, Delta);
-
-        // If the distance to the center of the sphere to the point is less than
-        // the radius of the sphere then it must intersect.
-        Intersects = XMVectorOrInt(Intersects, XMVectorLessOrEqual(DistSq, RadiusSq));
-    }
-
-    if (XMVector4EqualInt(Intersects, XMVectorTrueInt()))
-        return true;
-
-    // The sphere must be outside the frustum.
-    return false;
-}
-
-
-//-----------------------------------------------------------------------------
-// Exact axis aligned box vs frustum test.  Constructs an oriented box and uses
-// the oriented box vs frustum test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingFrustum::Intersects(const BoundingBox& box) const noexcept
-{
-    // Make the axis aligned box oriented and do an OBB vs frustum test.
-    BoundingOrientedBox obox(box.Center, box.Extents, XMFLOAT4(0.f, 0.f, 0.f, 1.f));
-    return Intersects(obox);
-}
-
-
-//-----------------------------------------------------------------------------
-// Exact oriented box vs frustum test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingFrustum::Intersects(const BoundingOrientedBox& box) const noexcept
-{
-    static const XMVECTORU32 SelectY = { { { XM_SELECT_0, XM_SELECT_1, XM_SELECT_0, XM_SELECT_0 } } };
-    static const XMVECTORU32 SelectZ = { { { XM_SELECT_0, XM_SELECT_0, XM_SELECT_1, XM_SELECT_0 } } };
-
-    XMVECTOR Zero = XMVectorZero();
-
-    // Build the frustum planes.
-    XMVECTOR Planes[6];
-    Planes[0] = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-    Planes[1] = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-    Planes[2] = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-    Planes[3] = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-    Planes[4] = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-    Planes[5] = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-
-    // Load origin and orientation of the frustum.
-    XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-    XMVECTOR FrustumOrientation = XMLoadFloat4(&Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(FrustumOrientation));
-
-    // Load the box.
-    XMVECTOR Center = XMLoadFloat3(&box.Center);
-    XMVECTOR Extents = XMLoadFloat3(&box.Extents);
-    XMVECTOR BoxOrientation = XMLoadFloat4(&box.Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(BoxOrientation));
-
-    // Transform the oriented box into the space of the frustum in order to
-    // minimize the number of transforms we have to do.
-    Center = XMVector3InverseRotate(XMVectorSubtract(Center, vOrigin), FrustumOrientation);
-    BoxOrientation = XMQuaternionMultiply(BoxOrientation, XMQuaternionConjugate(FrustumOrientation));
-
-    // Set w of the center to one so we can dot4 with the plane.
-    Center = XMVectorInsert<0, 0, 0, 0, 1>(Center, XMVectorSplatOne());
-
-    // Build the 3x3 rotation matrix that defines the box axes.
-    XMMATRIX R = XMMatrixRotationQuaternion(BoxOrientation);
-
-    // Check against each plane of the frustum.
-    XMVECTOR Outside = XMVectorFalseInt();
-    XMVECTOR InsideAll = XMVectorTrueInt();
-    XMVECTOR CenterInsideAll = XMVectorTrueInt();
-
-    for (size_t i = 0; i < 6; ++i)
-    {
-        // Compute the distance to the center of the box.
-        XMVECTOR Dist = XMVector4Dot(Center, Planes[i]);
-
-        // Project the axes of the box onto the normal of the plane.  Half the
-        // length of the projection (sometime called the "radius") is equal to
-        // h(u) * abs(n dot b(u))) + h(v) * abs(n dot b(v)) + h(w) * abs(n dot b(w))
-        // where h(i) are extents of the box, n is the plane normal, and b(i) are the
-        // axes of the box.
-        XMVECTOR Radius = XMVector3Dot(Planes[i], R.r[0]);
-        Radius = XMVectorSelect(Radius, XMVector3Dot(Planes[i], R.r[1]), SelectY);
-        Radius = XMVectorSelect(Radius, XMVector3Dot(Planes[i], R.r[2]), SelectZ);
-        Radius = XMVector3Dot(Extents, XMVectorAbs(Radius));
-
-        // Outside the plane?
-        Outside = XMVectorOrInt(Outside, XMVectorGreater(Dist, Radius));
-
-        // Fully inside the plane?
-        InsideAll = XMVectorAndInt(InsideAll, XMVectorLessOrEqual(Dist, XMVectorNegate(Radius)));
-
-        // Check if the center is inside the plane.
-        CenterInsideAll = XMVectorAndInt(CenterInsideAll, XMVectorLessOrEqual(Dist, Zero));
-    }
-
-    // If the box is outside any of the planes it is outside.
-    if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-        return false;
-
-    // If the box is inside all planes it is fully inside.
-    if (XMVector4EqualInt(InsideAll, XMVectorTrueInt()))
-        return true;
-
-    // If the center of the box is inside all planes and the box intersects
-    // one or more planes then it must intersect.
-    if (XMVector4EqualInt(CenterInsideAll, XMVectorTrueInt()))
-        return true;
-
-    // Build the corners of the frustum.
-    XMVECTOR vRightTop = XMVectorSet(RightSlope, TopSlope, 1.0f, 0.0f);
-    XMVECTOR vRightBottom = XMVectorSet(RightSlope, BottomSlope, 1.0f, 0.0f);
-    XMVECTOR vLeftTop = XMVectorSet(LeftSlope, TopSlope, 1.0f, 0.0f);
-    XMVECTOR vLeftBottom = XMVectorSet(LeftSlope, BottomSlope, 1.0f, 0.0f);
-    XMVECTOR vNear = XMVectorReplicatePtr(&Near);
-    XMVECTOR vFar = XMVectorReplicatePtr(&Far);
-
-    XMVECTOR Corners[CORNER_COUNT];
-    Corners[0] = XMVectorMultiply(vRightTop, vNear);
-    Corners[1] = XMVectorMultiply(vRightBottom, vNear);
-    Corners[2] = XMVectorMultiply(vLeftTop, vNear);
-    Corners[3] = XMVectorMultiply(vLeftBottom, vNear);
-    Corners[4] = XMVectorMultiply(vRightTop, vFar);
-    Corners[5] = XMVectorMultiply(vRightBottom, vFar);
-    Corners[6] = XMVectorMultiply(vLeftTop, vFar);
-    Corners[7] = XMVectorMultiply(vLeftBottom, vFar);
-
-    // Test against box axes (3)
-    {
-        // Find the min/max values of the projection of the frustum onto each axis.
-        XMVECTOR FrustumMin, FrustumMax;
-
-        FrustumMin = XMVector3Dot(Corners[0], R.r[0]);
-        FrustumMin = XMVectorSelect(FrustumMin, XMVector3Dot(Corners[0], R.r[1]), SelectY);
-        FrustumMin = XMVectorSelect(FrustumMin, XMVector3Dot(Corners[0], R.r[2]), SelectZ);
-        FrustumMax = FrustumMin;
-
-        for (size_t i = 1; i < BoundingOrientedBox::CORNER_COUNT; ++i)
-        {
-            XMVECTOR Temp = XMVector3Dot(Corners[i], R.r[0]);
-            Temp = XMVectorSelect(Temp, XMVector3Dot(Corners[i], R.r[1]), SelectY);
-            Temp = XMVectorSelect(Temp, XMVector3Dot(Corners[i], R.r[2]), SelectZ);
-
-            FrustumMin = XMVectorMin(FrustumMin, Temp);
-            FrustumMax = XMVectorMax(FrustumMax, Temp);
-        }
-
-        // Project the center of the box onto the axes.
-        XMVECTOR BoxDist = XMVector3Dot(Center, R.r[0]);
-        BoxDist = XMVectorSelect(BoxDist, XMVector3Dot(Center, R.r[1]), SelectY);
-        BoxDist = XMVectorSelect(BoxDist, XMVector3Dot(Center, R.r[2]), SelectZ);
-
-        // The projection of the box onto the axis is just its Center and Extents.
-        // if (min > box_max || max < box_min) reject;
-        XMVECTOR Result = XMVectorOrInt(XMVectorGreater(FrustumMin, XMVectorAdd(BoxDist, Extents)),
-                                        XMVectorLess(FrustumMax, XMVectorSubtract(BoxDist, Extents)));
-
-        if (DirectX::Internal::XMVector3AnyTrue(Result))
-            return false;
-    }
-
-    // Test against edge/edge axes (3*6).
-    XMVECTOR FrustumEdgeAxis[6];
-
-    FrustumEdgeAxis[0] = vRightTop;
-    FrustumEdgeAxis[1] = vRightBottom;
-    FrustumEdgeAxis[2] = vLeftTop;
-    FrustumEdgeAxis[3] = vLeftBottom;
-    FrustumEdgeAxis[4] = XMVectorSubtract(vRightTop, vLeftTop);
-    FrustumEdgeAxis[5] = XMVectorSubtract(vLeftBottom, vLeftTop);
-
-    for (size_t i = 0; i < 3; ++i)
-    {
-        for (size_t j = 0; j < 6; j++)
-        {
-            // Compute the axis we are going to test.
-            XMVECTOR Axis = XMVector3Cross(R.r[i], FrustumEdgeAxis[j]);
-
-            // Find the min/max values of the projection of the frustum onto the axis.
-            XMVECTOR FrustumMin, FrustumMax;
-
-            FrustumMin = FrustumMax = XMVector3Dot(Axis, Corners[0]);
-
-            for (size_t k = 1; k < CORNER_COUNT; k++)
-            {
-                XMVECTOR Temp = XMVector3Dot(Axis, Corners[k]);
-                FrustumMin = XMVectorMin(FrustumMin, Temp);
-                FrustumMax = XMVectorMax(FrustumMax, Temp);
-            }
-
-            // Project the center of the box onto the axis.
-            XMVECTOR Dist = XMVector3Dot(Center, Axis);
-
-            // Project the axes of the box onto the axis to find the "radius" of the box.
-            XMVECTOR Radius = XMVector3Dot(Axis, R.r[0]);
-            Radius = XMVectorSelect(Radius, XMVector3Dot(Axis, R.r[1]), SelectY);
-            Radius = XMVectorSelect(Radius, XMVector3Dot(Axis, R.r[2]), SelectZ);
-            Radius = XMVector3Dot(Extents, XMVectorAbs(Radius));
-
-            // if (center > max + radius || center < min - radius) reject;
-            Outside = XMVectorOrInt(Outside, XMVectorGreater(Dist, XMVectorAdd(FrustumMax, Radius)));
-            Outside = XMVectorOrInt(Outside, XMVectorLess(Dist, XMVectorSubtract(FrustumMin, Radius)));
-        }
-    }
-
-    if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-        return false;
-
-    // If we did not find a separating plane then the box must intersect the frustum.
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-// Exact frustum vs frustum test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool BoundingFrustum::Intersects(const BoundingFrustum& fr) const noexcept
-{
-    // Load origin and orientation of frustum B.
-    XMVECTOR OriginB = XMLoadFloat3(&Origin);
-    XMVECTOR OrientationB = XMLoadFloat4(&Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(OrientationB));
-
-    // Build the planes of frustum B.
-    XMVECTOR AxisB[6];
-    AxisB[0] = XMVectorSet(0.0f, 0.0f, -1.0f, 0.0f);
-    AxisB[1] = XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
-    AxisB[2] = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-    AxisB[3] = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-    AxisB[4] = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-    AxisB[5] = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-
-    XMVECTOR PlaneDistB[6];
-    PlaneDistB[0] = XMVectorNegate(XMVectorReplicatePtr(&Near));
-    PlaneDistB[1] = XMVectorReplicatePtr(&Far);
-    PlaneDistB[2] = XMVectorZero();
-    PlaneDistB[3] = XMVectorZero();
-    PlaneDistB[4] = XMVectorZero();
-    PlaneDistB[5] = XMVectorZero();
-
-    // Load origin and orientation of frustum A.
-    XMVECTOR OriginA = XMLoadFloat3(&fr.Origin);
-    XMVECTOR OrientationA = XMLoadFloat4(&fr.Orientation);
-
-    assert(DirectX::Internal::XMQuaternionIsUnit(OrientationA));
-
-    // Transform frustum A into the space of the frustum B in order to
-    // minimize the number of transforms we have to do.
-    OriginA = XMVector3InverseRotate(XMVectorSubtract(OriginA, OriginB), OrientationB);
-    OrientationA = XMQuaternionMultiply(OrientationA, XMQuaternionConjugate(OrientationB));
-
-    // Build the corners of frustum A (in the local space of B).
-    XMVECTOR RightTopA = XMVectorSet(fr.RightSlope, fr.TopSlope, 1.0f, 0.0f);
-    XMVECTOR RightBottomA = XMVectorSet(fr.RightSlope, fr.BottomSlope, 1.0f, 0.0f);
-    XMVECTOR LeftTopA = XMVectorSet(fr.LeftSlope, fr.TopSlope, 1.0f, 0.0f);
-    XMVECTOR LeftBottomA = XMVectorSet(fr.LeftSlope, fr.BottomSlope, 1.0f, 0.0f);
-    XMVECTOR NearA = XMVectorReplicatePtr(&fr.Near);
-    XMVECTOR FarA = XMVectorReplicatePtr(&fr.Far);
-
-    RightTopA = XMVector3Rotate(RightTopA, OrientationA);
-    RightBottomA = XMVector3Rotate(RightBottomA, OrientationA);
-    LeftTopA = XMVector3Rotate(LeftTopA, OrientationA);
-    LeftBottomA = XMVector3Rotate(LeftBottomA, OrientationA);
-
-    XMVECTOR CornersA[CORNER_COUNT];
-    CornersA[0] = XMVectorMultiplyAdd(RightTopA, NearA, OriginA);
-    CornersA[1] = XMVectorMultiplyAdd(RightBottomA, NearA, OriginA);
-    CornersA[2] = XMVectorMultiplyAdd(LeftTopA, NearA, OriginA);
-    CornersA[3] = XMVectorMultiplyAdd(LeftBottomA, NearA, OriginA);
-    CornersA[4] = XMVectorMultiplyAdd(RightTopA, FarA, OriginA);
-    CornersA[5] = XMVectorMultiplyAdd(RightBottomA, FarA, OriginA);
-    CornersA[6] = XMVectorMultiplyAdd(LeftTopA, FarA, OriginA);
-    CornersA[7] = XMVectorMultiplyAdd(LeftBottomA, FarA, OriginA);
-
-    // Check frustum A against each plane of frustum B.
-    XMVECTOR Outside = XMVectorFalseInt();
-    XMVECTOR InsideAll = XMVectorTrueInt();
-
-    for (size_t i = 0; i < 6; ++i)
-    {
-        // Find the min/max projection of the frustum onto the plane normal.
-        XMVECTOR Min, Max;
-
-        Min = Max = XMVector3Dot(AxisB[i], CornersA[0]);
-
-        for (size_t j = 1; j < CORNER_COUNT; j++)
-        {
-            XMVECTOR Temp = XMVector3Dot(AxisB[i], CornersA[j]);
-            Min = XMVectorMin(Min, Temp);
-            Max = XMVectorMax(Max, Temp);
-        }
-
-        // Outside the plane?
-        Outside = XMVectorOrInt(Outside, XMVectorGreater(Min, PlaneDistB[i]));
-
-        // Fully inside the plane?
-        InsideAll = XMVectorAndInt(InsideAll, XMVectorLessOrEqual(Max, PlaneDistB[i]));
-    }
-
-    // If the frustum A is outside any of the planes of frustum B it is outside.
-    if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-        return false;
-
-    // If frustum A is inside all planes of frustum B it is fully inside.
-    if (XMVector4EqualInt(InsideAll, XMVectorTrueInt()))
-        return true;
-
-    // Build the corners of frustum B.
-    XMVECTOR RightTopB = XMVectorSet(RightSlope, TopSlope, 1.0f, 0.0f);
-    XMVECTOR RightBottomB = XMVectorSet(RightSlope, BottomSlope, 1.0f, 0.0f);
-    XMVECTOR LeftTopB = XMVectorSet(LeftSlope, TopSlope, 1.0f, 0.0f);
-    XMVECTOR LeftBottomB = XMVectorSet(LeftSlope, BottomSlope, 1.0f, 0.0f);
-    XMVECTOR NearB = XMVectorReplicatePtr(&Near);
-    XMVECTOR FarB = XMVectorReplicatePtr(&Far);
-
-    XMVECTOR CornersB[BoundingFrustum::CORNER_COUNT];
-    CornersB[0] = XMVectorMultiply(RightTopB, NearB);
-    CornersB[1] = XMVectorMultiply(RightBottomB, NearB);
-    CornersB[2] = XMVectorMultiply(LeftTopB, NearB);
-    CornersB[3] = XMVectorMultiply(LeftBottomB, NearB);
-    CornersB[4] = XMVectorMultiply(RightTopB, FarB);
-    CornersB[5] = XMVectorMultiply(RightBottomB, FarB);
-    CornersB[6] = XMVectorMultiply(LeftTopB, FarB);
-    CornersB[7] = XMVectorMultiply(LeftBottomB, FarB);
-
-    // Build the planes of frustum A (in the local space of B).
-    XMVECTOR AxisA[6];
-    XMVECTOR PlaneDistA[6];
-
-    AxisA[0] = XMVectorSet(0.0f, 0.0f, -1.0f, 0.0f);
-    AxisA[1] = XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
-    AxisA[2] = XMVectorSet(1.0f, 0.0f, -fr.RightSlope, 0.0f);
-    AxisA[3] = XMVectorSet(-1.0f, 0.0f, fr.LeftSlope, 0.0f);
-    AxisA[4] = XMVectorSet(0.0f, 1.0f, -fr.TopSlope, 0.0f);
-    AxisA[5] = XMVectorSet(0.0f, -1.0f, fr.BottomSlope, 0.0f);
-
-    AxisA[0] = XMVector3Rotate(AxisA[0], OrientationA);
-    AxisA[1] = XMVectorNegate(AxisA[0]);
-    AxisA[2] = XMVector3Rotate(AxisA[2], OrientationA);
-    AxisA[3] = XMVector3Rotate(AxisA[3], OrientationA);
-    AxisA[4] = XMVector3Rotate(AxisA[4], OrientationA);
-    AxisA[5] = XMVector3Rotate(AxisA[5], OrientationA);
-
-    PlaneDistA[0] = XMVector3Dot(AxisA[0], CornersA[0]);  // Re-use corner on near plane.
-    PlaneDistA[1] = XMVector3Dot(AxisA[1], CornersA[4]);  // Re-use corner on far plane.
-    PlaneDistA[2] = XMVector3Dot(AxisA[2], OriginA);
-    PlaneDistA[3] = XMVector3Dot(AxisA[3], OriginA);
-    PlaneDistA[4] = XMVector3Dot(AxisA[4], OriginA);
-    PlaneDistA[5] = XMVector3Dot(AxisA[5], OriginA);
-
-    // Check each axis of frustum A for a seperating plane (5).
-    for (size_t i = 0; i < 6; ++i)
-    {
-        // Find the minimum projection of the frustum onto the plane normal.
-        XMVECTOR Min;
-
-        Min = XMVector3Dot(AxisA[i], CornersB[0]);
-
-        for (size_t j = 1; j < CORNER_COUNT; j++)
-        {
-            XMVECTOR Temp = XMVector3Dot(AxisA[i], CornersB[j]);
-            Min = XMVectorMin(Min, Temp);
-        }
-
-        // Outside the plane?
-        Outside = XMVectorOrInt(Outside, XMVectorGreater(Min, PlaneDistA[i]));
-    }
-
-    // If the frustum B is outside any of the planes of frustum A it is outside.
-    if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-        return false;
-
-    // Check edge/edge axes (6 * 6).
-    XMVECTOR FrustumEdgeAxisA[6];
-    FrustumEdgeAxisA[0] = RightTopA;
-    FrustumEdgeAxisA[1] = RightBottomA;
-    FrustumEdgeAxisA[2] = LeftTopA;
-    FrustumEdgeAxisA[3] = LeftBottomA;
-    FrustumEdgeAxisA[4] = XMVectorSubtract(RightTopA, LeftTopA);
-    FrustumEdgeAxisA[5] = XMVectorSubtract(LeftBottomA, LeftTopA);
-
-    XMVECTOR FrustumEdgeAxisB[6];
-    FrustumEdgeAxisB[0] = RightTopB;
-    FrustumEdgeAxisB[1] = RightBottomB;
-    FrustumEdgeAxisB[2] = LeftTopB;
-    FrustumEdgeAxisB[3] = LeftBottomB;
-    FrustumEdgeAxisB[4] = XMVectorSubtract(RightTopB, LeftTopB);
-    FrustumEdgeAxisB[5] = XMVectorSubtract(LeftBottomB, LeftTopB);
-
-    for (size_t i = 0; i < 6; ++i)
-    {
-        for (size_t j = 0; j < 6; j++)
-        {
-            // Compute the axis we are going to test.
-            XMVECTOR Axis = XMVector3Cross(FrustumEdgeAxisA[i], FrustumEdgeAxisB[j]);
-
-            // Find the min/max values of the projection of both frustums onto the axis.
-            XMVECTOR MinA, MaxA;
-            XMVECTOR MinB, MaxB;
-
-            MinA = MaxA = XMVector3Dot(Axis, CornersA[0]);
-            MinB = MaxB = XMVector3Dot(Axis, CornersB[0]);
-
-            for (size_t k = 1; k < CORNER_COUNT; k++)
-            {
-                XMVECTOR TempA = XMVector3Dot(Axis, CornersA[k]);
-                MinA = XMVectorMin(MinA, TempA);
-                MaxA = XMVectorMax(MaxA, TempA);
-
-                XMVECTOR TempB = XMVector3Dot(Axis, CornersB[k]);
-                MinB = XMVectorMin(MinB, TempB);
-                MaxB = XMVectorMax(MaxB, TempB);
-            }
-
-            // if (MinA > MaxB || MinB > MaxA) reject
-            Outside = XMVectorOrInt(Outside, XMVectorGreater(MinA, MaxB));
-            Outside = XMVectorOrInt(Outside, XMVectorGreater(MinB, MaxA));
-        }
-    }
-
-    // If there is a seperating plane, then the frustums do not intersect.
-    if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-        return false;
-
-    // If we did not find a separating plane then the frustums intersect.
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-// Triangle vs frustum test.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool XM_CALLCONV BoundingFrustum::Intersects(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2) const noexcept
-{
-// Build the frustum planes (NOTE: D is negated from the usual).
-XMVECTOR Planes[6];
-Planes[0] = XMVectorSet(0.0f, 0.0f, -1.0f, -Near);
-Planes[1] = XMVectorSet(0.0f, 0.0f, 1.0f, Far);
-Planes[2] = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-Planes[3] = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-Planes[4] = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-Planes[5] = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-
-// Load origin and orientation of the frustum.
-XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-// Transform triangle into the local space of frustum.
-XMVECTOR TV0 = XMVector3InverseRotate(XMVectorSubtract(V0, vOrigin), vOrientation);
-XMVECTOR TV1 = XMVector3InverseRotate(XMVectorSubtract(V1, vOrigin), vOrientation);
-XMVECTOR TV2 = XMVector3InverseRotate(XMVectorSubtract(V2, vOrigin), vOrientation);
-
-// Test each vertex of the triangle against the frustum planes.
-XMVECTOR Outside = XMVectorFalseInt();
-XMVECTOR InsideAll = XMVectorTrueInt();
-
-for (size_t i = 0; i < 6; ++i)
-{
-XMVECTOR Dist0 = XMVector3Dot(TV0, Planes[i]);
-XMVECTOR Dist1 = XMVector3Dot(TV1, Planes[i]);
-XMVECTOR Dist2 = XMVector3Dot(TV2, Planes[i]);
-
-XMVECTOR MinDist = XMVectorMin(Dist0, Dist1);
-MinDist = XMVectorMin(MinDist, Dist2);
-XMVECTOR MaxDist = XMVectorMax(Dist0, Dist1);
-MaxDist = XMVectorMax(MaxDist, Dist2);
-
-XMVECTOR PlaneDist = XMVectorSplatW(Planes[i]);
-
-// Outside the plane?
-Outside = XMVectorOrInt(Outside, XMVectorGreater(MinDist, PlaneDist));
-
-// Fully inside the plane?
-InsideAll = XMVectorAndInt(InsideAll, XMVectorLessOrEqual(MaxDist, PlaneDist));
-}
-
-// If the triangle is outside any of the planes it is outside.
-if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-return false;
-
-// If the triangle is inside all planes it is fully inside.
-if (XMVector4EqualInt(InsideAll, XMVectorTrueInt()))
-return true;
-
-// Build the corners of the frustum.
-XMVECTOR vRightTop = XMVectorSet(RightSlope, TopSlope, 1.0f, 0.0f);
-XMVECTOR vRightBottom = XMVectorSet(RightSlope, BottomSlope, 1.0f, 0.0f);
-XMVECTOR vLeftTop = XMVectorSet(LeftSlope, TopSlope, 1.0f, 0.0f);
-XMVECTOR vLeftBottom = XMVectorSet(LeftSlope, BottomSlope, 1.0f, 0.0f);
-XMVECTOR vNear = XMVectorReplicatePtr(&Near);
-XMVECTOR vFar = XMVectorReplicatePtr(&Far);
-
-XMVECTOR Corners[CORNER_COUNT];
-Corners[0] = XMVectorMultiply(vRightTop, vNear);
-Corners[1] = XMVectorMultiply(vRightBottom, vNear);
-Corners[2] = XMVectorMultiply(vLeftTop, vNear);
-Corners[3] = XMVectorMultiply(vLeftBottom, vNear);
-Corners[4] = XMVectorMultiply(vRightTop, vFar);
-Corners[5] = XMVectorMultiply(vRightBottom, vFar);
-Corners[6] = XMVectorMultiply(vLeftTop, vFar);
-Corners[7] = XMVectorMultiply(vLeftBottom, vFar);
-
-// Test the plane of the triangle.
-XMVECTOR Normal = XMVector3Cross(XMVectorSubtract(V1, V0), XMVectorSubtract(V2, V0));
-XMVECTOR Dist = XMVector3Dot(Normal, V0);
-
-XMVECTOR MinDist, MaxDist;
-MinDist = MaxDist = XMVector3Dot(Corners[0], Normal);
-for (size_t i = 1; i < CORNER_COUNT; ++i)
-{
-XMVECTOR Temp = XMVector3Dot(Corners[i], Normal);
-MinDist = XMVectorMin(MinDist, Temp);
-MaxDist = XMVectorMax(MaxDist, Temp);
-}
-
-Outside = XMVectorOrInt(XMVectorGreater(MinDist, Dist), XMVectorLess(MaxDist, Dist));
-if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-return false;
-
-// Check the edge/edge axes (3*6).
-XMVECTOR TriangleEdgeAxis[3];
-TriangleEdgeAxis[0] = XMVectorSubtract(V1, V0);
-TriangleEdgeAxis[1] = XMVectorSubtract(V2, V1);
-TriangleEdgeAxis[2] = XMVectorSubtract(V0, V2);
-
-XMVECTOR FrustumEdgeAxis[6];
-FrustumEdgeAxis[0] = vRightTop;
-FrustumEdgeAxis[1] = vRightBottom;
-FrustumEdgeAxis[2] = vLeftTop;
-FrustumEdgeAxis[3] = vLeftBottom;
-FrustumEdgeAxis[4] = XMVectorSubtract(vRightTop, vLeftTop);
-FrustumEdgeAxis[5] = XMVectorSubtract(vLeftBottom, vLeftTop);
-
-for (size_t i = 0; i < 3; ++i)
-{
-for (size_t j = 0; j < 6; j++)
-{
-// Compute the axis we are going to test.
-XMVECTOR Axis = XMVector3Cross(TriangleEdgeAxis[i], FrustumEdgeAxis[j]);
-
-// Find the min/max of the projection of the triangle onto the axis.
-XMVECTOR MinA, MaxA;
-
-XMVECTOR Dist0 = XMVector3Dot(V0, Axis);
-XMVECTOR Dist1 = XMVector3Dot(V1, Axis);
-XMVECTOR Dist2 = XMVector3Dot(V2, Axis);
-
-MinA = XMVectorMin(Dist0, Dist1);
-MinA = XMVectorMin(MinA, Dist2);
-MaxA = XMVectorMax(Dist0, Dist1);
-MaxA = XMVectorMax(MaxA, Dist2);
-
-// Find the min/max of the projection of the frustum onto the axis.
-XMVECTOR MinB, MaxB;
-
-MinB = MaxB = XMVector3Dot(Axis, Corners[0]);
-
-for (size_t k = 1; k < CORNER_COUNT; k++)
-{
-XMVECTOR Temp = XMVector3Dot(Axis, Corners[k]);
-MinB = XMVectorMin(MinB, Temp);
-MaxB = XMVectorMax(MaxB, Temp);
-}
-
-// if (MinA > MaxB || MinB > MaxA) reject;
-Outside = XMVectorOrInt(Outside, XMVectorGreater(MinA, MaxB));
-Outside = XMVectorOrInt(Outside, XMVectorGreater(MinB, MaxA));
-}
-}
-
-if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-return false;
-
-// If we did not find a separating plane then the triangle must intersect the frustum.
-return true;
-}
-
-
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline PlaneIntersectionType XM_CALLCONV BoundingFrustum::Intersects(FXMVECTOR Plane) const noexcept
-{
-assert(DirectX::Internal::XMPlaneIsUnit(Plane));
-
-// Load origin and orientation of the frustum.
-XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-// Set w of the origin to one so we can dot4 with a plane.
-vOrigin = XMVectorInsert<0, 0, 0, 0, 1>(vOrigin, XMVectorSplatOne());
-
-// Build the corners of the frustum (in world space).
-XMVECTOR RightTop = XMVectorSet(RightSlope, TopSlope, 1.0f, 0.0f);
-XMVECTOR RightBottom = XMVectorSet(RightSlope, BottomSlope, 1.0f, 0.0f);
-XMVECTOR LeftTop = XMVectorSet(LeftSlope, TopSlope, 1.0f, 0.0f);
-XMVECTOR LeftBottom = XMVectorSet(LeftSlope, BottomSlope, 1.0f, 0.0f);
-XMVECTOR vNear = XMVectorReplicatePtr(&Near);
-XMVECTOR vFar = XMVectorReplicatePtr(&Far);
-
-RightTop = XMVector3Rotate(RightTop, vOrientation);
-RightBottom = XMVector3Rotate(RightBottom, vOrientation);
-LeftTop = XMVector3Rotate(LeftTop, vOrientation);
-LeftBottom = XMVector3Rotate(LeftBottom, vOrientation);
-
-XMVECTOR Corners0 = XMVectorMultiplyAdd(RightTop, vNear, vOrigin);
-XMVECTOR Corners1 = XMVectorMultiplyAdd(RightBottom, vNear, vOrigin);
-XMVECTOR Corners2 = XMVectorMultiplyAdd(LeftTop, vNear, vOrigin);
-XMVECTOR Corners3 = XMVectorMultiplyAdd(LeftBottom, vNear, vOrigin);
-XMVECTOR Corners4 = XMVectorMultiplyAdd(RightTop, vFar, vOrigin);
-XMVECTOR Corners5 = XMVectorMultiplyAdd(RightBottom, vFar, vOrigin);
-XMVECTOR Corners6 = XMVectorMultiplyAdd(LeftTop, vFar, vOrigin);
-XMVECTOR Corners7 = XMVectorMultiplyAdd(LeftBottom, vFar, vOrigin);
-
-XMVECTOR Outside, Inside;
-DirectX::Internal::FastIntersectFrustumPlane(Corners0, Corners1, Corners2, Corners3,
-        Corners4, Corners5, Corners6, Corners7,
-        Plane, Outside, Inside);
-
-// If the frustum is outside any plane it is outside.
-if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-return FRONT;
-
-// If the frustum is inside all planes it is inside.
-if (XMVector4EqualInt(Inside, XMVectorTrueInt()))
-return BACK;
-
-// The frustum is not inside all planes or outside a plane it intersects.
-return INTERSECTING;
-}
-
-
-//-----------------------------------------------------------------------------
-// Ray vs. frustum test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool XM_CALLCONV BoundingFrustum::Intersects(FXMVECTOR rayOrigin, FXMVECTOR Direction, float& Dist) const noexcept
-{
-// If ray starts inside the frustum, return a distance of 0 for the hit
-if (Contains(rayOrigin) == CONTAINS)
-{
-Dist = 0.0f;
-return true;
-}
-
-// Build the frustum planes.
-XMVECTOR Planes[6];
-Planes[0] = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-Planes[1] = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-Planes[2] = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-Planes[3] = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-Planes[4] = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-Planes[5] = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-
-// Load origin and orientation of the frustum.
-XMVECTOR frOrigin = XMLoadFloat3(&Origin);
-XMVECTOR frOrientation = XMLoadFloat4(&Orientation);
-
-// This algorithm based on "Fast Ray-Convex Polyhedron Intersectin," in James Arvo, ed., Graphics Gems II pp. 247-250
-float tnear = -FLT_MAX;
-float tfar = FLT_MAX;
-
-for (size_t i = 0; i < 6; ++i)
-{
-XMVECTOR Plane = DirectX::Internal::XMPlaneTransform(Planes[i], frOrientation, frOrigin);
-Plane = XMPlaneNormalize(Plane);
-
-XMVECTOR AxisDotOrigin = XMPlaneDotCoord(Plane, rayOrigin);
-XMVECTOR AxisDotDirection = XMVector3Dot(Plane, Direction);
-
-if (XMVector3LessOrEqual(XMVectorAbs(AxisDotDirection), g_RayEpsilon))
-{
-// Ray is parallel to plane - check if ray origin is inside plane's
-if (XMVector3Greater(AxisDotOrigin, g_XMZero))
-{
-// Ray origin is outside half-space.
-Dist = 0.f;
-return false;
-}
-}
-else
-{
-// Ray not parallel - get distance to plane.
-float vd = XMVectorGetX(AxisDotDirection);
-float vn = XMVectorGetX(AxisDotOrigin);
-float t = -vn / vd;
-if (vd < 0.0f)
-{
-// Front face - T is a near point.
-if (t > tfar)
-{
-Dist = 0.f;
-return false;
-}
-if (t > tnear)
-{
-// Hit near face.
-tnear = t;
-}
-}
-else
-{
-// back face - T is far point.
-if (t < tnear)
-{
-Dist = 0.f;
-return false;
-}
-if (t < tfar)
-{
-// Hit far face.
-tfar = t;
-}
-}
-}
-}
-
-// Survived all tests.
-// Note: if ray originates on polyhedron, may want to change 0.0f to some
-// epsilon to avoid intersecting the originating face.
-float distance = (tnear >= 0.0f) ? tnear : tfar;
-if (distance >= 0.0f)
-{
-Dist = distance;
-return true;
-}
-
-Dist = 0.f;
-return false;
-}
-
-
-//-----------------------------------------------------------------------------
-// Test a frustum vs 6 planes (typically forming another frustum).
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV BoundingFrustum::ContainedBy(
-        FXMVECTOR Plane0, FXMVECTOR Plane1, FXMVECTOR Plane2,
-GXMVECTOR Plane3,
-        HXMVECTOR Plane4, HXMVECTOR Plane5) const noexcept
-{
-// Load origin and orientation of the frustum.
-XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-assert(DirectX::Internal::XMQuaternionIsUnit(vOrientation));
-
-// Set w of the origin to one so we can dot4 with a plane.
-vOrigin = XMVectorInsert<0, 0, 0, 0, 1>(vOrigin, XMVectorSplatOne());
-
-// Build the corners of the frustum (in world space).
-XMVECTOR RightTop = XMVectorSet(RightSlope, TopSlope, 1.0f, 0.0f);
-XMVECTOR RightBottom = XMVectorSet(RightSlope, BottomSlope, 1.0f, 0.0f);
-XMVECTOR LeftTop = XMVectorSet(LeftSlope, TopSlope, 1.0f, 0.0f);
-XMVECTOR LeftBottom = XMVectorSet(LeftSlope, BottomSlope, 1.0f, 0.0f);
-XMVECTOR vNear = XMVectorReplicatePtr(&Near);
-XMVECTOR vFar = XMVectorReplicatePtr(&Far);
-
-RightTop = XMVector3Rotate(RightTop, vOrientation);
-RightBottom = XMVector3Rotate(RightBottom, vOrientation);
-LeftTop = XMVector3Rotate(LeftTop, vOrientation);
-LeftBottom = XMVector3Rotate(LeftBottom, vOrientation);
-
-XMVECTOR Corners0 = XMVectorMultiplyAdd(RightTop, vNear, vOrigin);
-XMVECTOR Corners1 = XMVectorMultiplyAdd(RightBottom, vNear, vOrigin);
-XMVECTOR Corners2 = XMVectorMultiplyAdd(LeftTop, vNear, vOrigin);
-XMVECTOR Corners3 = XMVectorMultiplyAdd(LeftBottom, vNear, vOrigin);
-XMVECTOR Corners4 = XMVectorMultiplyAdd(RightTop, vFar, vOrigin);
-XMVECTOR Corners5 = XMVectorMultiplyAdd(RightBottom, vFar, vOrigin);
-XMVECTOR Corners6 = XMVectorMultiplyAdd(LeftTop, vFar, vOrigin);
-XMVECTOR Corners7 = XMVectorMultiplyAdd(LeftBottom, vFar, vOrigin);
-
-XMVECTOR Outside, Inside;
-
-// Test against each plane.
-DirectX::Internal::FastIntersectFrustumPlane(Corners0, Corners1, Corners2, Corners3,
-        Corners4, Corners5, Corners6, Corners7,
-        Plane0, Outside, Inside);
-
-XMVECTOR AnyOutside = Outside;
-XMVECTOR AllInside = Inside;
-
-DirectX::Internal::FastIntersectFrustumPlane(Corners0, Corners1, Corners2, Corners3,
-        Corners4, Corners5, Corners6, Corners7,
-        Plane1, Outside, Inside);
-
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectFrustumPlane(Corners0, Corners1, Corners2, Corners3,
-        Corners4, Corners5, Corners6, Corners7,
-        Plane2, Outside, Inside);
-
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectFrustumPlane(Corners0, Corners1, Corners2, Corners3,
-        Corners4, Corners5, Corners6, Corners7,
-        Plane3, Outside, Inside);
-
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectFrustumPlane(Corners0, Corners1, Corners2, Corners3,
-        Corners4, Corners5, Corners6, Corners7,
-        Plane4, Outside, Inside);
-
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectFrustumPlane(Corners0, Corners1, Corners2, Corners3,
-        Corners4, Corners5, Corners6, Corners7,
-        Plane5, Outside, Inside);
-
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-// If the frustum is outside any plane it is outside.
-if (XMVector4EqualInt(AnyOutside, XMVectorTrueInt()))
-return DISJOINT;
-
-// If the frustum is inside all planes it is inside.
-if (XMVector4EqualInt(AllInside, XMVectorTrueInt()))
-return CONTAINS;
-
-// The frustum is not inside all planes or outside a plane, it may intersect.
-return INTERSECTS;
-}
-
-
-//-----------------------------------------------------------------------------
-// Build the 6 frustum planes from a frustum.
-//
-// The intended use for these routines is for fast culling to a view frustum.
-// When the volume being tested against a view frustum is small relative to the
-// view frustum it is usually either inside all six planes of the frustum
-// (CONTAINS) or outside one of the planes of the frustum (DISJOINT). If neither
-// of these cases is true then it may or may not be intersecting the frustum
-// (INTERSECTS)
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void BoundingFrustum::GetPlanes(XMVECTOR* NearPlane, XMVECTOR* FarPlane, XMVECTOR* RightPlane,
-                                       XMVECTOR* LeftPlane, XMVECTOR* TopPlane, XMVECTOR* BottomPlane) const noexcept
-{
-// Load origin and orientation of the frustum.
-XMVECTOR vOrigin = XMLoadFloat3(&Origin);
-XMVECTOR vOrientation = XMLoadFloat4(&Orientation);
-
-if (NearPlane)
-{
-XMVECTOR vNearPlane = XMVectorSet(0.0f, 0.0f, -1.0f, Near);
-vNearPlane = DirectX::Internal::XMPlaneTransform(vNearPlane, vOrientation, vOrigin);
-*NearPlane = XMPlaneNormalize(vNearPlane);
-}
-
-if (FarPlane)
-{
-XMVECTOR vFarPlane = XMVectorSet(0.0f, 0.0f, 1.0f, -Far);
-vFarPlane = DirectX::Internal::XMPlaneTransform(vFarPlane, vOrientation, vOrigin);
-*FarPlane = XMPlaneNormalize(vFarPlane);
-}
-
-if (RightPlane)
-{
-XMVECTOR vRightPlane = XMVectorSet(1.0f, 0.0f, -RightSlope, 0.0f);
-vRightPlane = DirectX::Internal::XMPlaneTransform(vRightPlane, vOrientation, vOrigin);
-*RightPlane = XMPlaneNormalize(vRightPlane);
-}
-
-if (LeftPlane)
-{
-XMVECTOR vLeftPlane = XMVectorSet(-1.0f, 0.0f, LeftSlope, 0.0f);
-vLeftPlane = DirectX::Internal::XMPlaneTransform(vLeftPlane, vOrientation, vOrigin);
-*LeftPlane = XMPlaneNormalize(vLeftPlane);
-}
-
-if (TopPlane)
-{
-XMVECTOR vTopPlane = XMVectorSet(0.0f, 1.0f, -TopSlope, 0.0f);
-vTopPlane = DirectX::Internal::XMPlaneTransform(vTopPlane, vOrientation, vOrigin);
-*TopPlane = XMPlaneNormalize(vTopPlane);
-}
-
-if (BottomPlane)
-{
-XMVECTOR vBottomPlane = XMVectorSet(0.0f, -1.0f, BottomSlope, 0.0f);
-vBottomPlane = DirectX::Internal::XMPlaneTransform(vBottomPlane, vOrientation, vOrigin);
-*BottomPlane = XMPlaneNormalize(vBottomPlane);
-}
-}
-
-
-//-----------------------------------------------------------------------------
-// Build a frustum from a persepective projection matrix.  The matrix may only
-// contain a projection; any rotation, translation or scale will cause the
-// constructed frustum to be incorrect.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV BoundingFrustum::CreateFromMatrix(BoundingFrustum& Out, FXMMATRIX Projection, bool rhcoords) noexcept
-{
-// Corners of the projection frustum in homogenous space.
-static XMVECTORF32 HomogenousPoints[6] =
-        {
-                { { {  1.0f,  0.0f, 1.0f, 1.0f } } },   // right (at far plane)
-                { { { -1.0f,  0.0f, 1.0f, 1.0f } } },   // left
-                { { {  0.0f,  1.0f, 1.0f, 1.0f } } },   // top
-                { { {  0.0f, -1.0f, 1.0f, 1.0f } } },   // bottom
-
-                { { { 0.0f, 0.0f, 0.0f, 1.0f } } },     // near
-                { { { 0.0f, 0.0f, 1.0f, 1.0f } } }      // far
-        };
-
-XMVECTOR Determinant;
-XMMATRIX matInverse = XMMatrixInverse(&Determinant, Projection);
-
-// Compute the frustum corners in world space.
-XMVECTOR Points[6];
-
-for (size_t i = 0; i < 6; ++i)
-{
-// Transform point.
-Points[i] = XMVector4Transform(HomogenousPoints[i], matInverse);
-}
-
-Out.Origin = XMFLOAT3(0.0f, 0.0f, 0.0f);
-Out.Orientation = XMFLOAT4(0.0f, 0.0f, 0.0f, 1.0f);
-
-// Compute the slopes.
-Points[0] = XMVectorMultiply(Points[0], XMVectorReciprocal(XMVectorSplatZ(Points[0])));
-Points[1] = XMVectorMultiply(Points[1], XMVectorReciprocal(XMVectorSplatZ(Points[1])));
-Points[2] = XMVectorMultiply(Points[2], XMVectorReciprocal(XMVectorSplatZ(Points[2])));
-Points[3] = XMVectorMultiply(Points[3], XMVectorReciprocal(XMVectorSplatZ(Points[3])));
-
-Out.RightSlope = XMVectorGetX(Points[0]);
-Out.LeftSlope = XMVectorGetX(Points[1]);
-Out.TopSlope = XMVectorGetY(Points[2]);
-Out.BottomSlope = XMVectorGetY(Points[3]);
-
-// Compute near and far.
-Points[4] = XMVectorMultiply(Points[4], XMVectorReciprocal(XMVectorSplatW(Points[4])));
-Points[5] = XMVectorMultiply(Points[5], XMVectorReciprocal(XMVectorSplatW(Points[5])));
-
-if (rhcoords)
-{
-Out.Near = XMVectorGetZ(Points[5]);
-Out.Far = XMVectorGetZ(Points[4]);
-}
-else
-{
-Out.Near = XMVectorGetZ(Points[4]);
-Out.Far = XMVectorGetZ(Points[5]);
-}
-}
-
-
-/****************************************************************************
- *
- * TriangleTests
- *
- ****************************************************************************/
-
-namespace TriangleTests
-{
-
-    //-----------------------------------------------------------------------------
-    // Compute the intersection of a ray (Origin, Direction) with a triangle
-    // (V0, V1, V2).  Return true if there is an intersection and also set *pDist
-    // to the distance along the ray to the intersection.
-    //
-    // The algorithm is based on Moller, Tomas and Trumbore, "Fast, Minimum Storage
-    // Ray-Triangle Intersection", Journal of Graphics Tools, vol. 2, no. 1,
-    // pp 21-28, 1997.
-    //-----------------------------------------------------------------------------
-    _Use_decl_annotations_
-    inline bool XM_CALLCONV Intersects(
-            FXMVECTOR Origin, FXMVECTOR Direction, FXMVECTOR V0,
-    GXMVECTOR V1,
-            HXMVECTOR V2, float& Dist) noexcept
-{
-    assert(DirectX::Internal::XMVector3IsUnit(Direction));
-
-    XMVECTOR Zero = XMVectorZero();
-
-    XMVECTOR e1 = XMVectorSubtract(V1, V0);
-    XMVECTOR e2 = XMVectorSubtract(V2, V0);
-
-    // p = Direction ^ e2;
-    XMVECTOR p = XMVector3Cross(Direction, e2);
-
-    // det = e1 * p;
-    XMVECTOR det = XMVector3Dot(e1, p);
-
-    XMVECTOR u, v, t;
-
-    if (XMVector3GreaterOrEqual(det, g_RayEpsilon))
-{
-    // Determinate is positive (front side of the triangle).
-    XMVECTOR s = XMVectorSubtract(Origin, V0);
-
-    // u = s * p;
-    u = XMVector3Dot(s, p);
-
-    XMVECTOR NoIntersection = XMVectorLess(u, Zero);
-    NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(u, det));
-
-    // q = s ^ e1;
-    XMVECTOR q = XMVector3Cross(s, e1);
-
-    // v = Direction * q;
-    v = XMVector3Dot(Direction, q);
-
-    NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(v, Zero));
-    NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(XMVectorAdd(u, v), det));
-
-    // t = e2 * q;
-    t = XMVector3Dot(e2, q);
-
-    NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(t, Zero));
-
-    if (XMVector4EqualInt(NoIntersection, XMVectorTrueInt()))
-{
-    Dist = 0.f;
-    return false;
-}
-}
-else if (XMVector3LessOrEqual(det, g_RayNegEpsilon))
-{
-// Determinate is negative (back side of the triangle).
-XMVECTOR s = XMVectorSubtract(Origin, V0);
-
-// u = s * p;
-u = XMVector3Dot(s, p);
-
-XMVECTOR NoIntersection = XMVectorGreater(u, Zero);
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(u, det));
-
-// q = s ^ e1;
-XMVECTOR q = XMVector3Cross(s, e1);
-
-// v = Direction * q;
-v = XMVector3Dot(Direction, q);
-
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(v, Zero));
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorLess(XMVectorAdd(u, v), det));
-
-// t = e2 * q;
-t = XMVector3Dot(e2, q);
-
-NoIntersection = XMVectorOrInt(NoIntersection, XMVectorGreater(t, Zero));
-
-if (XMVector4EqualInt(NoIntersection, XMVectorTrueInt()))
-{
-Dist = 0.f;
-return false;
-}
-}
-else
-{
-// Parallel ray.
-Dist = 0.f;
-return false;
-}
-
-t = XMVectorDivide(t, det);
-
-// (u / det) and (v / dev) are the barycentric cooridinates of the intersection.
-
-// Store the x-component to *pDist
-XMStoreFloat(&Dist, t);
-
-return true;
-}
-
-
-//-----------------------------------------------------------------------------
-// Test if two triangles intersect.
-//
-// The final test of algorithm is based on Shen, Heng, and Tang, "A Fast
-// Triangle-Triangle Overlap Test Using Signed Distances", Journal of Graphics
-// Tools, vol. 8, no. 1, pp 17-23, 2003 and Guigue and Devillers, "Fast and
-// Robust Triangle-Triangle Overlap Test Using Orientation Predicates", Journal
-// of Graphics Tools, vol. 8, no. 1, pp 25-32, 2003.
-//
-// The final test could be considered an edge-edge separating plane test with
-// the 9 possible cases narrowed down to the only two pairs of edges that can
-// actaully result in a seperation.
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline bool XM_CALLCONV Intersects(FXMVECTOR A0, FXMVECTOR A1, FXMVECTOR A2, GXMVECTOR B0, HXMVECTOR B1, HXMVECTOR B2) noexcept
-{
-static const XMVECTORU32 SelectY = { { { XM_SELECT_0, XM_SELECT_1, XM_SELECT_0, XM_SELECT_0 } } };
-static const XMVECTORU32 SelectZ = { { { XM_SELECT_0, XM_SELECT_0, XM_SELECT_1, XM_SELECT_0 } } };
-static const XMVECTORU32 Select0111 = { { { XM_SELECT_0, XM_SELECT_1, XM_SELECT_1, XM_SELECT_1 } } };
-static const XMVECTORU32 Select1011 = { { { XM_SELECT_1, XM_SELECT_0, XM_SELECT_1, XM_SELECT_1 } } };
-static const XMVECTORU32 Select1101 = { { { XM_SELECT_1, XM_SELECT_1, XM_SELECT_0, XM_SELECT_1 } } };
-
-XMVECTOR Zero = XMVectorZero();
-
-// Compute the normal of triangle A.
-XMVECTOR N1 = XMVector3Cross(XMVectorSubtract(A1, A0), XMVectorSubtract(A2, A0));
-
-// Assert that the triangle is not degenerate.
-assert(!XMVector3Equal(N1, Zero));
-
-// Test points of B against the plane of A.
-XMVECTOR BDist = XMVector3Dot(N1, XMVectorSubtract(B0, A0));
-BDist = XMVectorSelect(BDist, XMVector3Dot(N1, XMVectorSubtract(B1, A0)), SelectY);
-BDist = XMVectorSelect(BDist, XMVector3Dot(N1, XMVectorSubtract(B2, A0)), SelectZ);
-
-// Ensure robustness with co-planar triangles by zeroing small distances.
-uint32_t BDistIsZeroCR;
-XMVECTOR BDistIsZero = XMVectorGreaterR(&BDistIsZeroCR, g_RayEpsilon, XMVectorAbs(BDist));
-BDist = XMVectorSelect(BDist, Zero, BDistIsZero);
-
-uint32_t BDistIsLessCR;
-XMVECTOR BDistIsLess = XMVectorGreaterR(&BDistIsLessCR, Zero, BDist);
-
-uint32_t BDistIsGreaterCR;
-XMVECTOR BDistIsGreater = XMVectorGreaterR(&BDistIsGreaterCR, BDist, Zero);
-
-// If all the points are on the same side we don't intersect.
-if (XMComparisonAllTrue(BDistIsLessCR) || XMComparisonAllTrue(BDistIsGreaterCR))
-return false;
-
-// Compute the normal of triangle B.
-XMVECTOR N2 = XMVector3Cross(XMVectorSubtract(B1, B0), XMVectorSubtract(B2, B0));
-
-// Assert that the triangle is not degenerate.
-assert(!XMVector3Equal(N2, Zero));
-
-// Test points of A against the plane of B.
-XMVECTOR ADist = XMVector3Dot(N2, XMVectorSubtract(A0, B0));
-ADist = XMVectorSelect(ADist, XMVector3Dot(N2, XMVectorSubtract(A1, B0)), SelectY);
-ADist = XMVectorSelect(ADist, XMVector3Dot(N2, XMVectorSubtract(A2, B0)), SelectZ);
-
-// Ensure robustness with co-planar triangles by zeroing small distances.
-uint32_t ADistIsZeroCR;
-XMVECTOR ADistIsZero = XMVectorGreaterR(&ADistIsZeroCR, g_RayEpsilon, XMVectorAbs(BDist));
-ADist = XMVectorSelect(ADist, Zero, ADistIsZero);
-
-uint32_t ADistIsLessCR;
-XMVECTOR ADistIsLess = XMVectorGreaterR(&ADistIsLessCR, Zero, ADist);
-
-uint32_t ADistIsGreaterCR;
-XMVECTOR ADistIsGreater = XMVectorGreaterR(&ADistIsGreaterCR, ADist, Zero);
-
-// If all the points are on the same side we don't intersect.
-if (XMComparisonAllTrue(ADistIsLessCR) || XMComparisonAllTrue(ADistIsGreaterCR))
-return false;
-
-// Special case for co-planar triangles.
-if (XMComparisonAllTrue(ADistIsZeroCR) || XMComparisonAllTrue(BDistIsZeroCR))
-{
-XMVECTOR Axis, Dist, MinDist;
-
-// Compute an axis perpindicular to the edge (points out).
-Axis = XMVector3Cross(N1, XMVectorSubtract(A1, A0));
-Dist = XMVector3Dot(Axis, A0);
-
-// Test points of B against the axis.
-MinDist = XMVector3Dot(B0, Axis);
-MinDist = XMVectorMin(MinDist, XMVector3Dot(B1, Axis));
-MinDist = XMVectorMin(MinDist, XMVector3Dot(B2, Axis));
-if (XMVector4GreaterOrEqual(MinDist, Dist))
-return false;
-
-// Edge (A1, A2)
-Axis = XMVector3Cross(N1, XMVectorSubtract(A2, A1));
-Dist = XMVector3Dot(Axis, A1);
-
-MinDist = XMVector3Dot(B0, Axis);
-MinDist = XMVectorMin(MinDist, XMVector3Dot(B1, Axis));
-MinDist = XMVectorMin(MinDist, XMVector3Dot(B2, Axis));
-if (XMVector4GreaterOrEqual(MinDist, Dist))
-return false;
-
-// Edge (A2, A0)
-Axis = XMVector3Cross(N1, XMVectorSubtract(A0, A2));
-Dist = XMVector3Dot(Axis, A2);
-
-MinDist = XMVector3Dot(B0, Axis);
-MinDist = XMVectorMin(MinDist, XMVector3Dot(B1, Axis));
-MinDist = XMVectorMin(MinDist, XMVector3Dot(B2, Axis));
-if (XMVector4GreaterOrEqual(MinDist, Dist))
-return false;
-
-// Edge (B0, B1)
-Axis = XMVector3Cross(N2, XMVectorSubtract(B1, B0));
-Dist = XMVector3Dot(Axis, B0);
-
-MinDist = XMVector3Dot(A0, Axis);
-MinDist = XMVectorMin(MinDist, XMVector3Dot(A1, Axis));
-MinDist = XMVectorMin(MinDist, XMVector3Dot(A2, Axis));
-if (XMVector4GreaterOrEqual(MinDist, Dist))
-return false;
-
-// Edge (B1, B2)
-Axis = XMVector3Cross(N2, XMVectorSubtract(B2, B1));
-Dist = XMVector3Dot(Axis, B1);
-
-MinDist = XMVector3Dot(A0, Axis);
-MinDist = XMVectorMin(MinDist, XMVector3Dot(A1, Axis));
-MinDist = XMVectorMin(MinDist, XMVector3Dot(A2, Axis));
-if (XMVector4GreaterOrEqual(MinDist, Dist))
-return false;
-
-// Edge (B2,B0)
-Axis = XMVector3Cross(N2, XMVectorSubtract(B0, B2));
-Dist = XMVector3Dot(Axis, B2);
-
-MinDist = XMVector3Dot(A0, Axis);
-MinDist = XMVectorMin(MinDist, XMVector3Dot(A1, Axis));
-MinDist = XMVectorMin(MinDist, XMVector3Dot(A2, Axis));
-if (XMVector4GreaterOrEqual(MinDist, Dist))
-return false;
-
-return true;
-}
-
-//
-// Find the single vertex of A and B (ie the vertex on the opposite side
-// of the plane from the other two) and reorder the edges so we can compute
-// the signed edge/edge distances.
-//
-// if ( (V0 >= 0 && V1 <  0 && V2 <  0) ||
-//      (V0 >  0 && V1 <= 0 && V2 <= 0) ||
-//      (V0 <= 0 && V1 >  0 && V2 >  0) ||
-//      (V0 <  0 && V1 >= 0 && V2 >= 0) ) then V0 is singular;
-//
-// If our singular vertex is not on the positive side of the plane we reverse
-// the triangle winding so that the overlap comparisons will compare the
-// correct edges with the correct signs.
-//
-XMVECTOR ADistIsLessEqual = XMVectorOrInt(ADistIsLess, ADistIsZero);
-XMVECTOR ADistIsGreaterEqual = XMVectorOrInt(ADistIsGreater, ADistIsZero);
-
-XMVECTOR AA0, AA1, AA2;
-bool bPositiveA;
-
-if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsGreaterEqual, ADistIsLess, Select0111)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsGreater, ADistIsLessEqual, Select0111)))
-{
-// A0 is singular, crossing from positive to negative.
-AA0 = A0; AA1 = A1; AA2 = A2;
-bPositiveA = true;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsLessEqual, ADistIsGreater, Select0111)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsLess, ADistIsGreaterEqual, Select0111)))
-{
-// A0 is singular, crossing from negative to positive.
-AA0 = A0; AA1 = A2; AA2 = A1;
-bPositiveA = false;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsGreaterEqual, ADistIsLess, Select1011)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsGreater, ADistIsLessEqual, Select1011)))
-{
-// A1 is singular, crossing from positive to negative.
-AA0 = A1; AA1 = A2; AA2 = A0;
-bPositiveA = true;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsLessEqual, ADistIsGreater, Select1011)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsLess, ADistIsGreaterEqual, Select1011)))
-{
-// A1 is singular, crossing from negative to positive.
-AA0 = A1; AA1 = A0; AA2 = A2;
-bPositiveA = false;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsGreaterEqual, ADistIsLess, Select1101)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsGreater, ADistIsLessEqual, Select1101)))
-{
-// A2 is singular, crossing from positive to negative.
-AA0 = A2; AA1 = A0; AA2 = A1;
-bPositiveA = true;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsLessEqual, ADistIsGreater, Select1101)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(ADistIsLess, ADistIsGreaterEqual, Select1101)))
-{
-// A2 is singular, crossing from negative to positive.
-AA0 = A2; AA1 = A1; AA2 = A0;
-bPositiveA = false;
-}
-else
-{
-assert(false);
-return false;
-}
-
-XMVECTOR BDistIsLessEqual = XMVectorOrInt(BDistIsLess, BDistIsZero);
-XMVECTOR BDistIsGreaterEqual = XMVectorOrInt(BDistIsGreater, BDistIsZero);
-
-XMVECTOR BB0, BB1, BB2;
-bool bPositiveB;
-
-if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsGreaterEqual, BDistIsLess, Select0111)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsGreater, BDistIsLessEqual, Select0111)))
-{
-// B0 is singular, crossing from positive to negative.
-BB0 = B0; BB1 = B1; BB2 = B2;
-bPositiveB = true;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsLessEqual, BDistIsGreater, Select0111)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsLess, BDistIsGreaterEqual, Select0111)))
-{
-// B0 is singular, crossing from negative to positive.
-BB0 = B0; BB1 = B2; BB2 = B1;
-bPositiveB = false;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsGreaterEqual, BDistIsLess, Select1011)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsGreater, BDistIsLessEqual, Select1011)))
-{
-// B1 is singular, crossing from positive to negative.
-BB0 = B1; BB1 = B2; BB2 = B0;
-bPositiveB = true;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsLessEqual, BDistIsGreater, Select1011)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsLess, BDistIsGreaterEqual, Select1011)))
-{
-// B1 is singular, crossing from negative to positive.
-BB0 = B1; BB1 = B0; BB2 = B2;
-bPositiveB = false;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsGreaterEqual, BDistIsLess, Select1101)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsGreater, BDistIsLessEqual, Select1101)))
-{
-// B2 is singular, crossing from positive to negative.
-BB0 = B2; BB1 = B0; BB2 = B1;
-bPositiveB = true;
-}
-else if (DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsLessEqual, BDistIsGreater, Select1101)) ||
-DirectX::Internal::XMVector3AllTrue(XMVectorSelect(BDistIsLess, BDistIsGreaterEqual, Select1101)))
-{
-// B2 is singular, crossing from negative to positive.
-BB0 = B2; BB1 = B1; BB2 = B0;
-bPositiveB = false;
-}
-else
-{
-assert(false);
-return false;
-}
-
-XMVECTOR Delta0, Delta1;
-
-// Reverse the direction of the test depending on whether the singular vertices are
-// the same sign or different signs.
-if (bPositiveA ^ bPositiveB)
-{
-Delta0 = XMVectorSubtract(BB0, AA0);
-Delta1 = XMVectorSubtract(AA0, BB0);
-}
-else
-{
-Delta0 = XMVectorSubtract(AA0, BB0);
-Delta1 = XMVectorSubtract(BB0, AA0);
-}
-
-// Check if the triangles overlap on the line of intersection between the
-// planes of the two triangles by finding the signed line distances.
-XMVECTOR Dist0 = XMVector3Dot(Delta0, XMVector3Cross(XMVectorSubtract(BB2, BB0), XMVectorSubtract(AA2, AA0)));
-if (XMVector4Greater(Dist0, Zero))
-return false;
-
-XMVECTOR Dist1 = XMVector3Dot(Delta1, XMVector3Cross(XMVectorSubtract(BB1, BB0), XMVectorSubtract(AA1, AA0)));
-if (XMVector4Greater(Dist1, Zero))
-return false;
-
-return true;
-}
-
-
-//-----------------------------------------------------------------------------
-// Ray-triangle test
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline PlaneIntersectionType XM_CALLCONV Intersects(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2, GXMVECTOR Plane) noexcept
-{
-XMVECTOR One = XMVectorSplatOne();
-
-assert(DirectX::Internal::XMPlaneIsUnit(Plane));
-
-// Set w of the points to one so we can dot4 with a plane.
-XMVECTOR TV0 = XMVectorInsert<0, 0, 0, 0, 1>(V0, One);
-XMVECTOR TV1 = XMVectorInsert<0, 0, 0, 0, 1>(V1, One);
-XMVECTOR TV2 = XMVectorInsert<0, 0, 0, 0, 1>(V2, One);
-
-XMVECTOR Outside, Inside;
-DirectX::Internal::FastIntersectTrianglePlane(TV0, TV1, TV2, Plane, Outside, Inside);
-
-// If the triangle is outside any plane it is outside.
-if (XMVector4EqualInt(Outside, XMVectorTrueInt()))
-return FRONT;
-
-// If the triangle is inside all planes it is inside.
-if (XMVector4EqualInt(Inside, XMVectorTrueInt()))
-return BACK;
-
-// The triangle is not inside all planes or outside a plane it intersects.
-return INTERSECTING;
-}
-
-
-//-----------------------------------------------------------------------------
-// Test a triangle vs 6 planes (typically forming a frustum).
-//-----------------------------------------------------------------------------
-_Use_decl_annotations_
-inline ContainmentType XM_CALLCONV ContainedBy(
-        FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2,
-GXMVECTOR Plane0,
-        HXMVECTOR Plane1, HXMVECTOR Plane2,
-        CXMVECTOR Plane3, CXMVECTOR Plane4, CXMVECTOR Plane5) noexcept
-{
-XMVECTOR One = XMVectorSplatOne();
-
-// Set w of the points to one so we can dot4 with a plane.
-XMVECTOR TV0 = XMVectorInsert<0, 0, 0, 0, 1>(V0, One);
-XMVECTOR TV1 = XMVectorInsert<0, 0, 0, 0, 1>(V1, One);
-XMVECTOR TV2 = XMVectorInsert<0, 0, 0, 0, 1>(V2, One);
-
-XMVECTOR Outside, Inside;
-
-// Test against each plane.
-DirectX::Internal::FastIntersectTrianglePlane(TV0, TV1, TV2, Plane0, Outside, Inside);
-
-XMVECTOR AnyOutside = Outside;
-XMVECTOR AllInside = Inside;
-
-DirectX::Internal::FastIntersectTrianglePlane(TV0, TV1, TV2, Plane1, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectTrianglePlane(TV0, TV1, TV2, Plane2, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectTrianglePlane(TV0, TV1, TV2, Plane3, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectTrianglePlane(TV0, TV1, TV2, Plane4, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-DirectX::Internal::FastIntersectTrianglePlane(TV0, TV1, TV2, Plane5, Outside, Inside);
-AnyOutside = XMVectorOrInt(AnyOutside, Outside);
-AllInside = XMVectorAndInt(AllInside, Inside);
-
-// If the triangle is outside any plane it is outside.
-if (XMVector4EqualInt(AnyOutside, XMVectorTrueInt()))
-return DISJOINT;
-
-// If the triangle is inside all planes it is inside.
-if (XMVector4EqualInt(AllInside, XMVectorTrueInt()))
-return CONTAINS;
-
-// The triangle is not inside all planes or outside a plane, it may intersect.
-return INTERSECTS;
-}
-
-} // namespace TriangleTests
-
diff --git a/thirdparty/directxmath/DirectXColors.h b/thirdparty/directxmath/DirectXColors.h
deleted file mode 100644
index df1efeb..0000000
--- a/thirdparty/directxmath/DirectXColors.h
+++ /dev/null
@@ -1,312 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXColors.h -- C++ Color Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-#include "./DirectXMath.h"
-
-namespace DirectX
-{
-
-    namespace Colors
-    {
-        // Standard colors (Red/Green/Blue/Alpha) in sRGB colorspace
-        XMGLOBALCONST XMVECTORF32 AliceBlue = { { { 0.941176534f, 0.972549081f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 AntiqueWhite = { { { 0.980392218f, 0.921568692f, 0.843137324f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Aqua = { { { 0.f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Aquamarine = { { { 0.498039246f, 1.f, 0.831372619f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Azure = { { { 0.941176534f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Beige = { { { 0.960784376f, 0.960784376f, 0.862745166f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Bisque = { { { 1.f, 0.894117713f, 0.768627524f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Black = { { { 0.f, 0.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 BlanchedAlmond = { { { 1.f, 0.921568692f, 0.803921640f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Blue = { { { 0.f, 0.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 BlueViolet = { { { 0.541176498f, 0.168627456f, 0.886274576f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Brown = { { { 0.647058845f, 0.164705887f, 0.164705887f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 BurlyWood = { { { 0.870588303f, 0.721568644f, 0.529411793f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 CadetBlue = { { { 0.372549027f, 0.619607866f, 0.627451003f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Chartreuse = { { { 0.498039246f, 1.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Chocolate = { { { 0.823529482f, 0.411764741f, 0.117647067f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Coral = { { { 1.f, 0.498039246f, 0.313725501f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 CornflowerBlue = { { { 0.392156899f, 0.584313750f, 0.929411829f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Cornsilk = { { { 1.f, 0.972549081f, 0.862745166f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Crimson = { { { 0.862745166f, 0.078431375f, 0.235294133f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Cyan = { { { 0.f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkBlue = { { { 0.f, 0.f, 0.545098066f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkCyan = { { { 0.f, 0.545098066f, 0.545098066f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkGoldenrod = { { { 0.721568644f, 0.525490224f, 0.043137256f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkGray = { { { 0.662745118f, 0.662745118f, 0.662745118f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkGreen = { { { 0.f, 0.392156899f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkKhaki = { { { 0.741176486f, 0.717647076f, 0.419607878f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkMagenta = { { { 0.545098066f, 0.f, 0.545098066f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkOliveGreen = { { { 0.333333343f, 0.419607878f, 0.184313729f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkOrange = { { { 1.f, 0.549019635f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkOrchid = { { { 0.600000024f, 0.196078449f, 0.800000072f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkRed = { { { 0.545098066f, 0.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkSalmon = { { { 0.913725555f, 0.588235319f, 0.478431404f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkSeaGreen = { { { 0.560784340f, 0.737254918f, 0.545098066f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkSlateBlue = { { { 0.282352954f, 0.239215702f, 0.545098066f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkSlateGray = { { { 0.184313729f, 0.309803933f, 0.309803933f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkTurquoise = { { { 0.f, 0.807843208f, 0.819607913f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkViolet = { { { 0.580392182f, 0.f, 0.827451050f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DeepPink = { { { 1.f, 0.078431375f, 0.576470613f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DeepSkyBlue = { { { 0.f, 0.749019623f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DimGray = { { { 0.411764741f, 0.411764741f, 0.411764741f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DodgerBlue = { { { 0.117647067f, 0.564705908f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Firebrick = { { { 0.698039234f, 0.133333340f, 0.133333340f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 FloralWhite = { { { 1.f, 0.980392218f, 0.941176534f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 ForestGreen = { { { 0.133333340f, 0.545098066f, 0.133333340f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Fuchsia = { { { 1.f, 0.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Gainsboro = { { { 0.862745166f, 0.862745166f, 0.862745166f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 GhostWhite = { { { 0.972549081f, 0.972549081f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Gold = { { { 1.f, 0.843137324f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Goldenrod = { { { 0.854902029f, 0.647058845f, 0.125490203f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Gray = { { { 0.501960814f, 0.501960814f, 0.501960814f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Green = { { { 0.f, 0.501960814f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 GreenYellow = { { { 0.678431392f, 1.f, 0.184313729f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Honeydew = { { { 0.941176534f, 1.f, 0.941176534f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 HotPink = { { { 1.f, 0.411764741f, 0.705882370f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 IndianRed = { { { 0.803921640f, 0.360784322f, 0.360784322f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Indigo = { { { 0.294117659f, 0.f, 0.509803951f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Ivory = { { { 1.f, 1.f, 0.941176534f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Khaki = { { { 0.941176534f, 0.901960850f, 0.549019635f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Lavender = { { { 0.901960850f, 0.901960850f, 0.980392218f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LavenderBlush = { { { 1.f, 0.941176534f, 0.960784376f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LawnGreen = { { { 0.486274540f, 0.988235354f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LemonChiffon = { { { 1.f, 0.980392218f, 0.803921640f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightBlue = { { { 0.678431392f, 0.847058892f, 0.901960850f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightCoral = { { { 0.941176534f, 0.501960814f, 0.501960814f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightCyan = { { { 0.878431439f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightGoldenrodYellow = { { { 0.980392218f, 0.980392218f, 0.823529482f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightGray = { { { 0.827451050f, 0.827451050f, 0.827451050f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightGreen = { { { 0.564705908f, 0.933333397f, 0.564705908f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightPink = { { { 1.f, 0.713725507f, 0.756862819f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSalmon = { { { 1.f, 0.627451003f, 0.478431404f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSeaGreen = { { { 0.125490203f, 0.698039234f, 0.666666687f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSkyBlue = { { { 0.529411793f, 0.807843208f, 0.980392218f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSlateGray = { { { 0.466666698f, 0.533333361f, 0.600000024f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSteelBlue = { { { 0.690196097f, 0.768627524f, 0.870588303f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightYellow = { { { 1.f, 1.f, 0.878431439f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Lime = { { { 0.f, 1.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LimeGreen = { { { 0.196078449f, 0.803921640f, 0.196078449f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Linen = { { { 0.980392218f, 0.941176534f, 0.901960850f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Magenta = { { { 1.f, 0.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Maroon = { { { 0.501960814f, 0.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumAquamarine = { { { 0.400000036f, 0.803921640f, 0.666666687f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumBlue = { { { 0.f, 0.f, 0.803921640f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumOrchid = { { { 0.729411781f, 0.333333343f, 0.827451050f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumPurple = { { { 0.576470613f, 0.439215720f, 0.858823597f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumSeaGreen = { { { 0.235294133f, 0.701960802f, 0.443137288f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumSlateBlue = { { { 0.482352972f, 0.407843173f, 0.933333397f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumSpringGreen = { { { 0.f, 0.980392218f, 0.603921592f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumTurquoise = { { { 0.282352954f, 0.819607913f, 0.800000072f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumVioletRed = { { { 0.780392230f, 0.082352944f, 0.521568656f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MidnightBlue = { { { 0.098039225f, 0.098039225f, 0.439215720f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MintCream = { { { 0.960784376f, 1.f, 0.980392218f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MistyRose = { { { 1.f, 0.894117713f, 0.882353008f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Moccasin = { { { 1.f, 0.894117713f, 0.709803939f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 NavajoWhite = { { { 1.f, 0.870588303f, 0.678431392f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Navy = { { { 0.f, 0.f, 0.501960814f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 OldLace = { { { 0.992156923f, 0.960784376f, 0.901960850f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Olive = { { { 0.501960814f, 0.501960814f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 OliveDrab = { { { 0.419607878f, 0.556862772f, 0.137254909f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Orange = { { { 1.f, 0.647058845f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 OrangeRed = { { { 1.f, 0.270588249f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Orchid = { { { 0.854902029f, 0.439215720f, 0.839215755f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PaleGoldenrod = { { { 0.933333397f, 0.909803987f, 0.666666687f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PaleGreen = { { { 0.596078455f, 0.984313786f, 0.596078455f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PaleTurquoise = { { { 0.686274529f, 0.933333397f, 0.933333397f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PaleVioletRed = { { { 0.858823597f, 0.439215720f, 0.576470613f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PapayaWhip = { { { 1.f, 0.937254965f, 0.835294187f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PeachPuff = { { { 1.f, 0.854902029f, 0.725490212f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Peru = { { { 0.803921640f, 0.521568656f, 0.247058839f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Pink = { { { 1.f, 0.752941251f, 0.796078503f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Plum = { { { 0.866666734f, 0.627451003f, 0.866666734f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PowderBlue = { { { 0.690196097f, 0.878431439f, 0.901960850f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Purple = { { { 0.501960814f, 0.f, 0.501960814f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Red = { { { 1.f, 0.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 RosyBrown = { { { 0.737254918f, 0.560784340f, 0.560784340f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 RoyalBlue = { { { 0.254901975f, 0.411764741f, 0.882353008f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SaddleBrown = { { { 0.545098066f, 0.270588249f, 0.074509807f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Salmon = { { { 0.980392218f, 0.501960814f, 0.447058856f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SandyBrown = { { { 0.956862807f, 0.643137276f, 0.376470625f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SeaGreen = { { { 0.180392161f, 0.545098066f, 0.341176480f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SeaShell = { { { 1.f, 0.960784376f, 0.933333397f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Sienna = { { { 0.627451003f, 0.321568638f, 0.176470593f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Silver = { { { 0.752941251f, 0.752941251f, 0.752941251f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SkyBlue = { { { 0.529411793f, 0.807843208f, 0.921568692f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SlateBlue = { { { 0.415686309f, 0.352941185f, 0.803921640f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SlateGray = { { { 0.439215720f, 0.501960814f, 0.564705908f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Snow = { { { 1.f, 0.980392218f, 0.980392218f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SpringGreen = { { { 0.f, 1.f, 0.498039246f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SteelBlue = { { { 0.274509817f, 0.509803951f, 0.705882370f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Tan = { { { 0.823529482f, 0.705882370f, 0.549019635f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Teal = { { { 0.f, 0.501960814f, 0.501960814f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Thistle = { { { 0.847058892f, 0.749019623f, 0.847058892f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Tomato = { { { 1.f, 0.388235331f, 0.278431386f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Transparent = { { { 0.f, 0.f, 0.f, 0.f } } };
-        XMGLOBALCONST XMVECTORF32 Turquoise = { { { 0.250980407f, 0.878431439f, 0.815686345f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Violet = { { { 0.933333397f, 0.509803951f, 0.933333397f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Wheat = { { { 0.960784376f, 0.870588303f, 0.701960802f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 White = { { { 1.f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 WhiteSmoke = { { { 0.960784376f, 0.960784376f, 0.960784376f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Yellow = { { { 1.f, 1.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 YellowGreen = { { { 0.603921592f, 0.803921640f, 0.196078449f, 1.f } } };
-
-    } // namespace Colors
-
-    namespace ColorsLinear
-    {
-        // Standard colors (Red/Green/Blue/Alpha) in linear colorspace
-        XMGLOBALCONST XMVECTORF32 AliceBlue = { { { 0.871367335f, 0.938685894f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 AntiqueWhite = { { { 0.955973506f, 0.830770075f, 0.679542601f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Aqua = { { { 0.f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Aquamarine = { { { 0.212230787f, 1.f, 0.658374965f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Azure = { { { 0.871367335f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Beige = { { { 0.913098991f, 0.913098991f, 0.715693772f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Bisque = { { { 1.f, 0.775822461f, 0.552011609f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Black = { { { 0.f, 0.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 BlanchedAlmond = { { { 1.f, 0.830770075f, 0.610495746f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Blue = { { { 0.f, 0.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 BlueViolet = { { { 0.254152179f, 0.024157630f, 0.760524750f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Brown = { { { 0.376262218f, 0.023153365f, 0.023153365f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 BurlyWood = { { { 0.730461001f, 0.479320228f, 0.242281199f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 CadetBlue = { { { 0.114435382f, 0.341914445f, 0.351532698f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Chartreuse = { { { 0.212230787f, 1.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Chocolate = { { { 0.644479871f, 0.141263321f, 0.012983031f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Coral = { { { 1.f, 0.212230787f, 0.080219828f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 CornflowerBlue = { { { 0.127437726f, 0.300543845f, 0.846873462f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Cornsilk = { { { 1.f, 0.938685894f, 0.715693772f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Crimson = { { { 0.715693772f, 0.006995410f, 0.045186214f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Cyan = { { { 0.f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkBlue = { { { 0.f, 0.f, 0.258182913f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkCyan = { { { 0.f, 0.258182913f, 0.258182913f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkGoldenrod = { { { 0.479320228f, 0.238397658f, 0.003346536f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkGray = { { { 0.396755308f, 0.396755308f, 0.396755308f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkGreen = { { { 0.f, 0.127437726f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkKhaki = { { { 0.508881450f, 0.473531544f, 0.147027299f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkMagenta = { { { 0.258182913f, 0.f, 0.258182913f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkOliveGreen = { { { 0.090841733f, 0.147027299f, 0.028426038f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkOrange = { { { 1.f, 0.262250721f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkOrchid = { { { 0.318546832f, 0.031896040f, 0.603827536f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkRed = { { { 0.258182913f, 0.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkSalmon = { { { 0.814846814f, 0.304987371f, 0.194617867f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkSeaGreen = { { { 0.274677366f, 0.502886593f, 0.258182913f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkSlateBlue = { { { 0.064803280f, 0.046665095f, 0.258182913f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkSlateGray = { { { 0.028426038f, 0.078187428f, 0.078187428f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkTurquoise = { { { 0.f, 0.617206752f, 0.637597024f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DarkViolet = { { { 0.296138316f, 0.f, 0.651405811f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DeepPink = { { { 1.f, 0.006995410f, 0.291770697f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DeepSkyBlue = { { { 0.f, 0.520995677f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DimGray = { { { 0.141263321f, 0.141263321f, 0.141263321f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 DodgerBlue = { { { 0.012983031f, 0.278894335f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Firebrick = { { { 0.445201248f, 0.015996292f, 0.015996292f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 FloralWhite = { { { 1.f, 0.955973506f, 0.871367335f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 ForestGreen = { { { 0.015996292f, 0.258182913f, 0.015996292f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Fuchsia = { { { 1.f, 0.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Gainsboro = { { { 0.715693772f, 0.715693772f, 0.715693772f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 GhostWhite = { { { 0.938685894f, 0.938685894f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Gold = { { { 1.f, 0.679542601f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Goldenrod = { { { 0.701102138f, 0.376262218f, 0.014443844f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Gray = { { { 0.215860531f, 0.215860531f, 0.215860531f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Green = { { { 0.f, 0.215860531f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 GreenYellow = { { { 0.417885154f, 1.f, 0.028426038f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Honeydew = { { { 0.871367335f, 1.f, 0.871367335f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 HotPink = { { { 1.f, 0.141263321f, 0.456411064f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 IndianRed = { { { 0.610495746f, 0.107023112f, 0.107023112f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Indigo = { { { 0.070360109f, 0.f, 0.223227978f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Ivory = { { { 1.f, 1.f, 0.871367335f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Khaki = { { { 0.871367335f, 0.791298151f, 0.262250721f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Lavender = { { { 0.791298151f, 0.791298151f, 0.955973506f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LavenderBlush = { { { 1.f, 0.871367335f, 0.913098991f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LawnGreen = { { { 0.201556295f, 0.973445475f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LemonChiffon = { { { 1.f, 0.955973506f, 0.610495746f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightBlue = { { { 0.417885154f, 0.686685443f, 0.791298151f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightCoral = { { { 0.871367335f, 0.215860531f, 0.215860531f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightCyan = { { { 0.745404482f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightGoldenrodYellow = { { { 0.955973506f, 0.955973506f, 0.644479871f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightGray = { { { 0.651405811f, 0.651405811f, 0.651405811f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightGreen = { { { 0.278894335f, 0.854992807f, 0.278894335f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightPink = { { { 1.f, 0.467783839f, 0.533276618f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSalmon = { { { 1.f, 0.351532698f, 0.194617867f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSeaGreen = { { { 0.014443844f, 0.445201248f, 0.401977867f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSkyBlue = { { { 0.242281199f, 0.617206752f, 0.955973506f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSlateGray = { { { 0.184475034f, 0.246201396f, 0.318546832f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightSteelBlue = { { { 0.434153706f, 0.552011609f, 0.730461001f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LightYellow = { { { 1.f, 1.f, 0.745404482f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Lime = { { { 0.f, 1.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 LimeGreen = { { { 0.031896040f, 0.610495746f, 0.031896040f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Linen = { { { 0.955973506f, 0.871367335f, 0.791298151f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Magenta = { { { 1.f, 0.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Maroon = { { { 0.215860531f, 0.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumAquamarine = { { { 0.132868364f, 0.610495746f, 0.401977867f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumBlue = { { { 0.f, 0.f, 0.610495746f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumOrchid = { { { 0.491020888f, 0.090841733f, 0.651405811f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumPurple = { { { 0.291770697f, 0.162029430f, 0.708376050f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumSeaGreen = { { { 0.045186214f, 0.450785846f, 0.165132239f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumSlateBlue = { { { 0.198069349f, 0.138431653f, 0.854992807f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumSpringGreen = { { { 0.f, 0.955973506f, 0.323143244f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumTurquoise = { { { 0.064803280f, 0.637597024f, 0.603827536f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MediumVioletRed = { { { 0.571125031f, 0.007499032f, 0.234550655f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MidnightBlue = { { { 0.009721218f, 0.009721218f, 0.162029430f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MintCream = { { { 0.913098991f, 1.f, 0.955973506f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 MistyRose = { { { 1.f, 0.775822461f, 0.752942443f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Moccasin = { { { 1.f, 0.775822461f, 0.462077051f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 NavajoWhite = { { { 1.f, 0.730461001f, 0.417885154f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Navy = { { { 0.f, 0.f, 0.215860531f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 OldLace = { { { 0.982250869f, 0.913098991f, 0.791298151f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Olive = { { { 0.215860531f, 0.215860531f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 OliveDrab = { { { 0.147027299f, 0.270497859f, 0.016807375f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Orange = { { { 1.f, 0.376262218f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 OrangeRed = { { { 1.f, 0.059511241f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Orchid = { { { 0.701102138f, 0.162029430f, 0.672443330f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PaleGoldenrod = { { { 0.854992807f, 0.806952477f, 0.401977867f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PaleGreen = { { { 0.313988745f, 0.964686573f, 0.313988745f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PaleTurquoise = { { { 0.428690553f, 0.854992807f, 0.854992807f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PaleVioletRed = { { { 0.708376050f, 0.162029430f, 0.291770697f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PapayaWhip = { { { 1.f, 0.863157392f, 0.665387452f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PeachPuff = { { { 1.f, 0.701102138f, 0.485149980f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Peru = { { { 0.610495746f, 0.234550655f, 0.049706575f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Pink = { { { 1.f, 0.527115345f, 0.597202003f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Plum = { { { 0.723055363f, 0.351532698f, 0.723055363f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 PowderBlue = { { { 0.434153706f, 0.745404482f, 0.791298151f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Purple = { { { 0.215860531f, 0.f, 0.215860531f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Red = { { { 1.f, 0.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 RosyBrown = { { { 0.502886593f, 0.274677366f, 0.274677366f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 RoyalBlue = { { { 0.052860655f, 0.141263321f, 0.752942443f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SaddleBrown = { { { 0.258182913f, 0.059511241f, 0.006512091f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Salmon = { { { 0.955973506f, 0.215860531f, 0.168269455f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SandyBrown = { { { 0.904661357f, 0.371237785f, 0.116970696f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SeaGreen = { { { 0.027320892f, 0.258182913f, 0.095307484f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SeaShell = { { { 1.f, 0.913098991f, 0.854992807f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Sienna = { { { 0.351532698f, 0.084376216f, 0.026241222f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Silver = { { { 0.527115345f, 0.527115345f, 0.527115345f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SkyBlue = { { { 0.242281199f, 0.617206752f, 0.830770075f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SlateBlue = { { { 0.144128501f, 0.102241747f, 0.610495746f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SlateGray = { { { 0.162029430f, 0.215860531f, 0.278894335f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Snow = { { { 1.f, 0.955973506f, 0.955973506f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SpringGreen = { { { 0.f, 1.f, 0.212230787f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 SteelBlue = { { { 0.061246071f, 0.223227978f, 0.456411064f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Tan = { { { 0.644479871f, 0.456411064f, 0.262250721f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Teal = { { { 0.f, 0.215860531f, 0.215860531f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Thistle = { { { 0.686685443f, 0.520995677f, 0.686685443f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Tomato = { { { 1.f, 0.124771863f, 0.063010029f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Transparent = { { { 0.f, 0.f, 0.f, 0.f } } };
-        XMGLOBALCONST XMVECTORF32 Turquoise = { { { 0.051269468f, 0.745404482f, 0.630757332f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Violet = { { { 0.854992807f, 0.223227978f, 0.854992807f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Wheat = { { { 0.913098991f, 0.730461001f, 0.450785846f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 White = { { { 1.f, 1.f, 1.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 WhiteSmoke = { { { 0.913098991f, 0.913098991f, 0.913098991f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 Yellow = { { { 1.f, 1.f, 0.f, 1.f } } };
-        XMGLOBALCONST XMVECTORF32 YellowGreen = { { { 0.323143244f, 0.610495746f, 0.031896040f, 1.f } } };
-
-    } // namespace ColorsLinear
-
-} // namespace DirectX
-
diff --git a/thirdparty/directxmath/DirectXMath.h b/thirdparty/directxmath/DirectXMath.h
deleted file mode 100644
index ddfe12a..0000000
--- a/thirdparty/directxmath/DirectXMath.h
+++ /dev/null
@@ -1,2280 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXMath.h -- SIMD C++ Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-#ifndef __cplusplus
-#error DirectX Math requires C++
-#endif
-
-#define DIRECTX_MATH_VERSION 317
-
-#if defined(_MSC_VER) && (_MSC_VER < 1910)
-#error DirectX Math requires Visual C++ 2017 or later.
-#endif
-
-#if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) && !defined(_M_HYBRID_X86_ARM64) && !defined(_M_ARM64EC) && (!_MANAGED) && (!_M_CEE) && (!defined(_M_IX86_FP) || (_M_IX86_FP > 1)) && !defined(_XM_NO_INTRINSICS_) && !defined(_XM_VECTORCALL_)
-#define _XM_VECTORCALL_ 1
-#endif
-
-#if _XM_VECTORCALL_
-#define XM_CALLCONV __vectorcall
-#elif defined(__GNUC__)
-#define XM_CALLCONV
-#else
-#define XM_CALLCONV __fastcall
-#endif
-
-#ifndef XM_DEPRECATED
-#ifdef __GNUC__
-#define XM_DEPRECATED __attribute__ ((deprecated))
-#else
-#define XM_DEPRECATED __declspec(deprecated("This is deprecated and will be removed in a future version."))
-#endif
-#endif
-
-#if !defined(_XM_AVX2_INTRINSICS_) && defined(__AVX2__) && !defined(_XM_NO_INTRINSICS_)
-#define _XM_AVX2_INTRINSICS_
-#endif
-
-#if !defined(_XM_FMA3_INTRINSICS_) && defined(_XM_AVX2_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-#define _XM_FMA3_INTRINSICS_
-#endif
-
-#if !defined(_XM_F16C_INTRINSICS_) && defined(_XM_AVX2_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-#define _XM_F16C_INTRINSICS_
-#endif
-
-#if !defined(_XM_F16C_INTRINSICS_) && defined(__F16C__) && !defined(_XM_NO_INTRINSICS_)
-#define _XM_F16C_INTRINSICS_
-#endif
-
-#if defined(_XM_FMA3_INTRINSICS_) && !defined(_XM_AVX_INTRINSICS_)
-#define _XM_AVX_INTRINSICS_
-#endif
-
-#if defined(_XM_F16C_INTRINSICS_) && !defined(_XM_AVX_INTRINSICS_)
-#define _XM_AVX_INTRINSICS_
-#endif
-
-#if !defined(_XM_AVX_INTRINSICS_) && defined(__AVX__) && !defined(_XM_NO_INTRINSICS_)
-#define _XM_AVX_INTRINSICS_
-#endif
-
-#if defined(_XM_AVX_INTRINSICS_) && !defined(_XM_SSE4_INTRINSICS_)
-#define _XM_SSE4_INTRINSICS_
-#endif
-
-#if defined(_XM_SSE4_INTRINSICS_) && !defined(_XM_SSE3_INTRINSICS_)
-#define _XM_SSE3_INTRINSICS_
-#endif
-
-#if defined(_XM_SSE3_INTRINSICS_) && !defined(_XM_SSE_INTRINSICS_)
-#define _XM_SSE_INTRINSICS_
-#endif
-
-#if !defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-#if (defined(_M_IX86) || defined(_M_X64) || __i386__ || __x86_64__) && !defined(_M_HYBRID_X86_ARM64) && !defined(_M_ARM64EC)
-#define _XM_SSE_INTRINSICS_
-#elif defined(_M_ARM) || defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __arm__ || __aarch64__
-#define _XM_ARM_NEON_INTRINSICS_
-#elif !defined(_XM_NO_INTRINSICS_)
-#error DirectX Math does not support this target
-#endif
-#endif // !_XM_ARM_NEON_INTRINSICS_ && !_XM_SSE_INTRINSICS_ && !_XM_NO_INTRINSICS_
-
-#if defined(_XM_SSE_INTRINSICS_) && defined(_MSC_VER) && (_MSC_VER >= 1920) && !defined(__clang__) && !defined(_XM_SVML_INTRINSICS_) && !defined(_XM_DISABLE_INTEL_SVML_)
-#define _XM_SVML_INTRINSICS_
-#endif
-
-#if !defined(_XM_NO_XMVECTOR_OVERLOADS_) && (defined(__clang__) || defined(__GNUC__)) && !defined(_XM_NO_INTRINSICS_)
-#define _XM_NO_XMVECTOR_OVERLOADS_
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4514 4820)
-// C4514/4820: Off by default noise
-#endif
-#include <math.h>
-#include <float.h>
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#ifndef _XM_NO_INTRINSICS_
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4987)
-// C4987: Off by default noise
-#include <intrin.h>
-#pragma warning(pop)
-#endif
-
-#if (defined(__clang__) || defined(__GNUC__)) && (__x86_64__ || __i386__)
-#include <cpuid.h>
-#endif
-
-#ifdef _XM_SSE_INTRINSICS_
-#include <xmmintrin.h>
-#include <emmintrin.h>
-
-#ifdef _XM_SSE3_INTRINSICS_
-#include <pmmintrin.h>
-#endif
-
-#ifdef _XM_SSE4_INTRINSICS_
-#include <smmintrin.h>
-#endif
-
-#ifdef _XM_AVX_INTRINSICS_
-#include <immintrin.h>
-#endif
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-#if defined(_MSC_VER) && !defined(__clang__) && (defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC))
-#include <arm64_neon.h>
-#else
-#include <arm_neon.h>
-#endif
-#endif
-#endif // !_XM_NO_INTRINSICS_
-
-#include "sal.h"
-#include <assert.h>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4005 4668)
-// C4005/4668: Old header issue
-#endif
-#include <stdint.h>
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#if __cplusplus >= 201703L
-#define XM_ALIGNED_DATA(x) alignas(x)
-#define XM_ALIGNED_STRUCT(x) struct alignas(x)
-#elif defined(__GNUC__)
-#define XM_ALIGNED_DATA(x) __attribute__ ((aligned(x)))
-#define XM_ALIGNED_STRUCT(x) struct __attribute__ ((aligned(x)))
-#else
-#define XM_ALIGNED_DATA(x) __declspec(align(x))
-#define XM_ALIGNED_STRUCT(x) __declspec(align(x)) struct
-#endif
-
-#if (__cplusplus >= 202002L)
-#include <compare>
-#endif
-
-/****************************************************************************
- *
- * Conditional intrinsics
- *
- ****************************************************************************/
-
-#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-
-#if defined(_XM_NO_MOVNT_)
-#define XM_STREAM_PS( p, a ) _mm_store_ps((p), (a))
-#define XM256_STREAM_PS( p, a ) _mm256_store_ps((p), (a))
-#define XM_SFENCE()
-#else
-#define XM_STREAM_PS( p, a ) _mm_stream_ps((p), (a))
-#define XM256_STREAM_PS( p, a ) _mm256_stream_ps((p), (a))
-#define XM_SFENCE() _mm_sfence()
-#endif
-
-#if defined(_XM_FMA3_INTRINSICS_)
-#define XM_FMADD_PS( a, b, c ) _mm_fmadd_ps((a), (b), (c))
-#define XM_FNMADD_PS( a, b, c ) _mm_fnmadd_ps((a), (b), (c))
-#else
-#define XM_FMADD_PS( a, b, c ) _mm_add_ps(_mm_mul_ps((a), (b)), (c))
-#define XM_FNMADD_PS( a, b, c ) _mm_sub_ps((c), _mm_mul_ps((a), (b)))
-#endif
-
-#if defined(_XM_AVX_INTRINSICS_) && defined(_XM_FAVOR_INTEL_)
-#define XM_PERMUTE_PS( v, c ) _mm_permute_ps((v), c )
-#else
-#define XM_PERMUTE_PS( v, c ) _mm_shuffle_ps((v), (v), c )
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__) && (__GNUC__ < 11)
-#define XM_LOADU_SI16( p ) _mm_cvtsi32_si128(*reinterpret_cast<unsigned short const*>(p))
-#else
-#define XM_LOADU_SI16( p ) _mm_loadu_si16(p)
-#endif
-
-#endif // _XM_SSE_INTRINSICS_ && !_XM_NO_INTRINSICS_
-
-#if defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-
-#if defined(__clang__) || defined(__GNUC__)
-#define XM_PREFETCH( a ) __builtin_prefetch(a)
-#elif defined(_MSC_VER)
-#define XM_PREFETCH( a ) __prefetch(a)
-#else
-#define XM_PREFETCH( a )
-#endif
-
-#endif // _XM_ARM_NEON_INTRINSICS_ && !_XM_NO_INTRINSICS_
-
-namespace DirectX
-{
-
-    /****************************************************************************
-     *
-     * Constant definitions
-     *
-     ****************************************************************************/
-
-#if defined(__XNAMATH_H__) && defined(XM_PI)
-    #undef XM_PI
-#undef XM_2PI
-#undef XM_1DIVPI
-#undef XM_1DIV2PI
-#undef XM_PIDIV2
-#undef XM_PIDIV4
-#undef XM_SELECT_0
-#undef XM_SELECT_1
-#undef XM_PERMUTE_0X
-#undef XM_PERMUTE_0Y
-#undef XM_PERMUTE_0Z
-#undef XM_PERMUTE_0W
-#undef XM_PERMUTE_1X
-#undef XM_PERMUTE_1Y
-#undef XM_PERMUTE_1Z
-#undef XM_PERMUTE_1W
-#undef XM_CRMASK_CR6
-#undef XM_CRMASK_CR6TRUE
-#undef XM_CRMASK_CR6FALSE
-#undef XM_CRMASK_CR6BOUNDS
-#undef XM_CACHE_LINE_SIZE
-#endif
-
-    constexpr float XM_PI = 3.141592654f;
-    constexpr float XM_2PI = 6.283185307f;
-    constexpr float XM_1DIVPI = 0.318309886f;
-    constexpr float XM_1DIV2PI = 0.159154943f;
-    constexpr float XM_PIDIV2 = 1.570796327f;
-    constexpr float XM_PIDIV4 = 0.785398163f;
-
-    constexpr uint32_t XM_SELECT_0 = 0x00000000;
-    constexpr uint32_t XM_SELECT_1 = 0xFFFFFFFF;
-
-    constexpr uint32_t XM_PERMUTE_0X = 0;
-    constexpr uint32_t XM_PERMUTE_0Y = 1;
-    constexpr uint32_t XM_PERMUTE_0Z = 2;
-    constexpr uint32_t XM_PERMUTE_0W = 3;
-    constexpr uint32_t XM_PERMUTE_1X = 4;
-    constexpr uint32_t XM_PERMUTE_1Y = 5;
-    constexpr uint32_t XM_PERMUTE_1Z = 6;
-    constexpr uint32_t XM_PERMUTE_1W = 7;
-
-    constexpr uint32_t XM_SWIZZLE_X = 0;
-    constexpr uint32_t XM_SWIZZLE_Y = 1;
-    constexpr uint32_t XM_SWIZZLE_Z = 2;
-    constexpr uint32_t XM_SWIZZLE_W = 3;
-
-    constexpr uint32_t XM_CRMASK_CR6 = 0x000000F0;
-    constexpr uint32_t XM_CRMASK_CR6TRUE = 0x00000080;
-    constexpr uint32_t XM_CRMASK_CR6FALSE = 0x00000020;
-    constexpr uint32_t XM_CRMASK_CR6BOUNDS = XM_CRMASK_CR6FALSE;
-
-#if defined(_M_ARM) || defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __arm__ || __aarch64__
-    constexpr size_t XM_CACHE_LINE_SIZE = 128;
-#else
-    constexpr size_t XM_CACHE_LINE_SIZE = 64;
-#endif
-
-
-    /****************************************************************************
-     *
-     * Macros
-     *
-     ****************************************************************************/
-
-#if defined(__XNAMATH_H__) && defined(XMComparisonAllTrue)
-    #undef XMComparisonAllTrue
-#undef XMComparisonAnyTrue
-#undef XMComparisonAllFalse
-#undef XMComparisonAnyFalse
-#undef XMComparisonMixed
-#undef XMComparisonAllInBounds
-#undef XMComparisonAnyOutOfBounds
-#endif
-
-    // Unit conversion
-
-    constexpr float XMConvertToRadians(float fDegrees) noexcept { return fDegrees * (XM_PI / 180.0f); }
-    constexpr float XMConvertToDegrees(float fRadians) noexcept { return fRadians * (180.0f / XM_PI); }
-
-    // Condition register evaluation proceeding a recording (R) comparison
-
-    constexpr bool XMComparisonAllTrue(uint32_t CR) noexcept { return (CR & XM_CRMASK_CR6TRUE) == XM_CRMASK_CR6TRUE; }
-    constexpr bool XMComparisonAnyTrue(uint32_t CR) noexcept { return (CR & XM_CRMASK_CR6FALSE) != XM_CRMASK_CR6FALSE; }
-    constexpr bool XMComparisonAllFalse(uint32_t CR) noexcept { return (CR & XM_CRMASK_CR6FALSE) == XM_CRMASK_CR6FALSE; }
-    constexpr bool XMComparisonAnyFalse(uint32_t CR) noexcept { return (CR & XM_CRMASK_CR6TRUE) != XM_CRMASK_CR6TRUE; }
-    constexpr bool XMComparisonMixed(uint32_t CR) noexcept { return (CR & XM_CRMASK_CR6) == 0; }
-    constexpr bool XMComparisonAllInBounds(uint32_t CR) noexcept { return (CR & XM_CRMASK_CR6BOUNDS) == XM_CRMASK_CR6BOUNDS; }
-    constexpr bool XMComparisonAnyOutOfBounds(uint32_t CR) noexcept { return (CR & XM_CRMASK_CR6BOUNDS) != XM_CRMASK_CR6BOUNDS; }
-
-
-    /****************************************************************************
-     *
-     * Data types
-     *
-     ****************************************************************************/
-
-#ifdef _MSC_VER
-    #pragma warning(push)
-#pragma warning(disable:4068 4201 4365 4324 4820)
-     // C4068: ignore unknown pragmas
-     // C4201: nonstandard extension used : nameless struct/union
-     // C4365: Off by default noise
-     // C4324/4820: padding warnings
-#endif
-
-#ifdef _PREFAST_
-    #pragma prefast(push)
-#pragma prefast(disable : 25000, "FXMVECTOR is 16 bytes")
-#endif
-
-//------------------------------------------------------------------------------
-#if defined(_XM_NO_INTRINSICS_)
-    struct __vector4
-    {
-        union
-        {
-            float       vector4_f32[4];
-            uint32_t    vector4_u32[4];
-        };
-    };
-#endif // _XM_NO_INTRINSICS_
-
-    //------------------------------------------------------------------------------
-    // Vector intrinsic: Four 32 bit floating point components aligned on a 16 byte
-    // boundary and mapped to hardware vector registers
-#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    using XMVECTOR = __m128;
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    using XMVECTOR = float32x4_t;
-#else
-    using XMVECTOR = __vector4;
-#endif
-
-    // Fix-up for (1st-3rd) XMVECTOR parameters that are pass-in-register for x86, ARM, ARM64, and vector call; by reference otherwise
-#if ( defined(_M_IX86) || defined(_M_ARM) || defined(_M_ARM64) || _XM_VECTORCALL_ || __i386__ || __arm__ || __aarch64__ ) && !defined(_XM_NO_INTRINSICS_)
-    typedef const XMVECTOR FXMVECTOR;
-#else
-    typedef const XMVECTOR& FXMVECTOR;
-#endif
-
-    // Fix-up for (4th) XMVECTOR parameter to pass in-register for ARM, ARM64, and vector call; by reference otherwise
-#if ( defined(_M_ARM) || defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || _XM_VECTORCALL_ || __arm__ || __aarch64__ ) && !defined(_XM_NO_INTRINSICS_)
-    typedef const XMVECTOR GXMVECTOR;
-#else
-    typedef const XMVECTOR& GXMVECTOR;
-#endif
-
-    // Fix-up for (5th & 6th) XMVECTOR parameter to pass in-register for ARM64 and vector call; by reference otherwise
-#if ( defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || _XM_VECTORCALL_ || __aarch64__ ) && !defined(_XM_NO_INTRINSICS_)
-    typedef const XMVECTOR HXMVECTOR;
-#else
-    typedef const XMVECTOR& HXMVECTOR;
-#endif
-
-    // Fix-up for (7th+) XMVECTOR parameters to pass by reference
-    typedef const XMVECTOR& CXMVECTOR;
-
-    //------------------------------------------------------------------------------
-    // Conversion types for constants
-    XM_ALIGNED_STRUCT(16) XMVECTORF32
-    {
-        union
-        {
-            float f[4];
-            XMVECTOR v;
-        };
-
-        inline operator XMVECTOR() const noexcept { return v; }
-        inline operator const float* () const noexcept { return f; }
-#ifdef _XM_NO_INTRINSICS_
-#elif defined(_XM_SSE_INTRINSICS_)
-        inline operator __m128i() const noexcept { return _mm_castps_si128(v); }
-        inline operator __m128d() const noexcept { return _mm_castps_pd(v); }
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && defined(__GNUC__)
-        inline operator int32x4_t() const noexcept { return vreinterpretq_s32_f32(v); }
-        inline operator uint32x4_t() const noexcept { return vreinterpretq_u32_f32(v); }
-#endif
-    };
-
-    XM_ALIGNED_STRUCT(16) XMVECTORI32
-    {
-        union
-        {
-            int32_t i[4];
-            XMVECTOR v;
-        };
-
-        inline operator XMVECTOR() const noexcept { return v; }
-#ifdef _XM_NO_INTRINSICS_
-#elif defined(_XM_SSE_INTRINSICS_)
-        inline operator __m128i() const noexcept { return _mm_castps_si128(v); }
-        inline operator __m128d() const noexcept { return _mm_castps_pd(v); }
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && defined(__GNUC__)
-        inline operator int32x4_t() const noexcept { return vreinterpretq_s32_f32(v); }
-        inline operator uint32x4_t() const noexcept { return vreinterpretq_u32_f32(v); }
-#endif
-    };
-
-    XM_ALIGNED_STRUCT(16) XMVECTORU8
-    {
-        union
-        {
-            uint8_t u[16];
-            XMVECTOR v;
-        };
-
-        inline operator XMVECTOR() const noexcept { return v; }
-#ifdef _XM_NO_INTRINSICS_
-#elif defined(_XM_SSE_INTRINSICS_)
-        inline operator __m128i() const noexcept { return _mm_castps_si128(v); }
-        inline operator __m128d() const noexcept { return _mm_castps_pd(v); }
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && defined(__GNUC__)
-        inline operator int32x4_t() const noexcept { return vreinterpretq_s32_f32(v); }
-        inline operator uint32x4_t() const noexcept { return vreinterpretq_u32_f32(v); }
-#endif
-    };
-
-    XM_ALIGNED_STRUCT(16) XMVECTORU32
-    {
-        union
-        {
-            uint32_t u[4];
-            XMVECTOR v;
-        };
-
-        inline operator XMVECTOR() const noexcept { return v; }
-#ifdef _XM_NO_INTRINSICS_
-#elif defined(_XM_SSE_INTRINSICS_)
-        inline operator __m128i() const noexcept { return _mm_castps_si128(v); }
-        inline operator __m128d() const noexcept { return _mm_castps_pd(v); }
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && defined(__GNUC__)
-        inline operator int32x4_t() const noexcept { return vreinterpretq_s32_f32(v); }
-        inline operator uint32x4_t() const noexcept { return vreinterpretq_u32_f32(v); }
-#endif
-    };
-
-    //------------------------------------------------------------------------------
-    // Vector operators
-
-#ifndef _XM_NO_XMVECTOR_OVERLOADS_
-    XMVECTOR    XM_CALLCONV     operator+ (FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     operator- (FXMVECTOR V) noexcept;
-
-    XMVECTOR&   XM_CALLCONV     operator+= (XMVECTOR& V1, FXMVECTOR V2) noexcept;
-    XMVECTOR&   XM_CALLCONV     operator-= (XMVECTOR& V1, FXMVECTOR V2) noexcept;
-    XMVECTOR&   XM_CALLCONV     operator*= (XMVECTOR& V1, FXMVECTOR V2) noexcept;
-    XMVECTOR&   XM_CALLCONV     operator/= (XMVECTOR& V1, FXMVECTOR V2) noexcept;
-
-    XMVECTOR& operator*= (XMVECTOR& V, float S) noexcept;
-    XMVECTOR& operator/= (XMVECTOR& V, float S) noexcept;
-
-    XMVECTOR    XM_CALLCONV     operator+ (FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     operator- (FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     operator* (FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     operator/ (FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     operator* (FXMVECTOR V, float S) noexcept;
-    XMVECTOR    XM_CALLCONV     operator* (float S, FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     operator/ (FXMVECTOR V, float S) noexcept;
-#endif /* !_XM_NO_XMVECTOR_OVERLOADS_ */
-
-    //------------------------------------------------------------------------------
-    // Matrix type: Sixteen 32 bit floating point components aligned on a
-    // 16 byte boundary and mapped to four hardware vector registers
-
-    struct XMMATRIX;
-
-    // Fix-up for (1st) XMMATRIX parameter to pass in-register for ARM64 and vector call; by reference otherwise
-#if ( defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || _XM_VECTORCALL_ || __aarch64__ ) && !defined(_XM_NO_INTRINSICS_)
-    typedef const XMMATRIX FXMMATRIX;
-#else
-    typedef const XMMATRIX& FXMMATRIX;
-#endif
-
-    // Fix-up for (2nd+) XMMATRIX parameters to pass by reference
-    typedef const XMMATRIX& CXMMATRIX;
-
-#ifdef _XM_NO_INTRINSICS_
-    struct XMMATRIX
-#else
-    XM_ALIGNED_STRUCT(16) XMMATRIX
-#endif
-    {
-#ifdef _XM_NO_INTRINSICS_
-        union
-        {
-            XMVECTOR r[4];
-            struct
-            {
-                float _11, _12, _13, _14;
-                float _21, _22, _23, _24;
-                float _31, _32, _33, _34;
-                float _41, _42, _43, _44;
-            };
-            float m[4][4];
-        };
-#else
-        XMVECTOR r[4];
-#endif
-
-        XMMATRIX() = default;
-
-        XMMATRIX(const XMMATRIX&) = default;
-
-#if defined(_MSC_VER) && (_MSC_FULL_VER < 191426431)
-        XMMATRIX& operator= (const XMMATRIX& M) noexcept { r[0] = M.r[0]; r[1] = M.r[1]; r[2] = M.r[2]; r[3] = M.r[3]; return *this; }
-#else
-        XMMATRIX& operator=(const XMMATRIX&) = default;
-
-        XMMATRIX(XMMATRIX&&) = default;
-        XMMATRIX& operator=(XMMATRIX&&) = default;
-#endif
-
-        constexpr XMMATRIX(FXMVECTOR R0, FXMVECTOR R1, FXMVECTOR R2, CXMVECTOR R3) noexcept : r{ R0,R1,R2,R3 } {}
-        XMMATRIX(float m00, float m01, float m02, float m03,
-                 float m10, float m11, float m12, float m13,
-                 float m20, float m21, float m22, float m23,
-                 float m30, float m31, float m32, float m33) noexcept;
-        explicit XMMATRIX(_In_reads_(16) const float* pArray) noexcept;
-
-#ifdef _XM_NO_INTRINSICS_
-        float       operator() (size_t Row, size_t Column) const noexcept { return m[Row][Column]; }
-        float& operator() (size_t Row, size_t Column) noexcept { return m[Row][Column]; }
-#endif
-
-        XMMATRIX    operator+ () const noexcept { return *this; }
-        XMMATRIX    operator- () const noexcept;
-
-        XMMATRIX&   XM_CALLCONV     operator+= (FXMMATRIX M) noexcept;
-        XMMATRIX&   XM_CALLCONV     operator-= (FXMMATRIX M) noexcept;
-        XMMATRIX&   XM_CALLCONV     operator*= (FXMMATRIX M) noexcept;
-        XMMATRIX&   operator*= (float S) noexcept;
-        XMMATRIX&   operator/= (float S) noexcept;
-
-        XMMATRIX    XM_CALLCONV     operator+ (FXMMATRIX M) const noexcept;
-        XMMATRIX    XM_CALLCONV     operator- (FXMMATRIX M) const noexcept;
-        XMMATRIX    XM_CALLCONV     operator* (FXMMATRIX M) const noexcept;
-        XMMATRIX    operator* (float S) const noexcept;
-        XMMATRIX    operator/ (float S) const noexcept;
-
-        friend XMMATRIX     XM_CALLCONV     operator* (float S, FXMMATRIX M) noexcept;
-    };
-
-    //------------------------------------------------------------------------------
-    // 2D Vector; 32 bit floating point components
-    struct XMFLOAT2
-    {
-        float x;
-        float y;
-
-        XMFLOAT2() = default;
-
-        XMFLOAT2(const XMFLOAT2&) = default;
-        XMFLOAT2& operator=(const XMFLOAT2&) = default;
-
-        XMFLOAT2(XMFLOAT2&&) = default;
-        XMFLOAT2& operator=(XMFLOAT2&&) = default;
-
-        constexpr XMFLOAT2(float _x, float _y) noexcept : x(_x), y(_y) {}
-        explicit XMFLOAT2(_In_reads_(2) const float* pArray)  noexcept : x(pArray[0]), y(pArray[1]) {}
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMFLOAT2&) const = default;
-        auto operator <=> (const XMFLOAT2&) const = default;
-#endif
-    };
-
-    // 2D Vector; 32 bit floating point components aligned on a 16 byte boundary
-    XM_ALIGNED_STRUCT(16) XMFLOAT2A : public XMFLOAT2
-    {
-        using XMFLOAT2::XMFLOAT2;
-    };
-
-    //------------------------------------------------------------------------------
-    // 2D Vector; 32 bit signed integer components
-    struct XMINT2
-    {
-        int32_t x;
-        int32_t y;
-
-        XMINT2() = default;
-
-        XMINT2(const XMINT2&) = default;
-        XMINT2& operator=(const XMINT2&) = default;
-
-        XMINT2(XMINT2&&) = default;
-        XMINT2& operator=(XMINT2&&) = default;
-
-        constexpr XMINT2(int32_t _x, int32_t _y) noexcept : x(_x), y(_y) {}
-        explicit XMINT2(_In_reads_(2) const int32_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMINT2&) const = default;
-        auto operator <=> (const XMINT2&) const = default;
-#endif
-    };
-
-    // 2D Vector; 32 bit unsigned integer components
-    struct XMUINT2
-    {
-        uint32_t x;
-        uint32_t y;
-
-        XMUINT2() = default;
-
-        XMUINT2(const XMUINT2&) = default;
-        XMUINT2& operator=(const XMUINT2&) = default;
-
-        XMUINT2(XMUINT2&&) = default;
-        XMUINT2& operator=(XMUINT2&&) = default;
-
-        constexpr XMUINT2(uint32_t _x, uint32_t _y) noexcept : x(_x), y(_y) {}
-        explicit XMUINT2(_In_reads_(2) const uint32_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMUINT2&) const = default;
-        auto operator <=> (const XMUINT2&) const = default;
-#endif
-    };
-
-    //------------------------------------------------------------------------------
-    // 3D Vector; 32 bit floating point components
-    struct XMFLOAT3
-    {
-        float x;
-        float y;
-        float z;
-
-        XMFLOAT3() = default;
-
-        XMFLOAT3(const XMFLOAT3&) = default;
-        XMFLOAT3& operator=(const XMFLOAT3&) = default;
-
-        XMFLOAT3(XMFLOAT3&&) = default;
-        XMFLOAT3& operator=(XMFLOAT3&&) = default;
-
-        constexpr XMFLOAT3(float _x, float _y, float _z) noexcept : x(_x), y(_y), z(_z) {}
-        explicit XMFLOAT3(_In_reads_(3) const float* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
-    };
-
-    // 3D Vector; 32 bit floating point components aligned on a 16 byte boundary
-    XM_ALIGNED_STRUCT(16) XMFLOAT3A : public XMFLOAT3
-    {
-        using XMFLOAT3::XMFLOAT3;
-    };
-
-    //------------------------------------------------------------------------------
-    // 3D Vector; 32 bit signed integer components
-    struct XMINT3
-    {
-        int32_t x;
-        int32_t y;
-        int32_t z;
-
-        XMINT3() = default;
-
-        XMINT3(const XMINT3&) = default;
-        XMINT3& operator=(const XMINT3&) = default;
-
-        XMINT3(XMINT3&&) = default;
-        XMINT3& operator=(XMINT3&&) = default;
-
-        constexpr XMINT3(int32_t _x, int32_t _y, int32_t _z) noexcept : x(_x), y(_y), z(_z) {}
-        explicit XMINT3(_In_reads_(3) const int32_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMINT3&) const = default;
-        auto operator <=> (const XMINT3&) const = default;
-#endif
-    };
-
-    // 3D Vector; 32 bit unsigned integer components
-    struct XMUINT3
-    {
-        uint32_t x;
-        uint32_t y;
-        uint32_t z;
-
-        XMUINT3() = default;
-
-        XMUINT3(const XMUINT3&) = default;
-        XMUINT3& operator=(const XMUINT3&) = default;
-
-        XMUINT3(XMUINT3&&) = default;
-        XMUINT3& operator=(XMUINT3&&) = default;
-
-        constexpr XMUINT3(uint32_t _x, uint32_t _y, uint32_t _z) noexcept : x(_x), y(_y), z(_z) {}
-        explicit XMUINT3(_In_reads_(3) const uint32_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMUINT3&) const = default;
-        auto operator <=> (const XMUINT3&) const = default;
-#endif
-    };
-
-    //------------------------------------------------------------------------------
-    // 4D Vector; 32 bit floating point components
-    struct XMFLOAT4
-    {
-        float x;
-        float y;
-        float z;
-        float w;
-
-        XMFLOAT4() = default;
-
-        XMFLOAT4(const XMFLOAT4&) = default;
-        XMFLOAT4& operator=(const XMFLOAT4&) = default;
-
-        XMFLOAT4(XMFLOAT4&&) = default;
-        XMFLOAT4& operator=(XMFLOAT4&&) = default;
-
-        constexpr XMFLOAT4(float _x, float _y, float _z, float _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-        explicit XMFLOAT4(_In_reads_(4) const float* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMFLOAT4&) const = default;
-        auto operator <=> (const XMFLOAT4&) const = default;
-#endif
-    };
-
-    // 4D Vector; 32 bit floating point components aligned on a 16 byte boundary
-    XM_ALIGNED_STRUCT(16) XMFLOAT4A : public XMFLOAT4
-    {
-        using XMFLOAT4::XMFLOAT4;
-    };
-
-    //------------------------------------------------------------------------------
-    // 4D Vector; 32 bit signed integer components
-    struct XMINT4
-    {
-        int32_t x;
-        int32_t y;
-        int32_t z;
-        int32_t w;
-
-        XMINT4() = default;
-
-        XMINT4(const XMINT4&) = default;
-        XMINT4& operator=(const XMINT4&) = default;
-
-        XMINT4(XMINT4&&) = default;
-        XMINT4& operator=(XMINT4&&) = default;
-
-        constexpr XMINT4(int32_t _x, int32_t _y, int32_t _z, int32_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-        explicit XMINT4(_In_reads_(4) const int32_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMINT4&) const = default;
-        auto operator <=> (const XMINT4&) const = default;
-#endif
-    };
-
-    // 4D Vector; 32 bit unsigned integer components
-    struct XMUINT4
-    {
-        uint32_t x;
-        uint32_t y;
-        uint32_t z;
-        uint32_t w;
-
-        XMUINT4() = default;
-
-        XMUINT4(const XMUINT4&) = default;
-        XMUINT4& operator=(const XMUINT4&) = default;
-
-        XMUINT4(XMUINT4&&) = default;
-        XMUINT4& operator=(XMUINT4&&) = default;
-
-        constexpr XMUINT4(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-        explicit XMUINT4(_In_reads_(4) const uint32_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMUINT4&) const = default;
-        auto operator <=> (const XMUINT4&) const = default;
-#endif
-    };
-
-#ifdef __clang__
-    #pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
-#pragma clang diagnostic ignored "-Wnested-anon-types"
-#endif
-
-    //------------------------------------------------------------------------------
-    // 3x3 Matrix: 32 bit floating point components
-    struct XMFLOAT3X3
-    {
-        union
-        {
-            struct
-            {
-                float _11, _12, _13;
-                float _21, _22, _23;
-                float _31, _32, _33;
-            };
-            float m[3][3];
-        };
-
-        XMFLOAT3X3() = default;
-
-        XMFLOAT3X3(const XMFLOAT3X3&) = default;
-        XMFLOAT3X3& operator=(const XMFLOAT3X3&) = default;
-
-        XMFLOAT3X3(XMFLOAT3X3&&) = default;
-        XMFLOAT3X3& operator=(XMFLOAT3X3&&) = default;
-
-        constexpr XMFLOAT3X3(float m00, float m01, float m02,
-                             float m10, float m11, float m12,
-                             float m20, float m21, float m22) noexcept
-                : _11(m00), _12(m01), _13(m02),
-                  _21(m10), _22(m11), _23(m12),
-                  _31(m20), _32(m21), _33(m22) {}
-        explicit XMFLOAT3X3(_In_reads_(9) const float* pArray) noexcept;
-
-        float  operator() (size_t Row, size_t Column) const  noexcept { return m[Row][Column]; }
-        float& operator() (size_t Row, size_t Column) noexcept { return m[Row][Column]; }
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMFLOAT3X3&) const = default;
-        auto operator <=> (const XMFLOAT3X3&) const = default;
-#endif
-    };
-
-    //------------------------------------------------------------------------------
-    // 4x3 Row-major Matrix: 32 bit floating point components
-    struct XMFLOAT4X3
-    {
-        union
-        {
-            struct
-            {
-                float _11, _12, _13;
-                float _21, _22, _23;
-                float _31, _32, _33;
-                float _41, _42, _43;
-            };
-            float m[4][3];
-            float f[12];
-        };
-
-        XMFLOAT4X3() = default;
-
-        XMFLOAT4X3(const XMFLOAT4X3&) = default;
-        XMFLOAT4X3& operator=(const XMFLOAT4X3&) = default;
-
-        XMFLOAT4X3(XMFLOAT4X3&&) = default;
-        XMFLOAT4X3& operator=(XMFLOAT4X3&&) = default;
-
-        constexpr XMFLOAT4X3(float m00, float m01, float m02,
-                             float m10, float m11, float m12,
-                             float m20, float m21, float m22,
-                             float m30, float m31, float m32) noexcept
-                : _11(m00), _12(m01), _13(m02),
-                  _21(m10), _22(m11), _23(m12),
-                  _31(m20), _32(m21), _33(m22),
-                  _41(m30), _42(m31), _43(m32) {}
-        explicit XMFLOAT4X3(_In_reads_(12) const float* pArray) noexcept;
-
-        float  operator() (size_t Row, size_t Column) const  noexcept { return m[Row][Column]; }
-        float& operator() (size_t Row, size_t Column) noexcept { return m[Row][Column]; }
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMFLOAT4X3&) const = default;
-        auto operator <=> (const XMFLOAT4X3&) const = default;
-#endif
-    };
-
-    // 4x3 Row-major Matrix: 32 bit floating point components aligned on a 16 byte boundary
-    XM_ALIGNED_STRUCT(16) XMFLOAT4X3A : public XMFLOAT4X3
-    {
-        using XMFLOAT4X3::XMFLOAT4X3;
-    };
-
-    //------------------------------------------------------------------------------
-    // 3x4 Column-major Matrix: 32 bit floating point components
-    struct XMFLOAT3X4
-    {
-        union
-        {
-            struct
-            {
-                float _11, _12, _13, _14;
-                float _21, _22, _23, _24;
-                float _31, _32, _33, _34;
-            };
-            float m[3][4];
-            float f[12];
-        };
-
-        XMFLOAT3X4() = default;
-
-        XMFLOAT3X4(const XMFLOAT3X4&) = default;
-        XMFLOAT3X4& operator=(const XMFLOAT3X4&) = default;
-
-        XMFLOAT3X4(XMFLOAT3X4&&) = default;
-        XMFLOAT3X4& operator=(XMFLOAT3X4&&) = default;
-
-        constexpr XMFLOAT3X4(float m00, float m01, float m02, float m03,
-                             float m10, float m11, float m12, float m13,
-                             float m20, float m21, float m22, float m23) noexcept
-                : _11(m00), _12(m01), _13(m02), _14(m03),
-                  _21(m10), _22(m11), _23(m12), _24(m13),
-                  _31(m20), _32(m21), _33(m22), _34(m23) {}
-        explicit XMFLOAT3X4(_In_reads_(12) const float* pArray) noexcept;
-
-        float  operator() (size_t Row, size_t Column) const noexcept { return m[Row][Column]; }
-        float& operator() (size_t Row, size_t Column) noexcept { return m[Row][Column]; }
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMFLOAT3X4&) const = default;
-        auto operator <=> (const XMFLOAT3X4&) const = default;
-#endif
-    };
-
-    // 3x4 Column-major Matrix: 32 bit floating point components aligned on a 16 byte boundary
-    XM_ALIGNED_STRUCT(16) XMFLOAT3X4A : public XMFLOAT3X4
-    {
-        using XMFLOAT3X4::XMFLOAT3X4;
-    };
-
-    //------------------------------------------------------------------------------
-    // 4x4 Matrix: 32 bit floating point components
-    struct XMFLOAT4X4
-    {
-        union
-        {
-            struct
-            {
-                float _11, _12, _13, _14;
-                float _21, _22, _23, _24;
-                float _31, _32, _33, _34;
-                float _41, _42, _43, _44;
-            };
-            float m[4][4];
-        };
-
-        XMFLOAT4X4() = default;
-
-        XMFLOAT4X4(const XMFLOAT4X4&) = default;
-        XMFLOAT4X4& operator=(const XMFLOAT4X4&) = default;
-
-        XMFLOAT4X4(XMFLOAT4X4&&) = default;
-        XMFLOAT4X4& operator=(XMFLOAT4X4&&) = default;
-
-        constexpr XMFLOAT4X4(float m00, float m01, float m02, float m03,
-                             float m10, float m11, float m12, float m13,
-                             float m20, float m21, float m22, float m23,
-                             float m30, float m31, float m32, float m33) noexcept
-                : _11(m00), _12(m01), _13(m02), _14(m03),
-                  _21(m10), _22(m11), _23(m12), _24(m13),
-                  _31(m20), _32(m21), _33(m22), _34(m23),
-                  _41(m30), _42(m31), _43(m32), _44(m33) {}
-        explicit XMFLOAT4X4(_In_reads_(16) const float* pArray) noexcept;
-
-        float  operator() (size_t Row, size_t Column) const noexcept { return m[Row][Column]; }
-        float& operator() (size_t Row, size_t Column) noexcept { return m[Row][Column]; }
-
-#if (__cplusplus >= 202002L)
-        bool operator == (const XMFLOAT4X4&) const = default;
-        auto operator <=> (const XMFLOAT4X4&) const = default;
-#endif
-    };
-
-    // 4x4 Matrix: 32 bit floating point components aligned on a 16 byte boundary
-    XM_ALIGNED_STRUCT(16) XMFLOAT4X4A : public XMFLOAT4X4
-    {
-        using XMFLOAT4X4::XMFLOAT4X4;
-    };
-
-    ////////////////////////////////////////////////////////////////////////////////
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-/****************************************************************************
- *
- * Data conversion operations
- *
- ****************************************************************************/
-
-    XMVECTOR    XM_CALLCONV     XMConvertVectorIntToFloat(FXMVECTOR VInt, uint32_t DivExponent) noexcept;
-    XMVECTOR    XM_CALLCONV     XMConvertVectorFloatToInt(FXMVECTOR VFloat, uint32_t MulExponent) noexcept;
-    XMVECTOR    XM_CALLCONV     XMConvertVectorUIntToFloat(FXMVECTOR VUInt, uint32_t DivExponent) noexcept;
-    XMVECTOR    XM_CALLCONV     XMConvertVectorFloatToUInt(FXMVECTOR VFloat, uint32_t MulExponent) noexcept;
-
-#if defined(__XNAMATH_H__) && defined(XMVectorSetBinaryConstant)
-    #undef XMVectorSetBinaryConstant
-#undef XMVectorSplatConstant
-#undef XMVectorSplatConstantInt
-#endif
-
-    XMVECTOR    XM_CALLCONV     XMVectorSetBinaryConstant(uint32_t C0, uint32_t C1, uint32_t C2, uint32_t C3) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatConstant(int32_t IntConstant, uint32_t DivExponent) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatConstantInt(int32_t IntConstant) noexcept;
-
-    /****************************************************************************
-     *
-     * Load operations
-     *
-     ****************************************************************************/
-
-    XMVECTOR    XM_CALLCONV     XMLoadInt(_In_ const uint32_t* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadFloat(_In_ const float* pSource) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMLoadInt2(_In_reads_(2) const uint32_t* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadInt2A(_In_reads_(2) const uint32_t* PSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadFloat2(_In_ const XMFLOAT2* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadFloat2A(_In_ const XMFLOAT2A* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadSInt2(_In_ const XMINT2* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadUInt2(_In_ const XMUINT2* pSource) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMLoadInt3(_In_reads_(3) const uint32_t* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadInt3A(_In_reads_(3) const uint32_t* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadFloat3(_In_ const XMFLOAT3* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadFloat3A(_In_ const XMFLOAT3A* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadSInt3(_In_ const XMINT3* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadUInt3(_In_ const XMUINT3* pSource) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMLoadInt4(_In_reads_(4) const uint32_t* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadInt4A(_In_reads_(4) const uint32_t* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadFloat4(_In_ const XMFLOAT4* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadFloat4A(_In_ const XMFLOAT4A* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadSInt4(_In_ const XMINT4* pSource) noexcept;
-    XMVECTOR    XM_CALLCONV     XMLoadUInt4(_In_ const XMUINT4* pSource) noexcept;
-
-    XMMATRIX    XM_CALLCONV     XMLoadFloat3x3(_In_ const XMFLOAT3X3* pSource) noexcept;
-    XMMATRIX    XM_CALLCONV     XMLoadFloat4x3(_In_ const XMFLOAT4X3* pSource) noexcept;
-    XMMATRIX    XM_CALLCONV     XMLoadFloat4x3A(_In_ const XMFLOAT4X3A* pSource) noexcept;
-    XMMATRIX    XM_CALLCONV     XMLoadFloat3x4(_In_ const XMFLOAT3X4* pSource) noexcept;
-    XMMATRIX    XM_CALLCONV     XMLoadFloat3x4A(_In_ const XMFLOAT3X4A* pSource) noexcept;
-    XMMATRIX    XM_CALLCONV     XMLoadFloat4x4(_In_ const XMFLOAT4X4* pSource) noexcept;
-    XMMATRIX    XM_CALLCONV     XMLoadFloat4x4A(_In_ const XMFLOAT4X4A* pSource) noexcept;
-
-    /****************************************************************************
-     *
-     * Store operations
-     *
-     ****************************************************************************/
-
-    void        XM_CALLCONV     XMStoreInt(_Out_ uint32_t* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreFloat(_Out_ float* pDestination, _In_ FXMVECTOR V) noexcept;
-
-    void        XM_CALLCONV     XMStoreInt2(_Out_writes_(2) uint32_t* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreInt2A(_Out_writes_(2) uint32_t* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreFloat2(_Out_ XMFLOAT2* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreFloat2A(_Out_ XMFLOAT2A* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreSInt2(_Out_ XMINT2* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreUInt2(_Out_ XMUINT2* pDestination, _In_ FXMVECTOR V) noexcept;
-
-    void        XM_CALLCONV     XMStoreInt3(_Out_writes_(3) uint32_t* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreInt3A(_Out_writes_(3) uint32_t* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreFloat3(_Out_ XMFLOAT3* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreFloat3A(_Out_ XMFLOAT3A* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreSInt3(_Out_ XMINT3* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreUInt3(_Out_ XMUINT3* pDestination, _In_ FXMVECTOR V) noexcept;
-
-    void        XM_CALLCONV     XMStoreInt4(_Out_writes_(4) uint32_t* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreInt4A(_Out_writes_(4) uint32_t* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreFloat4(_Out_ XMFLOAT4* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreFloat4A(_Out_ XMFLOAT4A* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreSInt4(_Out_ XMINT4* pDestination, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMStoreUInt4(_Out_ XMUINT4* pDestination, _In_ FXMVECTOR V) noexcept;
-
-    void        XM_CALLCONV     XMStoreFloat3x3(_Out_ XMFLOAT3X3* pDestination, _In_ FXMMATRIX M) noexcept;
-    void        XM_CALLCONV     XMStoreFloat4x3(_Out_ XMFLOAT4X3* pDestination, _In_ FXMMATRIX M) noexcept;
-    void        XM_CALLCONV     XMStoreFloat4x3A(_Out_ XMFLOAT4X3A* pDestination, _In_ FXMMATRIX M) noexcept;
-    void        XM_CALLCONV     XMStoreFloat3x4(_Out_ XMFLOAT3X4* pDestination, _In_ FXMMATRIX M) noexcept;
-    void        XM_CALLCONV     XMStoreFloat3x4A(_Out_ XMFLOAT3X4A* pDestination, _In_ FXMMATRIX M) noexcept;
-    void        XM_CALLCONV     XMStoreFloat4x4(_Out_ XMFLOAT4X4* pDestination, _In_ FXMMATRIX M) noexcept;
-    void        XM_CALLCONV     XMStoreFloat4x4A(_Out_ XMFLOAT4X4A* pDestination, _In_ FXMMATRIX M) noexcept;
-
-    /****************************************************************************
-     *
-     * General vector operations
-     *
-     ****************************************************************************/
-
-    XMVECTOR    XM_CALLCONV     XMVectorZero() noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSet(float x, float y, float z, float w) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetInt(uint32_t x, uint32_t y, uint32_t z, uint32_t w) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorReplicate(float Value) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorReplicatePtr(_In_ const float* pValue) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorReplicateInt(uint32_t Value) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorReplicateIntPtr(_In_ const uint32_t* pValue) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorTrueInt() noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorFalseInt() noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatX(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatY(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatZ(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatW(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatOne() noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatInfinity() noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatQNaN() noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatEpsilon() noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSplatSignMask() noexcept;
-
-    float       XM_CALLCONV     XMVectorGetByIndex(FXMVECTOR V, size_t i) noexcept;
-    float       XM_CALLCONV     XMVectorGetX(FXMVECTOR V) noexcept;
-    float       XM_CALLCONV     XMVectorGetY(FXMVECTOR V) noexcept;
-    float       XM_CALLCONV     XMVectorGetZ(FXMVECTOR V) noexcept;
-    float       XM_CALLCONV     XMVectorGetW(FXMVECTOR V) noexcept;
-
-    void        XM_CALLCONV     XMVectorGetByIndexPtr(_Out_ float* f, _In_ FXMVECTOR V, _In_ size_t i) noexcept;
-    void        XM_CALLCONV     XMVectorGetXPtr(_Out_ float* x, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMVectorGetYPtr(_Out_ float* y, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMVectorGetZPtr(_Out_ float* z, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMVectorGetWPtr(_Out_ float* w, _In_ FXMVECTOR V) noexcept;
-
-    uint32_t    XM_CALLCONV     XMVectorGetIntByIndex(FXMVECTOR V, size_t i) noexcept;
-    uint32_t    XM_CALLCONV     XMVectorGetIntX(FXMVECTOR V) noexcept;
-    uint32_t    XM_CALLCONV     XMVectorGetIntY(FXMVECTOR V) noexcept;
-    uint32_t    XM_CALLCONV     XMVectorGetIntZ(FXMVECTOR V) noexcept;
-    uint32_t    XM_CALLCONV     XMVectorGetIntW(FXMVECTOR V) noexcept;
-
-    void        XM_CALLCONV     XMVectorGetIntByIndexPtr(_Out_ uint32_t* x, _In_ FXMVECTOR V, _In_ size_t i) noexcept;
-    void        XM_CALLCONV     XMVectorGetIntXPtr(_Out_ uint32_t* x, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMVectorGetIntYPtr(_Out_ uint32_t* y, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMVectorGetIntZPtr(_Out_ uint32_t* z, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMVectorGetIntWPtr(_Out_ uint32_t* w, _In_ FXMVECTOR V) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVectorSetByIndex(FXMVECTOR V, float f, size_t i) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetX(FXMVECTOR V, float x) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetY(FXMVECTOR V, float y) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetZ(FXMVECTOR V, float z) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetW(FXMVECTOR V, float w) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVectorSetByIndexPtr(_In_ FXMVECTOR V, _In_ const float* f, _In_ size_t i) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetXPtr(_In_ FXMVECTOR V, _In_ const float* x) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetYPtr(_In_ FXMVECTOR V, _In_ const float* y) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetZPtr(_In_ FXMVECTOR V, _In_ const float* z) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetWPtr(_In_ FXMVECTOR V, _In_ const float* w) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntByIndex(FXMVECTOR V, uint32_t x, size_t i) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntX(FXMVECTOR V, uint32_t x) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntY(FXMVECTOR V, uint32_t y) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntZ(FXMVECTOR V, uint32_t z) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntW(FXMVECTOR V, uint32_t w) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntByIndexPtr(_In_ FXMVECTOR V, _In_ const uint32_t* x, _In_ size_t i) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntXPtr(_In_ FXMVECTOR V, _In_ const uint32_t* x) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntYPtr(_In_ FXMVECTOR V, _In_ const uint32_t* y) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntZPtr(_In_ FXMVECTOR V, _In_ const uint32_t* z) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSetIntWPtr(_In_ FXMVECTOR V, _In_ const uint32_t* w) noexcept;
-
-#if defined(__XNAMATH_H__) && defined(XMVectorSwizzle)
-#undef XMVectorSwizzle
-#endif
-
-    XMVECTOR    XM_CALLCONV     XMVectorSwizzle(FXMVECTOR V, uint32_t E0, uint32_t E1, uint32_t E2, uint32_t E3) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorPermute(FXMVECTOR V1, FXMVECTOR V2, uint32_t PermuteX, uint32_t PermuteY, uint32_t PermuteZ, uint32_t PermuteW) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSelectControl(uint32_t VectorIndex0, uint32_t VectorIndex1, uint32_t VectorIndex2, uint32_t VectorIndex3) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSelect(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Control) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorMergeXY(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorMergeZW(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-
-#if defined(__XNAMATH_H__) && defined(XMVectorShiftLeft)
-    #undef XMVectorShiftLeft
-#undef XMVectorRotateLeft
-#undef XMVectorRotateRight
-#undef XMVectorInsert
-#endif
-
-    XMVECTOR    XM_CALLCONV     XMVectorShiftLeft(FXMVECTOR V1, FXMVECTOR V2, uint32_t Elements) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorRotateLeft(FXMVECTOR V, uint32_t Elements) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorRotateRight(FXMVECTOR V, uint32_t Elements) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorInsert(FXMVECTOR VD, FXMVECTOR VS, uint32_t VSLeftRotateElements,
-                                               uint32_t Select0, uint32_t Select1, uint32_t Select2, uint32_t Select3) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVectorEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorEqualR(_Out_ uint32_t* pCR, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorEqualInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorEqualIntR(_Out_ uint32_t* pCR, _In_ FXMVECTOR V, _In_ FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorNearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorNotEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorNotEqualInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorGreater(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorGreaterR(_Out_ uint32_t* pCR, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorGreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorGreaterOrEqualR(_Out_ uint32_t* pCR, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorLess(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorLessOrEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorInBounds(FXMVECTOR V, FXMVECTOR Bounds) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorInBoundsR(_Out_ uint32_t* pCR, _In_ FXMVECTOR V, _In_ FXMVECTOR Bounds) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVectorIsNaN(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorIsInfinite(FXMVECTOR V) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVectorMin(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorMax(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorRound(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorTruncate(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorFloor(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorCeiling(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorClamp(FXMVECTOR V, FXMVECTOR Min, FXMVECTOR Max) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSaturate(FXMVECTOR V) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVectorAndInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorAndCInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorOrInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorNorInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorXorInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVectorNegate(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorAdd(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSum(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorAddAngles(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSubtract(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSubtractAngles(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorMultiply(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorMultiplyAdd(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorDivide(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorNegativeMultiplySubtract(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorScale(FXMVECTOR V, float ScaleFactor) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorReciprocalEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorReciprocal(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSqrtEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSqrt(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorReciprocalSqrtEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorReciprocalSqrt(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorExp2(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorExp10(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorExpE(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorExp(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorLog2(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorLog10(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorLogE(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorLog(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorPow(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorAbs(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorMod(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorModAngles(FXMVECTOR Angles) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSin(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSinEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorCos(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorCosEst(FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMVectorSinCos(_Out_ XMVECTOR* pSin, _Out_ XMVECTOR* pCos, _In_ FXMVECTOR V) noexcept;
-    void        XM_CALLCONV     XMVectorSinCosEst(_Out_ XMVECTOR* pSin, _Out_ XMVECTOR* pCos, _In_ FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorTan(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorTanEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorSinH(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorCosH(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorTanH(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorASin(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorASinEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorACos(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorACosEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorATan(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorATanEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorATan2(FXMVECTOR Y, FXMVECTOR X) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorATan2Est(FXMVECTOR Y, FXMVECTOR X) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorLerp(FXMVECTOR V0, FXMVECTOR V1, float t) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorLerpV(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR T) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorHermite(FXMVECTOR Position0, FXMVECTOR Tangent0, FXMVECTOR Position1, GXMVECTOR Tangent1, float t) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorHermiteV(FXMVECTOR Position0, FXMVECTOR Tangent0, FXMVECTOR Position1, GXMVECTOR Tangent1, HXMVECTOR T) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorCatmullRom(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, GXMVECTOR Position3, float t) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorCatmullRomV(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, GXMVECTOR Position3, HXMVECTOR T) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorBaryCentric(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, float f, float g) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVectorBaryCentricV(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, GXMVECTOR F, HXMVECTOR G) noexcept;
-
-    /****************************************************************************
-     *
-     * 2D vector operations
-     *
-     ****************************************************************************/
-
-    bool        XM_CALLCONV     XMVector2Equal(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector2EqualR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector2EqualInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector2EqualIntR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector2NearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon) noexcept;
-    bool        XM_CALLCONV     XMVector2NotEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector2NotEqualInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector2Greater(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector2GreaterR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector2GreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector2GreaterOrEqualR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector2Less(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector2LessOrEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector2InBounds(FXMVECTOR V, FXMVECTOR Bounds) noexcept;
-
-    bool        XM_CALLCONV     XMVector2IsNaN(FXMVECTOR V) noexcept;
-    bool        XM_CALLCONV     XMVector2IsInfinite(FXMVECTOR V) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVector2Dot(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2Cross(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2LengthSq(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2ReciprocalLengthEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2ReciprocalLength(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2LengthEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2Length(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2NormalizeEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2Normalize(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2ClampLength(FXMVECTOR V, float LengthMin, float LengthMax) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2ClampLengthV(FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2Reflect(FXMVECTOR Incident, FXMVECTOR Normal) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2Refract(FXMVECTOR Incident, FXMVECTOR Normal, float RefractionIndex) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2RefractV(FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2Orthogonal(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2AngleBetweenNormalsEst(FXMVECTOR N1, FXMVECTOR N2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2AngleBetweenNormals(FXMVECTOR N1, FXMVECTOR N2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2AngleBetweenVectors(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2LinePointDistance(FXMVECTOR LinePoint1, FXMVECTOR LinePoint2, FXMVECTOR Point) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2IntersectLine(FXMVECTOR Line1Point1, FXMVECTOR Line1Point2, FXMVECTOR Line2Point1, GXMVECTOR Line2Point2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2Transform(FXMVECTOR V, FXMMATRIX M) noexcept;
-    XMFLOAT4*   XM_CALLCONV     XMVector2TransformStream(_Out_writes_bytes_(sizeof(XMFLOAT4) + OutputStride * (VectorCount - 1)) XMFLOAT4* pOutputStream,
-                                                         _In_ size_t OutputStride,
-                                                         _In_reads_bytes_(sizeof(XMFLOAT2) + InputStride * (VectorCount - 1)) const XMFLOAT2* pInputStream,
-                                                         _In_ size_t InputStride, _In_ size_t VectorCount, _In_ FXMMATRIX M) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2TransformCoord(FXMVECTOR V, FXMMATRIX M) noexcept;
-    XMFLOAT2*   XM_CALLCONV     XMVector2TransformCoordStream(_Out_writes_bytes_(sizeof(XMFLOAT2) + OutputStride * (VectorCount - 1)) XMFLOAT2* pOutputStream,
-                                                              _In_ size_t OutputStride,
-                                                              _In_reads_bytes_(sizeof(XMFLOAT2) + InputStride * (VectorCount - 1)) const XMFLOAT2* pInputStream,
-                                                              _In_ size_t InputStride, _In_ size_t VectorCount, _In_ FXMMATRIX M) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector2TransformNormal(FXMVECTOR V, FXMMATRIX M) noexcept;
-    XMFLOAT2*   XM_CALLCONV     XMVector2TransformNormalStream(_Out_writes_bytes_(sizeof(XMFLOAT2) + OutputStride * (VectorCount - 1)) XMFLOAT2* pOutputStream,
-                                                               _In_ size_t OutputStride,
-                                                               _In_reads_bytes_(sizeof(XMFLOAT2) + InputStride * (VectorCount - 1)) const XMFLOAT2* pInputStream,
-                                                               _In_ size_t InputStride, _In_ size_t VectorCount, _In_ FXMMATRIX M) noexcept;
-
-    /****************************************************************************
-     *
-     * 3D vector operations
-     *
-     ****************************************************************************/
-
-    bool        XM_CALLCONV     XMVector3Equal(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector3EqualR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector3EqualInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector3EqualIntR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector3NearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon) noexcept;
-    bool        XM_CALLCONV     XMVector3NotEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector3NotEqualInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector3Greater(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector3GreaterR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector3GreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector3GreaterOrEqualR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector3Less(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector3LessOrEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector3InBounds(FXMVECTOR V, FXMVECTOR Bounds) noexcept;
-
-    bool        XM_CALLCONV     XMVector3IsNaN(FXMVECTOR V) noexcept;
-    bool        XM_CALLCONV     XMVector3IsInfinite(FXMVECTOR V) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVector3Dot(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Cross(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3LengthSq(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3ReciprocalLengthEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3ReciprocalLength(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3LengthEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Length(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3NormalizeEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Normalize(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3ClampLength(FXMVECTOR V, float LengthMin, float LengthMax) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3ClampLengthV(FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Reflect(FXMVECTOR Incident, FXMVECTOR Normal) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Refract(FXMVECTOR Incident, FXMVECTOR Normal, float RefractionIndex) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3RefractV(FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Orthogonal(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3AngleBetweenNormalsEst(FXMVECTOR N1, FXMVECTOR N2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3AngleBetweenNormals(FXMVECTOR N1, FXMVECTOR N2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3AngleBetweenVectors(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3LinePointDistance(FXMVECTOR LinePoint1, FXMVECTOR LinePoint2, FXMVECTOR Point) noexcept;
-    void        XM_CALLCONV     XMVector3ComponentsFromNormal(_Out_ XMVECTOR* pParallel, _Out_ XMVECTOR* pPerpendicular, _In_ FXMVECTOR V, _In_ FXMVECTOR Normal) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Rotate(FXMVECTOR V, FXMVECTOR RotationQuaternion) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3InverseRotate(FXMVECTOR V, FXMVECTOR RotationQuaternion) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Transform(FXMVECTOR V, FXMMATRIX M) noexcept;
-    XMFLOAT4*   XM_CALLCONV     XMVector3TransformStream(_Out_writes_bytes_(sizeof(XMFLOAT4) + OutputStride * (VectorCount - 1)) XMFLOAT4* pOutputStream,
-                                                         _In_ size_t OutputStride,
-                                                         _In_reads_bytes_(sizeof(XMFLOAT3) + InputStride * (VectorCount - 1)) const XMFLOAT3* pInputStream,
-                                                         _In_ size_t InputStride, _In_ size_t VectorCount, _In_ FXMMATRIX M) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3TransformCoord(FXMVECTOR V, FXMMATRIX M) noexcept;
-    XMFLOAT3*   XM_CALLCONV     XMVector3TransformCoordStream(_Out_writes_bytes_(sizeof(XMFLOAT3) + OutputStride * (VectorCount - 1)) XMFLOAT3* pOutputStream,
-                                                              _In_ size_t OutputStride,
-                                                              _In_reads_bytes_(sizeof(XMFLOAT3) + InputStride * (VectorCount - 1)) const XMFLOAT3* pInputStream,
-                                                              _In_ size_t InputStride, _In_ size_t VectorCount, _In_ FXMMATRIX M) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3TransformNormal(FXMVECTOR V, FXMMATRIX M) noexcept;
-    XMFLOAT3*   XM_CALLCONV     XMVector3TransformNormalStream(_Out_writes_bytes_(sizeof(XMFLOAT3) + OutputStride * (VectorCount - 1)) XMFLOAT3* pOutputStream,
-                                                               _In_ size_t OutputStride,
-                                                               _In_reads_bytes_(sizeof(XMFLOAT3) + InputStride * (VectorCount - 1)) const XMFLOAT3* pInputStream,
-                                                               _In_ size_t InputStride, _In_ size_t VectorCount, _In_ FXMMATRIX M) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Project(FXMVECTOR V, float ViewportX, float ViewportY, float ViewportWidth, float ViewportHeight, float ViewportMinZ, float ViewportMaxZ,
-                                                 FXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World) noexcept;
-    XMFLOAT3*   XM_CALLCONV     XMVector3ProjectStream(_Out_writes_bytes_(sizeof(XMFLOAT3) + OutputStride * (VectorCount - 1)) XMFLOAT3* pOutputStream,
-                                                       _In_ size_t OutputStride,
-                                                       _In_reads_bytes_(sizeof(XMFLOAT3) + InputStride * (VectorCount - 1)) const XMFLOAT3* pInputStream,
-                                                       _In_ size_t InputStride, _In_ size_t VectorCount,
-                                                       _In_ float ViewportX, _In_ float ViewportY, _In_ float ViewportWidth, _In_ float ViewportHeight, _In_ float ViewportMinZ, _In_ float ViewportMaxZ,
-                                                       _In_ FXMMATRIX Projection, _In_ CXMMATRIX View, _In_ CXMMATRIX World) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector3Unproject(FXMVECTOR V, float ViewportX, float ViewportY, float ViewportWidth, float ViewportHeight, float ViewportMinZ, float ViewportMaxZ,
-                                                   FXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World) noexcept;
-    XMFLOAT3*   XM_CALLCONV     XMVector3UnprojectStream(_Out_writes_bytes_(sizeof(XMFLOAT3) + OutputStride * (VectorCount - 1)) XMFLOAT3* pOutputStream,
-                                                         _In_ size_t OutputStride,
-                                                         _In_reads_bytes_(sizeof(XMFLOAT3) + InputStride * (VectorCount - 1)) const XMFLOAT3* pInputStream,
-                                                         _In_ size_t InputStride, _In_ size_t VectorCount,
-                                                         _In_ float ViewportX, _In_ float ViewportY, _In_ float ViewportWidth, _In_ float ViewportHeight, _In_ float ViewportMinZ, _In_ float ViewportMaxZ,
-                                                         _In_ FXMMATRIX Projection, _In_ CXMMATRIX View, _In_ CXMMATRIX World) noexcept;
-
-    /****************************************************************************
-     *
-     * 4D vector operations
-     *
-     ****************************************************************************/
-
-    bool        XM_CALLCONV     XMVector4Equal(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector4EqualR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector4EqualInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector4EqualIntR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector4NearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon) noexcept;
-    bool        XM_CALLCONV     XMVector4NotEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector4NotEqualInt(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector4Greater(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector4GreaterR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector4GreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    uint32_t    XM_CALLCONV     XMVector4GreaterOrEqualR(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector4Less(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector4LessOrEqual(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    bool        XM_CALLCONV     XMVector4InBounds(FXMVECTOR V, FXMVECTOR Bounds) noexcept;
-
-    bool        XM_CALLCONV     XMVector4IsNaN(FXMVECTOR V) noexcept;
-    bool        XM_CALLCONV     XMVector4IsInfinite(FXMVECTOR V) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMVector4Dot(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4Cross(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4LengthSq(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4ReciprocalLengthEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4ReciprocalLength(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4LengthEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4Length(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4NormalizeEst(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4Normalize(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4ClampLength(FXMVECTOR V, float LengthMin, float LengthMax) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4ClampLengthV(FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4Reflect(FXMVECTOR Incident, FXMVECTOR Normal) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4Refract(FXMVECTOR Incident, FXMVECTOR Normal, float RefractionIndex) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4RefractV(FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4Orthogonal(FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4AngleBetweenNormalsEst(FXMVECTOR N1, FXMVECTOR N2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4AngleBetweenNormals(FXMVECTOR N1, FXMVECTOR N2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4AngleBetweenVectors(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMVector4Transform(FXMVECTOR V, FXMMATRIX M) noexcept;
-    XMFLOAT4*   XM_CALLCONV     XMVector4TransformStream(_Out_writes_bytes_(sizeof(XMFLOAT4) + OutputStride * (VectorCount - 1)) XMFLOAT4* pOutputStream,
-                                                         _In_ size_t OutputStride,
-                                                         _In_reads_bytes_(sizeof(XMFLOAT4) + InputStride * (VectorCount - 1)) const XMFLOAT4* pInputStream,
-                                                         _In_ size_t InputStride, _In_ size_t VectorCount, _In_ FXMMATRIX M) noexcept;
-
-    /****************************************************************************
-     *
-     * Matrix operations
-     *
-     ****************************************************************************/
-
-    bool        XM_CALLCONV     XMMatrixIsNaN(FXMMATRIX M) noexcept;
-    bool        XM_CALLCONV     XMMatrixIsInfinite(FXMMATRIX M) noexcept;
-    bool        XM_CALLCONV     XMMatrixIsIdentity(FXMMATRIX M) noexcept;
-
-    XMMATRIX    XM_CALLCONV     XMMatrixMultiply(FXMMATRIX M1, CXMMATRIX M2) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixMultiplyTranspose(FXMMATRIX M1, CXMMATRIX M2) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixTranspose(FXMMATRIX M) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixInverse(_Out_opt_ XMVECTOR* pDeterminant, _In_ FXMMATRIX M) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixVectorTensorProduct(FXMVECTOR V1, FXMVECTOR V2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMMatrixDeterminant(FXMMATRIX M) noexcept;
-
-    _Success_(return)
-    bool        XM_CALLCONV     XMMatrixDecompose(_Out_ XMVECTOR* outScale, _Out_ XMVECTOR* outRotQuat, _Out_ XMVECTOR* outTrans, _In_ FXMMATRIX M) noexcept;
-
-    XMMATRIX    XM_CALLCONV     XMMatrixIdentity() noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixSet(float m00, float m01, float m02, float m03,
-                                            float m10, float m11, float m12, float m13,
-                                            float m20, float m21, float m22, float m23,
-                                            float m30, float m31, float m32, float m33) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixTranslation(float OffsetX, float OffsetY, float OffsetZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixTranslationFromVector(FXMVECTOR Offset) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixScaling(float ScaleX, float ScaleY, float ScaleZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixScalingFromVector(FXMVECTOR Scale) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixRotationX(float Angle) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixRotationY(float Angle) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixRotationZ(float Angle) noexcept;
-
-    // Rotates about y-axis (Yaw), then x-axis (Pitch), then z-axis (Roll)
-    XMMATRIX    XM_CALLCONV     XMMatrixRotationRollPitchYaw(float Pitch, float Yaw, float Roll) noexcept;
-
-    // Rotates about y-axis (Angles.y), then x-axis (Angles.x), then z-axis (Angles.z)
-    XMMATRIX    XM_CALLCONV     XMMatrixRotationRollPitchYawFromVector(FXMVECTOR Angles) noexcept;
-
-    XMMATRIX    XM_CALLCONV     XMMatrixRotationNormal(FXMVECTOR NormalAxis, float Angle) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixRotationAxis(FXMVECTOR Axis, float Angle) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixRotationQuaternion(FXMVECTOR Quaternion) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixTransformation2D(FXMVECTOR ScalingOrigin, float ScalingOrientation, FXMVECTOR Scaling,
-                                                         FXMVECTOR RotationOrigin, float Rotation, GXMVECTOR Translation) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixTransformation(FXMVECTOR ScalingOrigin, FXMVECTOR ScalingOrientationQuaternion, FXMVECTOR Scaling,
-                                                       GXMVECTOR RotationOrigin, HXMVECTOR RotationQuaternion, HXMVECTOR Translation) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixAffineTransformation2D(FXMVECTOR Scaling, FXMVECTOR RotationOrigin, float Rotation, FXMVECTOR Translation) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixAffineTransformation(FXMVECTOR Scaling, FXMVECTOR RotationOrigin, FXMVECTOR RotationQuaternion, GXMVECTOR Translation) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixReflect(FXMVECTOR ReflectionPlane) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixShadow(FXMVECTOR ShadowPlane, FXMVECTOR LightPosition) noexcept;
-
-    XMMATRIX    XM_CALLCONV     XMMatrixLookAtLH(FXMVECTOR EyePosition, FXMVECTOR FocusPosition, FXMVECTOR UpDirection) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixLookAtRH(FXMVECTOR EyePosition, FXMVECTOR FocusPosition, FXMVECTOR UpDirection) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixLookToLH(FXMVECTOR EyePosition, FXMVECTOR EyeDirection, FXMVECTOR UpDirection) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixLookToRH(FXMVECTOR EyePosition, FXMVECTOR EyeDirection, FXMVECTOR UpDirection) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixPerspectiveLH(float ViewWidth, float ViewHeight, float NearZ, float FarZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixPerspectiveRH(float ViewWidth, float ViewHeight, float NearZ, float FarZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixPerspectiveFovLH(float FovAngleY, float AspectRatio, float NearZ, float FarZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixPerspectiveFovRH(float FovAngleY, float AspectRatio, float NearZ, float FarZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixPerspectiveOffCenterLH(float ViewLeft, float ViewRight, float ViewBottom, float ViewTop, float NearZ, float FarZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixPerspectiveOffCenterRH(float ViewLeft, float ViewRight, float ViewBottom, float ViewTop, float NearZ, float FarZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixOrthographicLH(float ViewWidth, float ViewHeight, float NearZ, float FarZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixOrthographicRH(float ViewWidth, float ViewHeight, float NearZ, float FarZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixOrthographicOffCenterLH(float ViewLeft, float ViewRight, float ViewBottom, float ViewTop, float NearZ, float FarZ) noexcept;
-    XMMATRIX    XM_CALLCONV     XMMatrixOrthographicOffCenterRH(float ViewLeft, float ViewRight, float ViewBottom, float ViewTop, float NearZ, float FarZ) noexcept;
-
-
-    /****************************************************************************
-     *
-     * Quaternion operations
-     *
-     ****************************************************************************/
-
-    bool        XM_CALLCONV     XMQuaternionEqual(FXMVECTOR Q1, FXMVECTOR Q2) noexcept;
-    bool        XM_CALLCONV     XMQuaternionNotEqual(FXMVECTOR Q1, FXMVECTOR Q2) noexcept;
-
-    bool        XM_CALLCONV     XMQuaternionIsNaN(FXMVECTOR Q) noexcept;
-    bool        XM_CALLCONV     XMQuaternionIsInfinite(FXMVECTOR Q) noexcept;
-    bool        XM_CALLCONV     XMQuaternionIsIdentity(FXMVECTOR Q) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMQuaternionDot(FXMVECTOR Q1, FXMVECTOR Q2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionMultiply(FXMVECTOR Q1, FXMVECTOR Q2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionLengthSq(FXMVECTOR Q) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionReciprocalLength(FXMVECTOR Q) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionLength(FXMVECTOR Q) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionNormalizeEst(FXMVECTOR Q) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionNormalize(FXMVECTOR Q) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionConjugate(FXMVECTOR Q) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionInverse(FXMVECTOR Q) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionLn(FXMVECTOR Q) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionExp(FXMVECTOR Q) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionSlerp(FXMVECTOR Q0, FXMVECTOR Q1, float t) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionSlerpV(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR T) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionSquad(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, GXMVECTOR Q3, float t) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionSquadV(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, GXMVECTOR Q3, HXMVECTOR T) noexcept;
-    void        XM_CALLCONV     XMQuaternionSquadSetup(_Out_ XMVECTOR* pA, _Out_ XMVECTOR* pB, _Out_ XMVECTOR* pC, _In_ FXMVECTOR Q0, _In_ FXMVECTOR Q1, _In_ FXMVECTOR Q2, _In_ GXMVECTOR Q3) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionBaryCentric(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, float f, float g) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionBaryCentricV(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, GXMVECTOR F, HXMVECTOR G) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMQuaternionIdentity() noexcept;
-
-    // Rotates about y-axis (Yaw), then x-axis (Pitch), then z-axis (Roll)
-    XMVECTOR    XM_CALLCONV     XMQuaternionRotationRollPitchYaw(float Pitch, float Yaw, float Roll) noexcept;
-
-    // Rotates about y-axis (Angles.y), then x-axis (Angles.x), then z-axis (Angles.z)
-    XMVECTOR    XM_CALLCONV     XMQuaternionRotationRollPitchYawFromVector(FXMVECTOR Angles) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMQuaternionRotationNormal(FXMVECTOR NormalAxis, float Angle) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionRotationAxis(FXMVECTOR Axis, float Angle) noexcept;
-    XMVECTOR    XM_CALLCONV     XMQuaternionRotationMatrix(FXMMATRIX M) noexcept;
-
-    void        XM_CALLCONV     XMQuaternionToAxisAngle(_Out_ XMVECTOR* pAxis, _Out_ float* pAngle, _In_ FXMVECTOR Q) noexcept;
-
-    /****************************************************************************
-     *
-     * Plane operations
-     *
-     ****************************************************************************/
-
-    bool        XM_CALLCONV     XMPlaneEqual(FXMVECTOR P1, FXMVECTOR P2) noexcept;
-    bool        XM_CALLCONV     XMPlaneNearEqual(FXMVECTOR P1, FXMVECTOR P2, FXMVECTOR Epsilon) noexcept;
-    bool        XM_CALLCONV     XMPlaneNotEqual(FXMVECTOR P1, FXMVECTOR P2) noexcept;
-
-    bool        XM_CALLCONV     XMPlaneIsNaN(FXMVECTOR P) noexcept;
-    bool        XM_CALLCONV     XMPlaneIsInfinite(FXMVECTOR P) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMPlaneDot(FXMVECTOR P, FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMPlaneDotCoord(FXMVECTOR P, FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMPlaneDotNormal(FXMVECTOR P, FXMVECTOR V) noexcept;
-    XMVECTOR    XM_CALLCONV     XMPlaneNormalizeEst(FXMVECTOR P) noexcept;
-    XMVECTOR    XM_CALLCONV     XMPlaneNormalize(FXMVECTOR P) noexcept;
-    XMVECTOR    XM_CALLCONV     XMPlaneIntersectLine(FXMVECTOR P, FXMVECTOR LinePoint1, FXMVECTOR LinePoint2) noexcept;
-    void        XM_CALLCONV     XMPlaneIntersectPlane(_Out_ XMVECTOR* pLinePoint1, _Out_ XMVECTOR* pLinePoint2, _In_ FXMVECTOR P1, _In_ FXMVECTOR P2) noexcept;
-
-    // Transforms a plane given an inverse transpose matrix
-    XMVECTOR    XM_CALLCONV     XMPlaneTransform(FXMVECTOR P, FXMMATRIX ITM) noexcept;
-
-    // Transforms an array of planes given an inverse transpose matrix
-    XMFLOAT4*   XM_CALLCONV     XMPlaneTransformStream(_Out_writes_bytes_(sizeof(XMFLOAT4) + OutputStride * (PlaneCount - 1)) XMFLOAT4* pOutputStream,
-                                                       _In_ size_t OutputStride,
-                                                       _In_reads_bytes_(sizeof(XMFLOAT4) + InputStride * (PlaneCount - 1)) const XMFLOAT4* pInputStream,
-                                                       _In_ size_t InputStride, _In_ size_t PlaneCount, _In_ FXMMATRIX ITM) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMPlaneFromPointNormal(FXMVECTOR Point, FXMVECTOR Normal) noexcept;
-    XMVECTOR    XM_CALLCONV     XMPlaneFromPoints(FXMVECTOR Point1, FXMVECTOR Point2, FXMVECTOR Point3) noexcept;
-
-    /****************************************************************************
-     *
-     * Color operations
-     *
-     ****************************************************************************/
-
-    bool        XM_CALLCONV     XMColorEqual(FXMVECTOR C1, FXMVECTOR C2) noexcept;
-    bool        XM_CALLCONV     XMColorNotEqual(FXMVECTOR C1, FXMVECTOR C2) noexcept;
-    bool        XM_CALLCONV     XMColorGreater(FXMVECTOR C1, FXMVECTOR C2) noexcept;
-    bool        XM_CALLCONV     XMColorGreaterOrEqual(FXMVECTOR C1, FXMVECTOR C2) noexcept;
-    bool        XM_CALLCONV     XMColorLess(FXMVECTOR C1, FXMVECTOR C2) noexcept;
-    bool        XM_CALLCONV     XMColorLessOrEqual(FXMVECTOR C1, FXMVECTOR C2) noexcept;
-
-    bool        XM_CALLCONV     XMColorIsNaN(FXMVECTOR C) noexcept;
-    bool        XM_CALLCONV     XMColorIsInfinite(FXMVECTOR C) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMColorNegative(FXMVECTOR C) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorModulate(FXMVECTOR C1, FXMVECTOR C2) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorAdjustSaturation(FXMVECTOR C, float Saturation) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorAdjustContrast(FXMVECTOR C, float Contrast) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMColorRGBToHSL(FXMVECTOR rgb) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorHSLToRGB(FXMVECTOR hsl) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMColorRGBToHSV(FXMVECTOR rgb) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorHSVToRGB(FXMVECTOR hsv) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMColorRGBToYUV(FXMVECTOR rgb) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorYUVToRGB(FXMVECTOR yuv) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMColorRGBToYUV_HD(FXMVECTOR rgb) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorYUVToRGB_HD(FXMVECTOR yuv) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMColorRGBToYUV_UHD(FXMVECTOR rgb) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorYUVToRGB_UHD(FXMVECTOR yuv) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMColorRGBToXYZ(FXMVECTOR rgb) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorXYZToRGB(FXMVECTOR xyz) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMColorXYZToSRGB(FXMVECTOR xyz) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorSRGBToXYZ(FXMVECTOR srgb) noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMColorRGBToSRGB(FXMVECTOR rgb) noexcept;
-    XMVECTOR    XM_CALLCONV     XMColorSRGBToRGB(FXMVECTOR srgb) noexcept;
-
-
-    /****************************************************************************
-     *
-     * Miscellaneous operations
-     *
-     ****************************************************************************/
-
-    bool            XMVerifyCPUSupport() noexcept;
-
-    XMVECTOR    XM_CALLCONV     XMFresnelTerm(FXMVECTOR CosIncidentAngle, FXMVECTOR RefractionIndex) noexcept;
-
-    bool            XMScalarNearEqual(float S1, float S2, float Epsilon) noexcept;
-    float           XMScalarModAngle(float Value) noexcept;
-
-    float           XMScalarSin(float Value) noexcept;
-    float           XMScalarSinEst(float Value) noexcept;
-
-    float           XMScalarCos(float Value) noexcept;
-    float           XMScalarCosEst(float Value) noexcept;
-
-    void            XMScalarSinCos(_Out_ float* pSin, _Out_ float* pCos, float Value) noexcept;
-    void            XMScalarSinCosEst(_Out_ float* pSin, _Out_ float* pCos, float Value) noexcept;
-
-    float           XMScalarASin(float Value) noexcept;
-    float           XMScalarASinEst(float Value) noexcept;
-
-    float           XMScalarACos(float Value) noexcept;
-    float           XMScalarACosEst(float Value) noexcept;
-
-    /****************************************************************************
-     *
-     * Templates
-     *
-     ****************************************************************************/
-
-#if defined(__XNAMATH_H__) && defined(XMMin)
-    #undef XMMin
-#undef XMMax
-#endif
-
-    template<class T> inline T XMMin(T a, T b) noexcept { return (a < b) ? a : b; }
-    template<class T> inline T XMMax(T a, T b) noexcept { return (a > b) ? a : b; }
-
-    //------------------------------------------------------------------------------
-
-#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-
-// PermuteHelper internal template (SSE only)
-    namespace Internal
-    {
-        // Slow path fallback for permutes that do not map to a single SSE shuffle opcode.
-        template<uint32_t Shuffle, bool WhichX, bool WhichY, bool WhichZ, bool WhichW> struct PermuteHelper
-        {
-            static XMVECTOR     XM_CALLCONV     Permute(FXMVECTOR v1, FXMVECTOR v2) noexcept
-            {
-                static const XMVECTORU32 selectMask =
-                        { { {
-                                    WhichX ? 0xFFFFFFFF : 0,
-                                    WhichY ? 0xFFFFFFFF : 0,
-                                    WhichZ ? 0xFFFFFFFF : 0,
-                                    WhichW ? 0xFFFFFFFF : 0,
-                            } } };
-
-                XMVECTOR shuffled1 = XM_PERMUTE_PS(v1, Shuffle);
-                XMVECTOR shuffled2 = XM_PERMUTE_PS(v2, Shuffle);
-
-                XMVECTOR masked1 = _mm_andnot_ps(selectMask, shuffled1);
-                XMVECTOR masked2 = _mm_and_ps(selectMask, shuffled2);
-
-                return _mm_or_ps(masked1, masked2);
-            }
-        };
-
-        // Fast path for permutes that only read from the first vector.
-        template<uint32_t Shuffle> struct PermuteHelper<Shuffle, false, false, false, false>
-        {
-            static XMVECTOR     XM_CALLCONV     Permute(FXMVECTOR v1, FXMVECTOR) noexcept { return XM_PERMUTE_PS(v1, Shuffle); }
-        };
-
-        // Fast path for permutes that only read from the second vector.
-        template<uint32_t Shuffle> struct PermuteHelper<Shuffle, true, true, true, true>
-        {
-            static XMVECTOR     XM_CALLCONV     Permute(FXMVECTOR, FXMVECTOR v2) noexcept { return XM_PERMUTE_PS(v2, Shuffle); }
-        };
-
-        // Fast path for permutes that read XY from the first vector, ZW from the second.
-        template<uint32_t Shuffle> struct PermuteHelper<Shuffle, false, false, true, true>
-        {
-            static XMVECTOR     XM_CALLCONV     Permute(FXMVECTOR v1, FXMVECTOR v2) noexcept { return _mm_shuffle_ps(v1, v2, Shuffle); }
-        };
-
-        // Fast path for permutes that read XY from the second vector, ZW from the first.
-        template<uint32_t Shuffle> struct PermuteHelper<Shuffle, true, true, false, false>
-        {
-            static XMVECTOR     XM_CALLCONV     Permute(FXMVECTOR v1, FXMVECTOR v2) noexcept { return _mm_shuffle_ps(v2, v1, Shuffle); }
-        };
-    }
-
-#endif // _XM_SSE_INTRINSICS_ && !_XM_NO_INTRINSICS_
-
-    // General permute template
-    template<uint32_t PermuteX, uint32_t PermuteY, uint32_t PermuteZ, uint32_t PermuteW>
-    inline XMVECTOR     XM_CALLCONV     XMVectorPermute(FXMVECTOR V1, FXMVECTOR V2) noexcept
-    {
-        static_assert(PermuteX <= 7, "PermuteX template parameter out of range");
-        static_assert(PermuteY <= 7, "PermuteY template parameter out of range");
-        static_assert(PermuteZ <= 7, "PermuteZ template parameter out of range");
-        static_assert(PermuteW <= 7, "PermuteW template parameter out of range");
-
-#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-        constexpr uint32_t Shuffle = _MM_SHUFFLE(PermuteW & 3, PermuteZ & 3, PermuteY & 3, PermuteX & 3);
-
-        constexpr bool WhichX = PermuteX > 3;
-        constexpr bool WhichY = PermuteY > 3;
-        constexpr bool WhichZ = PermuteZ > 3;
-        constexpr bool WhichW = PermuteW > 3;
-
-        return Internal::PermuteHelper<Shuffle, WhichX, WhichY, WhichZ, WhichW>::Permute(V1, V2);
-#else
-
-        return XMVectorPermute(V1, V2, PermuteX, PermuteY, PermuteZ, PermuteW);
-
-#endif
-    }
-
-    // Special-case permute templates
-    template<> constexpr XMVECTOR XM_CALLCONV     XMVectorPermute<0, 1, 2, 3>(FXMVECTOR V1, FXMVECTOR) noexcept { return V1; }
-    template<> constexpr XMVECTOR XM_CALLCONV     XMVectorPermute<4, 5, 6, 7>(FXMVECTOR, FXMVECTOR V2) noexcept { return V2; }
-
-#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 1, 4, 5>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_movelh_ps(V1, V2); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<6, 7, 2, 3>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_movehl_ps(V1, V2); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 4, 1, 5>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_unpacklo_ps(V1, V2); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<2, 6, 3, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_unpackhi_ps(V1, V2); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<2, 3, 6, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_castpd_ps(_mm_unpackhi_pd(_mm_castps_pd(V1), _mm_castps_pd(V2))); }
-#endif
-
-#if defined(_XM_SSE4_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<4, 1, 2, 3>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0x1); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 5, 2, 3>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0x2); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<4, 5, 2, 3>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0x3); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 1, 6, 3>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0x4); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<4, 1, 6, 3>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0x5); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 5, 6, 3>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0x6); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<4, 5, 6, 3>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0x7); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 1, 2, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0x8); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<4, 1, 2, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0x9); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 5, 2, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0xA); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<4, 5, 2, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0xB); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 1, 6, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0xC); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<4, 1, 6, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0xD); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 5, 6, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return _mm_blend_ps(V1, V2, 0xE); }
-#endif
-
-#if defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-
-    // If the indices are all in the range 0-3 or 4-7, then use XMVectorSwizzle instead
-    // The mirror cases are not spelled out here as the programmer can always swap the arguments
-    // (i.e. prefer permutes where the X element comes from the V1 vector instead of the V2 vector)
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 1, 4, 5>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vget_low_f32(V1), vget_low_f32(V2)); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<1, 0, 4, 5>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vrev64_f32(vget_low_f32(V1)), vget_low_f32(V2)); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 1, 5, 4>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vget_low_f32(V1), vrev64_f32(vget_low_f32(V2))); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<1, 0, 5, 4>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vrev64_f32(vget_low_f32(V1)), vrev64_f32(vget_low_f32(V2))); }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<2, 3, 6, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vget_high_f32(V1), vget_high_f32(V2)); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<3, 2, 6, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vrev64_f32(vget_high_f32(V1)), vget_high_f32(V2)); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<2, 3, 7, 6>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vget_high_f32(V1), vrev64_f32(vget_high_f32(V2))); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<3, 2, 7, 6>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vrev64_f32(vget_high_f32(V1)), vrev64_f32(vget_high_f32(V2))); }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 1, 6, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vget_low_f32(V1), vget_high_f32(V2)); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<1, 0, 6, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vrev64_f32(vget_low_f32(V1)), vget_high_f32(V2)); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 1, 7, 6>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vget_low_f32(V1), vrev64_f32(vget_high_f32(V2))); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<1, 0, 7, 6>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vrev64_f32(vget_low_f32(V1)), vrev64_f32(vget_high_f32(V2))); }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<3, 2, 4, 5>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vrev64_f32(vget_high_f32(V1)), vget_low_f32(V2)); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<2, 3, 5, 4>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vget_high_f32(V1), vrev64_f32(vget_low_f32(V2))); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<3, 2, 5, 4>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vcombine_f32(vrev64_f32(vget_high_f32(V1)), vrev64_f32(vget_low_f32(V2))); }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 4, 2, 6>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vtrnq_f32(V1, V2).val[0]; }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<1, 5, 3, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vtrnq_f32(V1, V2).val[1]; }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 4, 1, 5>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vzipq_f32(V1, V2).val[0]; }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<2, 6, 3, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vzipq_f32(V1, V2).val[1]; }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<0, 2, 4, 6>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vuzpq_f32(V1, V2).val[0]; }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<1, 3, 5, 7>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vuzpq_f32(V1, V2).val[1]; }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<1, 2, 3, 4>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vextq_f32(V1, V2, 1); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<2, 3, 4, 5>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vextq_f32(V1, V2, 2); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorPermute<3, 4, 5, 6>(FXMVECTOR V1, FXMVECTOR V2) noexcept { return vextq_f32(V1, V2, 3); }
-
-#endif // _XM_ARM_NEON_INTRINSICS_ && !_XM_NO_INTRINSICS_
-
-    //------------------------------------------------------------------------------
-
-    // General swizzle template
-    template<uint32_t SwizzleX, uint32_t SwizzleY, uint32_t SwizzleZ, uint32_t SwizzleW>
-    inline XMVECTOR     XM_CALLCONV     XMVectorSwizzle(FXMVECTOR V) noexcept
-    {
-        static_assert(SwizzleX <= 3, "SwizzleX template parameter out of range");
-        static_assert(SwizzleY <= 3, "SwizzleY template parameter out of range");
-        static_assert(SwizzleZ <= 3, "SwizzleZ template parameter out of range");
-        static_assert(SwizzleW <= 3, "SwizzleW template parameter out of range");
-
-#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-        return XM_PERMUTE_PS(V, _MM_SHUFFLE(SwizzleW, SwizzleZ, SwizzleY, SwizzleX));
-#else
-
-        return XMVectorSwizzle(V, SwizzleX, SwizzleY, SwizzleZ, SwizzleW);
-
-#endif
-    }
-
-    // Specialized swizzles
-    template<> constexpr XMVECTOR XM_CALLCONV XMVectorSwizzle<0, 1, 2, 3>(FXMVECTOR V) noexcept { return V; }
-
-#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 1, 0, 1>(FXMVECTOR V) noexcept { return _mm_movelh_ps(V, V); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<2, 3, 2, 3>(FXMVECTOR V) noexcept { return _mm_movehl_ps(V, V); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 0, 1, 1>(FXMVECTOR V) noexcept { return _mm_unpacklo_ps(V, V); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<2, 2, 3, 3>(FXMVECTOR V) noexcept { return _mm_unpackhi_ps(V, V); }
-#endif
-
-#if defined(_XM_SSE3_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 0, 2, 2>(FXMVECTOR V) noexcept { return _mm_moveldup_ps(V); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<1, 1, 3, 3>(FXMVECTOR V) noexcept { return _mm_movehdup_ps(V); }
-#endif
-
-#if defined(_XM_AVX2_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_) && defined(_XM_FAVOR_INTEL_)
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 0, 0, 0>(FXMVECTOR V) noexcept { return _mm_broadcastss_ps(V); }
-#endif
-
-#if defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 0, 0, 0>(FXMVECTOR V) noexcept { return vdupq_lane_f32(vget_low_f32(V), 0); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<1, 1, 1, 1>(FXMVECTOR V) noexcept { return vdupq_lane_f32(vget_low_f32(V), 1); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<2, 2, 2, 2>(FXMVECTOR V) noexcept { return vdupq_lane_f32(vget_high_f32(V), 0); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<3, 3, 3, 3>(FXMVECTOR V) noexcept { return vdupq_lane_f32(vget_high_f32(V), 1); }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<1, 0, 3, 2>(FXMVECTOR V) noexcept { return vrev64q_f32(V); }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 1, 0, 1>(FXMVECTOR V) noexcept { float32x2_t vt = vget_low_f32(V); return vcombine_f32(vt, vt); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<2, 3, 2, 3>(FXMVECTOR V) noexcept { float32x2_t vt = vget_high_f32(V); return vcombine_f32(vt, vt); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<1, 0, 1, 0>(FXMVECTOR V) noexcept { float32x2_t vt = vrev64_f32(vget_low_f32(V)); return vcombine_f32(vt, vt); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<3, 2, 3, 2>(FXMVECTOR V) noexcept { float32x2_t vt = vrev64_f32(vget_high_f32(V)); return vcombine_f32(vt, vt); }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 1, 3, 2>(FXMVECTOR V) noexcept { return vcombine_f32(vget_low_f32(V), vrev64_f32(vget_high_f32(V))); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<1, 0, 2, 3>(FXMVECTOR V) noexcept { return vcombine_f32(vrev64_f32(vget_low_f32(V)), vget_high_f32(V)); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<2, 3, 1, 0>(FXMVECTOR V) noexcept { return vcombine_f32(vget_high_f32(V), vrev64_f32(vget_low_f32(V))); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<3, 2, 0, 1>(FXMVECTOR V) noexcept { return vcombine_f32(vrev64_f32(vget_high_f32(V)), vget_low_f32(V)); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<3, 2, 1, 0>(FXMVECTOR V) noexcept { return vcombine_f32(vrev64_f32(vget_high_f32(V)), vrev64_f32(vget_low_f32(V))); }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 0, 2, 2>(FXMVECTOR V) noexcept { return vtrnq_f32(V, V).val[0]; }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<1, 1, 3, 3>(FXMVECTOR V) noexcept { return vtrnq_f32(V, V).val[1]; }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 0, 1, 1>(FXMVECTOR V) noexcept { return vzipq_f32(V, V).val[0]; }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<2, 2, 3, 3>(FXMVECTOR V) noexcept { return vzipq_f32(V, V).val[1]; }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<0, 2, 0, 2>(FXMVECTOR V) noexcept { return vuzpq_f32(V, V).val[0]; }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<1, 3, 1, 3>(FXMVECTOR V) noexcept { return vuzpq_f32(V, V).val[1]; }
-
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<1, 2, 3, 0>(FXMVECTOR V) noexcept { return vextq_f32(V, V, 1); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<2, 3, 0, 1>(FXMVECTOR V) noexcept { return vextq_f32(V, V, 2); }
-    template<> inline XMVECTOR      XM_CALLCONV     XMVectorSwizzle<3, 0, 1, 2>(FXMVECTOR V) noexcept { return vextq_f32(V, V, 3); }
-
-#endif // _XM_ARM_NEON_INTRINSICS_ && !_XM_NO_INTRINSICS_
-
-    //------------------------------------------------------------------------------
-
-    template<uint32_t Elements>
-    inline XMVECTOR     XM_CALLCONV     XMVectorShiftLeft(FXMVECTOR V1, FXMVECTOR V2) noexcept
-    {
-        static_assert(Elements < 4, "Elements template parameter out of range");
-        return XMVectorPermute<Elements, (Elements + 1), (Elements + 2), (Elements + 3)>(V1, V2);
-    }
-
-    template<uint32_t Elements>
-    inline XMVECTOR     XM_CALLCONV     XMVectorRotateLeft(FXMVECTOR V) noexcept
-    {
-        static_assert(Elements < 4, "Elements template parameter out of range");
-        return XMVectorSwizzle<Elements & 3, (Elements + 1) & 3, (Elements + 2) & 3, (Elements + 3) & 3>(V);
-    }
-
-    template<uint32_t Elements>
-    inline XMVECTOR     XM_CALLCONV     XMVectorRotateRight(FXMVECTOR V) noexcept
-    {
-        static_assert(Elements < 4, "Elements template parameter out of range");
-        return XMVectorSwizzle<(4 - Elements) & 3, (5 - Elements) & 3, (6 - Elements) & 3, (7 - Elements) & 3>(V);
-    }
-
-    template<uint32_t VSLeftRotateElements, uint32_t Select0, uint32_t Select1, uint32_t Select2, uint32_t Select3>
-    inline XMVECTOR     XM_CALLCONV     XMVectorInsert(FXMVECTOR VD, FXMVECTOR VS) noexcept
-    {
-        XMVECTOR Control = XMVectorSelectControl(Select0 & 1, Select1 & 1, Select2 & 1, Select3 & 1);
-        return XMVectorSelect(VD, XMVectorRotateLeft<VSLeftRotateElements>(VS), Control);
-    }
-
-    /****************************************************************************
-     *
-     * Globals
-     *
-     ****************************************************************************/
-
-    // The purpose of the following global constants is to prevent redundant
-    // reloading of the constants when they are referenced by more than one
-    // separate inline math routine called within the same function.  Declaring
-    // a constant locally within a routine is sufficient to prevent redundant
-    // reloads of that constant when that single routine is called multiple
-    // times in a function, but if the constant is used (and declared) in a
-    // separate math routine it would be reloaded.
-
-#ifndef XMGLOBALCONST
-#if defined(__GNUC__) && !defined(__MINGW32__)
-#define XMGLOBALCONST extern const __attribute__((weak))
-#else
-#define XMGLOBALCONST extern const __declspec(selectany)
-#endif
-#endif
-
-    XMGLOBALCONST XMVECTORF32 g_XMSinCoefficients0 = { { { -0.16666667f, +0.0083333310f, -0.00019840874f, +2.7525562e-06f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMSinCoefficients1 = { { { -2.3889859e-08f, -0.16665852f /*Est1*/, +0.0083139502f /*Est2*/, -0.00018524670f /*Est3*/ } } };
-    XMGLOBALCONST XMVECTORF32 g_XMCosCoefficients0 = { { { -0.5f, +0.041666638f, -0.0013888378f, +2.4760495e-05f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMCosCoefficients1 = { { { -2.6051615e-07f, -0.49992746f /*Est1*/, +0.041493919f /*Est2*/, -0.0012712436f /*Est3*/ } } };
-    XMGLOBALCONST XMVECTORF32 g_XMTanCoefficients0 = { { { 1.0f, 0.333333333f, 0.133333333f, 5.396825397e-2f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMTanCoefficients1 = { { { 2.186948854e-2f, 8.863235530e-3f, 3.592128167e-3f, 1.455834485e-3f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMTanCoefficients2 = { { { 5.900274264e-4f, 2.391290764e-4f, 9.691537707e-5f, 3.927832950e-5f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMArcCoefficients0 = { { { +1.5707963050f, -0.2145988016f, +0.0889789874f, -0.0501743046f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMArcCoefficients1 = { { { +0.0308918810f, -0.0170881256f, +0.0066700901f, -0.0012624911f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMATanCoefficients0 = { { { -0.3333314528f, +0.1999355085f, -0.1420889944f, +0.1065626393f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMATanCoefficients1 = { { { -0.0752896400f, +0.0429096138f, -0.0161657367f, +0.0028662257f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMATanEstCoefficients0 = { { { +0.999866f, +0.999866f, +0.999866f, +0.999866f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMATanEstCoefficients1 = { { { -0.3302995f, +0.180141f, -0.085133f, +0.0208351f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMTanEstCoefficients = { { { 2.484f, -1.954923183e-1f, 2.467401101f, XM_1DIVPI } } };
-    XMGLOBALCONST XMVECTORF32 g_XMArcEstCoefficients = { { { +1.5707288f, -0.2121144f, +0.0742610f, -0.0187293f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMPiConstants0 = { { { XM_PI, XM_2PI, XM_1DIVPI, XM_1DIV2PI } } };
-    XMGLOBALCONST XMVECTORF32 g_XMIdentityR0 = { { { 1.0f, 0.0f, 0.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMIdentityR1 = { { { 0.0f, 1.0f, 0.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMIdentityR2 = { { { 0.0f, 0.0f, 1.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMIdentityR3 = { { { 0.0f, 0.0f, 0.0f, 1.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR0 = { { { -1.0f, 0.0f, 0.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR1 = { { { 0.0f, -1.0f, 0.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR2 = { { { 0.0f, 0.0f, -1.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR3 = { { { 0.0f, 0.0f, 0.0f, -1.0f } } };
-    XMGLOBALCONST XMVECTORU32 g_XMNegativeZero = { { { 0x80000000, 0x80000000, 0x80000000, 0x80000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMNegate3 = { { { 0x80000000, 0x80000000, 0x80000000, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskXY = { { { 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMask3 = { { { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskX = { { { 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskY = { { { 0x00000000, 0xFFFFFFFF, 0x00000000, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskZ = { { { 0x00000000, 0x00000000, 0xFFFFFFFF, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskW = { { { 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF } } };
-    XMGLOBALCONST XMVECTORF32 g_XMOne = { { { 1.0f, 1.0f, 1.0f, 1.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMOne3 = { { { 1.0f, 1.0f, 1.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMZero = { { { 0.0f, 0.0f, 0.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMTwo = { { { 2.f, 2.f, 2.f, 2.f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMFour = { { { 4.f, 4.f, 4.f, 4.f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMSix = { { { 6.f, 6.f, 6.f, 6.f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegativeOne = { { { -1.0f, -1.0f, -1.0f, -1.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMOneHalf = { { { 0.5f, 0.5f, 0.5f, 0.5f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegativeOneHalf = { { { -0.5f, -0.5f, -0.5f, -0.5f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegativeTwoPi = { { { -XM_2PI, -XM_2PI, -XM_2PI, -XM_2PI } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegativePi = { { { -XM_PI, -XM_PI, -XM_PI, -XM_PI } } };
-    XMGLOBALCONST XMVECTORF32 g_XMHalfPi = { { { XM_PIDIV2, XM_PIDIV2, XM_PIDIV2, XM_PIDIV2 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMPi = { { { XM_PI, XM_PI, XM_PI, XM_PI } } };
-    XMGLOBALCONST XMVECTORF32 g_XMReciprocalPi = { { { XM_1DIVPI, XM_1DIVPI, XM_1DIVPI, XM_1DIVPI } } };
-    XMGLOBALCONST XMVECTORF32 g_XMTwoPi = { { { XM_2PI, XM_2PI, XM_2PI, XM_2PI } } };
-    XMGLOBALCONST XMVECTORF32 g_XMReciprocalTwoPi = { { { XM_1DIV2PI, XM_1DIV2PI, XM_1DIV2PI, XM_1DIV2PI } } };
-    XMGLOBALCONST XMVECTORF32 g_XMEpsilon = { { { 1.192092896e-7f, 1.192092896e-7f, 1.192092896e-7f, 1.192092896e-7f } } };
-    XMGLOBALCONST XMVECTORI32 g_XMInfinity = { { { 0x7F800000, 0x7F800000, 0x7F800000, 0x7F800000 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMQNaN = { { { 0x7FC00000, 0x7FC00000, 0x7FC00000, 0x7FC00000 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMQNaNTest = { { { 0x007FFFFF, 0x007FFFFF, 0x007FFFFF, 0x007FFFFF } } };
-    XMGLOBALCONST XMVECTORI32 g_XMAbsMask = { { { 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF } } };
-    XMGLOBALCONST XMVECTORI32 g_XMFltMin = { { { 0x00800000, 0x00800000, 0x00800000, 0x00800000 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMFltMax = { { { 0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFF } } };
-    XMGLOBALCONST XMVECTORU32 g_XMNegOneMask = { { { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskA8R8G8B8 = { { { 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMFlipA8R8G8B8 = { { { 0x00000000, 0x00000000, 0x00000000, 0x80000000 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMFixAA8R8G8B8 = { { { 0.0f, 0.0f, 0.0f, float(0x80000000U) } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNormalizeA8R8G8B8 = { { { 1.0f / (255.0f * float(0x10000)), 1.0f / (255.0f * float(0x100)), 1.0f / 255.0f, 1.0f / (255.0f * float(0x1000000)) } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskA2B10G10R10 = { { { 0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMFlipA2B10G10R10 = { { { 0x00000200, 0x00080000, 0x20000000, 0x80000000 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMFixAA2B10G10R10 = { { { -512.0f, -512.0f * float(0x400), -512.0f * float(0x100000), float(0x80000000U) } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNormalizeA2B10G10R10 = { { { 1.0f / 511.0f, 1.0f / (511.0f * float(0x400)), 1.0f / (511.0f * float(0x100000)), 1.0f / (3.0f * float(0x40000000)) } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskX16Y16 = { { { 0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMFlipX16Y16 = { { { 0x00008000, 0x00000000, 0x00000000, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMFixX16Y16 = { { { -32768.0f, 0.0f, 0.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNormalizeX16Y16 = { { { 1.0f / 32767.0f, 1.0f / (32767.0f * 65536.0f), 0.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskX16Y16Z16W16 = { { { 0x0000FFFF, 0x0000FFFF, 0xFFFF0000, 0xFFFF0000 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMFlipX16Y16Z16W16 = { { { 0x00008000, 0x00008000, 0x00000000, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMFixX16Y16Z16W16 = { { { -32768.0f, -32768.0f, 0.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNormalizeX16Y16Z16W16 = { { { 1.0f / 32767.0f, 1.0f / 32767.0f, 1.0f / (32767.0f * 65536.0f), 1.0f / (32767.0f * 65536.0f) } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNoFraction = { { { 8388608.0f, 8388608.0f, 8388608.0f, 8388608.0f } } };
-    XMGLOBALCONST XMVECTORI32 g_XMMaskByte = { { { 0x000000FF, 0x000000FF, 0x000000FF, 0x000000FF } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegateX = { { { -1.0f, 1.0f, 1.0f, 1.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegateY = { { { 1.0f, -1.0f, 1.0f, 1.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegateZ = { { { 1.0f, 1.0f, -1.0f, 1.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMNegateW = { { { 1.0f, 1.0f, 1.0f, -1.0f } } };
-    XMGLOBALCONST XMVECTORU32 g_XMSelect0101 = { { { XM_SELECT_0, XM_SELECT_1, XM_SELECT_0, XM_SELECT_1 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMSelect1010 = { { { XM_SELECT_1, XM_SELECT_0, XM_SELECT_1, XM_SELECT_0 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMOneHalfMinusEpsilon = { { { 0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD } } };
-    XMGLOBALCONST XMVECTORU32 g_XMSelect1000 = { { { XM_SELECT_1, XM_SELECT_0, XM_SELECT_0, XM_SELECT_0 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMSelect1100 = { { { XM_SELECT_1, XM_SELECT_1, XM_SELECT_0, XM_SELECT_0 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMSelect1110 = { { { XM_SELECT_1, XM_SELECT_1, XM_SELECT_1, XM_SELECT_0 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMSelect1011 = { { { XM_SELECT_1, XM_SELECT_0, XM_SELECT_1, XM_SELECT_1 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMFixupY16 = { { { 1.0f, 1.0f / 65536.0f, 0.0f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMFixupY16W16 = { { { 1.0f, 1.0f, 1.0f / 65536.0f, 1.0f / 65536.0f } } };
-    XMGLOBALCONST XMVECTORU32 g_XMFlipY = { { { 0, 0x80000000, 0, 0 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMFlipZ = { { { 0, 0, 0x80000000, 0 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMFlipW = { { { 0, 0, 0, 0x80000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMFlipYZ = { { { 0, 0x80000000, 0x80000000, 0 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMFlipZW = { { { 0, 0, 0x80000000, 0x80000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMFlipYW = { { { 0, 0x80000000, 0, 0x80000000 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMMaskDec4 = { { { 0x3FF, 0x3FF << 10, 0x3FF << 20, static_cast<int>(0xC0000000) } } };
-    XMGLOBALCONST XMVECTORI32 g_XMXorDec4 = { { { 0x200, 0x200 << 10, 0x200 << 20, 0 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMAddUDec4 = { { { 0, 0, 0, 32768.0f * 65536.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMAddDec4 = { { { -512.0f, -512.0f * 1024.0f, -512.0f * 1024.0f * 1024.0f, 0 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMMulDec4 = { { { 1.0f, 1.0f / 1024.0f, 1.0f / (1024.0f * 1024.0f), 1.0f / (1024.0f * 1024.0f * 1024.0f) } } };
-    XMGLOBALCONST XMVECTORU32 g_XMMaskByte4 = { { { 0xFF, 0xFF00, 0xFF0000, 0xFF000000 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMXorByte4 = { { { 0x80, 0x8000, 0x800000, 0x00000000 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMAddByte4 = { { { -128.0f, -128.0f * 256.0f, -128.0f * 65536.0f, 0 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMFixUnsigned = { { { 32768.0f * 65536.0f, 32768.0f * 65536.0f, 32768.0f * 65536.0f, 32768.0f * 65536.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMMaxInt = { { { 65536.0f * 32768.0f - 128.0f, 65536.0f * 32768.0f - 128.0f, 65536.0f * 32768.0f - 128.0f, 65536.0f * 32768.0f - 128.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMMaxUInt = { { { 65536.0f * 65536.0f - 256.0f, 65536.0f * 65536.0f - 256.0f, 65536.0f * 65536.0f - 256.0f, 65536.0f * 65536.0f - 256.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMUnsignedFix = { { { 32768.0f * 65536.0f, 32768.0f * 65536.0f, 32768.0f * 65536.0f, 32768.0f * 65536.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMsrgbScale = { { { 12.92f, 12.92f, 12.92f, 1.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMsrgbA = { { { 0.055f, 0.055f, 0.055f, 0.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMsrgbA1 = { { { 1.055f, 1.055f, 1.055f, 1.0f } } };
-    XMGLOBALCONST XMVECTORI32 g_XMExponentBias = { { { 127, 127, 127, 127 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMSubnormalExponent = { { { -126, -126, -126, -126 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMNumTrailing = { { { 23, 23, 23, 23 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMMinNormal = { { { 0x00800000, 0x00800000, 0x00800000, 0x00800000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMNegInfinity = { { { 0xFF800000, 0xFF800000, 0xFF800000, 0xFF800000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMNegQNaN = { { { 0xFFC00000, 0xFFC00000, 0xFFC00000, 0xFFC00000 } } };
-    XMGLOBALCONST XMVECTORI32 g_XMBin128 = { { { 0x43000000, 0x43000000, 0x43000000, 0x43000000 } } };
-    XMGLOBALCONST XMVECTORU32 g_XMBinNeg150 = { { { 0xC3160000, 0xC3160000, 0xC3160000, 0xC3160000 } } };
-    XMGLOBALCONST XMVECTORI32 g_XM253 = { { { 253, 253, 253, 253 } } };
-    XMGLOBALCONST XMVECTORF32 g_XMExpEst1 = { { { -6.93147182e-1f, -6.93147182e-1f, -6.93147182e-1f, -6.93147182e-1f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMExpEst2 = { { { +2.40226462e-1f, +2.40226462e-1f, +2.40226462e-1f, +2.40226462e-1f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMExpEst3 = { { { -5.55036440e-2f, -5.55036440e-2f, -5.55036440e-2f, -5.55036440e-2f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMExpEst4 = { { { +9.61597636e-3f, +9.61597636e-3f, +9.61597636e-3f, +9.61597636e-3f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMExpEst5 = { { { -1.32823968e-3f, -1.32823968e-3f, -1.32823968e-3f, -1.32823968e-3f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMExpEst6 = { { { +1.47491097e-4f, +1.47491097e-4f, +1.47491097e-4f, +1.47491097e-4f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMExpEst7 = { { { -1.08635004e-5f, -1.08635004e-5f, -1.08635004e-5f, -1.08635004e-5f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLogEst0 = { { { +1.442693f, +1.442693f, +1.442693f, +1.442693f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLogEst1 = { { { -0.721242f, -0.721242f, -0.721242f, -0.721242f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLogEst2 = { { { +0.479384f, +0.479384f, +0.479384f, +0.479384f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLogEst3 = { { { -0.350295f, -0.350295f, -0.350295f, -0.350295f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLogEst4 = { { { +0.248590f, +0.248590f, +0.248590f, +0.248590f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLogEst5 = { { { -0.145700f, -0.145700f, -0.145700f, -0.145700f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLogEst6 = { { { +0.057148f, +0.057148f, +0.057148f, +0.057148f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLogEst7 = { { { -0.010578f, -0.010578f, -0.010578f, -0.010578f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLgE = { { { +1.442695f, +1.442695f, +1.442695f, +1.442695f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMInvLgE = { { { +6.93147182e-1f, +6.93147182e-1f, +6.93147182e-1f, +6.93147182e-1f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMLg10 = { { { +3.321928f, +3.321928f, +3.321928f, +3.321928f } } };
-    XMGLOBALCONST XMVECTORF32 g_XMInvLg10 = { { { +3.010299956e-1f, +3.010299956e-1f, +3.010299956e-1f, +3.010299956e-1f } } };
-    XMGLOBALCONST XMVECTORF32 g_UByteMax = { { { 255.0f, 255.0f, 255.0f, 255.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_ByteMin = { { { -127.0f, -127.0f, -127.0f, -127.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_ByteMax = { { { 127.0f, 127.0f, 127.0f, 127.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_ShortMin = { { { -32767.0f, -32767.0f, -32767.0f, -32767.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_ShortMax = { { { 32767.0f, 32767.0f, 32767.0f, 32767.0f } } };
-    XMGLOBALCONST XMVECTORF32 g_UShortMax = { { { 65535.0f, 65535.0f, 65535.0f, 65535.0f } } };
-
-    /****************************************************************************
-     *
-     * Implementation
-     *
-     ****************************************************************************/
-
-#ifdef _MSC_VER
-    #pragma warning(push)
-#pragma warning(disable:4068 4214 4204 4365 4616 4640 6001 6101)
-     // C4068/4616: ignore unknown pragmas
-     // C4214/4204: nonstandard extension used
-     // C4365/4640: Off by default noise
-     // C6001/6101: False positives
-#endif
-
-#ifdef _PREFAST_
-    #pragma prefast(push)
-#pragma prefast(disable : 25000, "FXMVECTOR is 16 bytes")
-#pragma prefast(disable : 26495, "Union initialization confuses /analyze")
-#endif
-
-#ifdef __clang__
-    #pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wundefined-reinterpret-cast"
-#endif
-
-//------------------------------------------------------------------------------
-
-    inline XMVECTOR XM_CALLCONV XMVectorSetBinaryConstant(uint32_t C0, uint32_t C1, uint32_t C2, uint32_t C3) noexcept
-    {
-#if defined(_XM_NO_INTRINSICS_)
-        XMVECTORU32 vResult;
-        vResult.u[0] = (0 - (C0 & 1)) & 0x3F800000;
-        vResult.u[1] = (0 - (C1 & 1)) & 0x3F800000;
-        vResult.u[2] = (0 - (C2 & 1)) & 0x3F800000;
-        vResult.u[3] = (0 - (C3 & 1)) & 0x3F800000;
-        return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-        XMVECTORU32 vResult;
-        vResult.u[0] = (0 - (C0 & 1)) & 0x3F800000;
-        vResult.u[1] = (0 - (C1 & 1)) & 0x3F800000;
-        vResult.u[2] = (0 - (C2 & 1)) & 0x3F800000;
-        vResult.u[3] = (0 - (C3 & 1)) & 0x3F800000;
-        return vResult.v;
-#else // XM_SSE_INTRINSICS_
-        static const XMVECTORU32 g_vMask1 = { { { 1, 1, 1, 1 } } };
-        // Move the parms to a vector
-        __m128i vTemp = _mm_set_epi32(static_cast<int>(C3), static_cast<int>(C2), static_cast<int>(C1), static_cast<int>(C0));
-        // Mask off the low bits
-        vTemp = _mm_and_si128(vTemp, g_vMask1);
-        // 0xFFFFFFFF on true bits
-        vTemp = _mm_cmpeq_epi32(vTemp, g_vMask1);
-        // 0xFFFFFFFF -> 1.0f, 0x00000000 -> 0.0f
-        vTemp = _mm_and_si128(vTemp, g_XMOne);
-        return _mm_castsi128_ps(vTemp);
-#endif
-    }
-
-    //------------------------------------------------------------------------------
-
-    inline XMVECTOR XM_CALLCONV XMVectorSplatConstant(int32_t IntConstant, uint32_t DivExponent) noexcept
-    {
-        assert(IntConstant >= -16 && IntConstant <= 15);
-        assert(DivExponent < 32);
-#if defined(_XM_NO_INTRINSICS_)
-
-        using DirectX::XMConvertVectorIntToFloat;
-
-        XMVECTORI32 V = { { { IntConstant, IntConstant, IntConstant, IntConstant } } };
-        return XMConvertVectorIntToFloat(V.v, DivExponent);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-        // Splat the int
-        int32x4_t vScale = vdupq_n_s32(IntConstant);
-        // Convert to a float
-        XMVECTOR vResult = vcvtq_f32_s32(vScale);
-        // Convert DivExponent into 1.0f/(1<<DivExponent)
-        uint32_t uScale = 0x3F800000U - (DivExponent << 23);
-        // Splat the scalar value (It's really a float)
-        vScale = vreinterpretq_s32_u32(vdupq_n_u32(uScale));
-        // Multiply by the reciprocal (Perform a right shift by DivExponent)
-        vResult = vmulq_f32(vResult, reinterpret_cast<const float32x4_t*>(&vScale)[0]);
-        return vResult;
-#else // XM_SSE_INTRINSICS_
-        // Splat the int
-        __m128i vScale = _mm_set1_epi32(IntConstant);
-        // Convert to a float
-        XMVECTOR vResult = _mm_cvtepi32_ps(vScale);
-        // Convert DivExponent into 1.0f/(1<<DivExponent)
-        uint32_t uScale = 0x3F800000U - (DivExponent << 23);
-        // Splat the scalar value (It's really a float)
-        vScale = _mm_set1_epi32(static_cast<int>(uScale));
-        // Multiply by the reciprocal (Perform a right shift by DivExponent)
-        vResult = _mm_mul_ps(vResult, _mm_castsi128_ps(vScale));
-        return vResult;
-#endif
-    }
-
-    //------------------------------------------------------------------------------
-
-    inline XMVECTOR XM_CALLCONV XMVectorSplatConstantInt(int32_t IntConstant) noexcept
-    {
-        assert(IntConstant >= -16 && IntConstant <= 15);
-#if defined(_XM_NO_INTRINSICS_)
-
-        XMVECTORI32 V = { { { IntConstant, IntConstant, IntConstant, IntConstant } } };
-        return V.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-        int32x4_t V = vdupq_n_s32(IntConstant);
-        return reinterpret_cast<float32x4_t*>(&V)[0];
-#else // XM_SSE_INTRINSICS_
-        __m128i V = _mm_set1_epi32(IntConstant);
-        return _mm_castsi128_ps(V);
-#endif
-    }
-
-#include "DirectXMathConvert.inl"
-#include "DirectXMathVector.inl"
-#include "DirectXMathMatrix.inl"
-#include "DirectXMathMisc.inl"
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-} // namespace DirectX
-
diff --git a/thirdparty/directxmath/DirectXMathConvert.inl b/thirdparty/directxmath/DirectXMathConvert.inl
deleted file mode 100644
index a05a92c..0000000
--- a/thirdparty/directxmath/DirectXMathConvert.inl
+++ /dev/null
@@ -1,2191 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXMathConvert.inl -- SIMD C++ Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-/****************************************************************************
- *
- * Data conversion
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4701)
-// C4701: false positives
-#endif
-
-inline XMVECTOR XM_CALLCONV XMConvertVectorIntToFloat
-        (
-                FXMVECTOR    VInt,
-                uint32_t     DivExponent
-        ) noexcept
-{
-    assert(DivExponent < 32);
-#if defined(_XM_NO_INTRINSICS_)
-    float fScale = 1.0f / static_cast<float>(1U << DivExponent);
-    uint32_t ElementIndex = 0;
-    XMVECTOR Result;
-    do {
-        auto iTemp = static_cast<int32_t>(VInt.vector4_u32[ElementIndex]);
-        Result.vector4_f32[ElementIndex] = static_cast<float>(iTemp)* fScale;
-    } while (++ElementIndex < 4);
-    return Result;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float fScale = 1.0f / static_cast<float>(1U << DivExponent);
-    float32x4_t vResult = vcvtq_f32_s32(vreinterpretq_s32_f32(VInt));
-    return vmulq_n_f32(vResult, fScale);
-#else // _XM_SSE_INTRINSICS_
-    // Convert to floats
-    XMVECTOR vResult = _mm_cvtepi32_ps(_mm_castps_si128(VInt));
-    // Convert DivExponent into 1.0f/(1<<DivExponent)
-    uint32_t uScale = 0x3F800000U - (DivExponent << 23);
-    // Splat the scalar value
-    __m128i vScale = _mm_set1_epi32(static_cast<int>(uScale));
-    vResult = _mm_mul_ps(vResult, _mm_castsi128_ps(vScale));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMConvertVectorFloatToInt
-        (
-                FXMVECTOR    VFloat,
-                uint32_t     MulExponent
-        ) noexcept
-{
-    assert(MulExponent < 32);
-#if defined(_XM_NO_INTRINSICS_)
-    // Get the scalar factor.
-    auto fScale = static_cast<float>(1U << MulExponent);
-    uint32_t ElementIndex = 0;
-    XMVECTOR Result;
-    do {
-        int32_t iResult;
-        float fTemp = VFloat.vector4_f32[ElementIndex] * fScale;
-        if (fTemp <= -(65536.0f * 32768.0f))
-        {
-            iResult = (-0x7FFFFFFF) - 1;
-        }
-        else if (fTemp > (65536.0f * 32768.0f) - 128.0f)
-        {
-            iResult = 0x7FFFFFFF;
-        }
-        else {
-            iResult = static_cast<int32_t>(fTemp);
-        }
-        Result.vector4_u32[ElementIndex] = static_cast<uint32_t>(iResult);
-    } while (++ElementIndex < 4);
-    return Result;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t vResult = vmulq_n_f32(VFloat, static_cast<float>(1U << MulExponent));
-    // In case of positive overflow, detect it
-    uint32x4_t vOverflow = vcgtq_f32(vResult, g_XMMaxInt);
-    // Float to int conversion
-    int32x4_t vResulti = vcvtq_s32_f32(vResult);
-    // If there was positive overflow, set to 0x7FFFFFFF
-    vResult = vreinterpretq_f32_u32(vandq_u32(vOverflow, g_XMAbsMask));
-    vOverflow = vbicq_u32(vreinterpretq_u32_s32(vResulti), vOverflow);
-    vOverflow = vorrq_u32(vOverflow, vreinterpretq_u32_f32(vResult));
-    return vreinterpretq_f32_u32(vOverflow);
-#else // _XM_SSE_INTRINSICS_
-    XMVECTOR vResult = _mm_set_ps1(static_cast<float>(1U << MulExponent));
-    vResult = _mm_mul_ps(vResult, VFloat);
-    // In case of positive overflow, detect it
-    XMVECTOR vOverflow = _mm_cmpgt_ps(vResult, g_XMMaxInt);
-    // Float to int conversion
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // If there was positive overflow, set to 0x7FFFFFFF
-    vResult = _mm_and_ps(vOverflow, g_XMAbsMask);
-    vOverflow = _mm_andnot_ps(vOverflow, _mm_castsi128_ps(vResulti));
-    vOverflow = _mm_or_ps(vOverflow, vResult);
-    return vOverflow;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMConvertVectorUIntToFloat
-        (
-                FXMVECTOR     VUInt,
-                uint32_t      DivExponent
-        ) noexcept
-{
-    assert(DivExponent < 32);
-#if defined(_XM_NO_INTRINSICS_)
-    float fScale = 1.0f / static_cast<float>(1U << DivExponent);
-    uint32_t ElementIndex = 0;
-    XMVECTOR Result;
-    do {
-        Result.vector4_f32[ElementIndex] = static_cast<float>(VUInt.vector4_u32[ElementIndex])* fScale;
-    } while (++ElementIndex < 4);
-    return Result;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float fScale = 1.0f / static_cast<float>(1U << DivExponent);
-    float32x4_t vResult = vcvtq_f32_u32(vreinterpretq_u32_f32(VUInt));
-    return vmulq_n_f32(vResult, fScale);
-#else // _XM_SSE_INTRINSICS_
-    // For the values that are higher than 0x7FFFFFFF, a fixup is needed
-    // Determine which ones need the fix.
-    XMVECTOR vMask = _mm_and_ps(VUInt, g_XMNegativeZero);
-    // Force all values positive
-    XMVECTOR vResult = _mm_xor_ps(VUInt, vMask);
-    // Convert to floats
-    vResult = _mm_cvtepi32_ps(_mm_castps_si128(vResult));
-    // Convert 0x80000000 -> 0xFFFFFFFF
-    __m128i iMask = _mm_srai_epi32(_mm_castps_si128(vMask), 31);
-    // For only the ones that are too big, add the fixup
-    vMask = _mm_and_ps(_mm_castsi128_ps(iMask), g_XMFixUnsigned);
-    vResult = _mm_add_ps(vResult, vMask);
-    // Convert DivExponent into 1.0f/(1<<DivExponent)
-    uint32_t uScale = 0x3F800000U - (DivExponent << 23);
-    // Splat
-    iMask = _mm_set1_epi32(static_cast<int>(uScale));
-    vResult = _mm_mul_ps(vResult, _mm_castsi128_ps(iMask));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMConvertVectorFloatToUInt
-        (
-                FXMVECTOR     VFloat,
-                uint32_t      MulExponent
-        ) noexcept
-{
-    assert(MulExponent < 32);
-#if defined(_XM_NO_INTRINSICS_)
-    // Get the scalar factor.
-    auto fScale = static_cast<float>(1U << MulExponent);
-    uint32_t ElementIndex = 0;
-    XMVECTOR Result;
-    do {
-        uint32_t uResult;
-        float fTemp = VFloat.vector4_f32[ElementIndex] * fScale;
-        if (fTemp <= 0.0f)
-        {
-            uResult = 0;
-        }
-        else if (fTemp >= (65536.0f * 65536.0f))
-        {
-            uResult = 0xFFFFFFFFU;
-        }
-        else {
-            uResult = static_cast<uint32_t>(fTemp);
-        }
-        Result.vector4_u32[ElementIndex] = uResult;
-    } while (++ElementIndex < 4);
-    return Result;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t vResult = vmulq_n_f32(VFloat, static_cast<float>(1U << MulExponent));
-    // In case of overflow, detect it
-    uint32x4_t vOverflow = vcgtq_f32(vResult, g_XMMaxUInt);
-    // Float to int conversion
-    uint32x4_t vResulti = vcvtq_u32_f32(vResult);
-    // If there was overflow, set to 0xFFFFFFFFU
-    vResult = vreinterpretq_f32_u32(vbicq_u32(vResulti, vOverflow));
-    vOverflow = vorrq_u32(vOverflow, vreinterpretq_u32_f32(vResult));
-    return vreinterpretq_f32_u32(vOverflow);
-#else // _XM_SSE_INTRINSICS_
-    XMVECTOR vResult = _mm_set_ps1(static_cast<float>(1U << MulExponent));
-    vResult = _mm_mul_ps(vResult, VFloat);
-    // Clamp to >=0
-    vResult = _mm_max_ps(vResult, g_XMZero);
-    // Any numbers that are too big, set to 0xFFFFFFFFU
-    XMVECTOR vOverflow = _mm_cmpgt_ps(vResult, g_XMMaxUInt);
-    XMVECTOR vValue = g_XMUnsignedFix;
-    // Too large for a signed integer?
-    XMVECTOR vMask = _mm_cmpge_ps(vResult, vValue);
-    // Zero for number's lower than 0x80000000, 32768.0f*65536.0f otherwise
-    vValue = _mm_and_ps(vValue, vMask);
-    // Perform fixup only on numbers too large (Keeps low bit precision)
-    vResult = _mm_sub_ps(vResult, vValue);
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Convert from signed to unsigned pnly if greater than 0x80000000
-    vMask = _mm_and_ps(vMask, g_XMNegativeZero);
-    vResult = _mm_xor_ps(_mm_castsi128_ps(vResulti), vMask);
-    // On those that are too large, set to 0xFFFFFFFF
-    vResult = _mm_or_ps(vResult, vOverflow);
-    return vResult;
-#endif
-}
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-/****************************************************************************
- *
- * Vector and matrix load operations
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadInt(const uint32_t* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_u32[0] = *pSource;
-    V.vector4_u32[1] = 0;
-    V.vector4_u32[2] = 0;
-    V.vector4_u32[3] = 0;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t zero = vdupq_n_u32(0);
-    return vreinterpretq_f32_u32(vld1q_lane_u32(pSource, zero, 0));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_load_ss(reinterpret_cast<const float*>(pSource));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadFloat(const float* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = *pSource;
-    V.vector4_f32[1] = 0.f;
-    V.vector4_f32[2] = 0.f;
-    V.vector4_f32[3] = 0.f;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t zero = vdupq_n_f32(0);
-    return vld1q_lane_f32(pSource, zero, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_load_ss(pSource);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadInt2(const uint32_t* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_u32[0] = pSource[0];
-    V.vector4_u32[1] = pSource[1];
-    V.vector4_u32[2] = 0;
-    V.vector4_u32[3] = 0;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t x = vld1_u32(pSource);
-    uint32x2_t zero = vdup_n_u32(0);
-    return vreinterpretq_f32_u32(vcombine_u32(x, zero));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadInt2A(const uint32_t* pSource) noexcept
-{
-    assert(pSource);
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_u32[0] = pSource[0];
-    V.vector4_u32[1] = pSource[1];
-    V.vector4_u32[2] = 0;
-    V.vector4_u32[3] = 0;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    uint32x2_t x = vld1_u32_ex(pSource, 64);
-#else
-    uint32x2_t x = vld1_u32(pSource);
-#endif
-    uint32x2_t zero = vdup_n_u32(0);
-    return vreinterpretq_f32_u32(vcombine_u32(x, zero));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadFloat2(const XMFLOAT2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = pSource->x;
-    V.vector4_f32[1] = pSource->y;
-    V.vector4_f32[2] = 0.f;
-    V.vector4_f32[3] = 0.f;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t x = vld1_f32(reinterpret_cast<const float*>(pSource));
-    float32x2_t zero = vdup_n_f32(0);
-    return vcombine_f32(x, zero);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadFloat2A(const XMFLOAT2A* pSource) noexcept
-{
-    assert(pSource);
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = pSource->x;
-    V.vector4_f32[1] = pSource->y;
-    V.vector4_f32[2] = 0.f;
-    V.vector4_f32[3] = 0.f;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    float32x2_t x = vld1_f32_ex(reinterpret_cast<const float*>(pSource), 64);
-#else
-    float32x2_t x = vld1_f32(reinterpret_cast<const float*>(pSource));
-#endif
-    float32x2_t zero = vdup_n_f32(0);
-    return vcombine_f32(x, zero);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadSInt2(const XMINT2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = static_cast<float>(pSource->x);
-    V.vector4_f32[1] = static_cast<float>(pSource->y);
-    V.vector4_f32[2] = 0.f;
-    V.vector4_f32[3] = 0.f;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int32x2_t x = vld1_s32(reinterpret_cast<const int32_t*>(pSource));
-    float32x2_t v = vcvt_f32_s32(x);
-    float32x2_t zero = vdup_n_f32(0);
-    return vcombine_f32(v, zero);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 V = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    return _mm_cvtepi32_ps(_mm_castps_si128(V));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUInt2(const XMUINT2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = static_cast<float>(pSource->x);
-    V.vector4_f32[1] = static_cast<float>(pSource->y);
-    V.vector4_f32[2] = 0.f;
-    V.vector4_f32[3] = 0.f;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t x = vld1_u32(reinterpret_cast<const uint32_t*>(pSource));
-    float32x2_t v = vcvt_f32_u32(x);
-    float32x2_t zero = vdup_n_f32(0);
-    return vcombine_f32(v, zero);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 V = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    // For the values that are higher than 0x7FFFFFFF, a fixup is needed
-    // Determine which ones need the fix.
-    XMVECTOR vMask = _mm_and_ps(V, g_XMNegativeZero);
-    // Force all values positive
-    XMVECTOR vResult = _mm_xor_ps(V, vMask);
-    // Convert to floats
-    vResult = _mm_cvtepi32_ps(_mm_castps_si128(vResult));
-    // Convert 0x80000000 -> 0xFFFFFFFF
-    __m128i iMask = _mm_srai_epi32(_mm_castps_si128(vMask), 31);
-    // For only the ones that are too big, add the fixup
-    vMask = _mm_and_ps(_mm_castsi128_ps(iMask), g_XMFixUnsigned);
-    vResult = _mm_add_ps(vResult, vMask);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadInt3(const uint32_t* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_u32[0] = pSource[0];
-    V.vector4_u32[1] = pSource[1];
-    V.vector4_u32[2] = pSource[2];
-    V.vector4_u32[3] = 0;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t x = vld1_u32(pSource);
-    uint32x2_t zero = vdup_n_u32(0);
-    uint32x2_t y = vld1_lane_u32(pSource + 2, zero, 0);
-    return vreinterpretq_f32_u32(vcombine_u32(x, y));
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    __m128 z = _mm_load_ss(reinterpret_cast<const float*>(pSource + 2));
-    return _mm_insert_ps(xy, z, 0x20);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    __m128 z = _mm_load_ss(reinterpret_cast<const float*>(pSource + 2));
-    return _mm_movelh_ps(xy, z);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadInt3A(const uint32_t* pSource) noexcept
-{
-    assert(pSource);
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_u32[0] = pSource[0];
-    V.vector4_u32[1] = pSource[1];
-    V.vector4_u32[2] = pSource[2];
-    V.vector4_u32[3] = 0;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Reads an extra integer which is zero'd
-#if defined(_MSC_VER) && !defined(__clang__)
-    uint32x4_t V = vld1q_u32_ex(pSource, 128);
-#else
-    uint32x4_t V = vld1q_u32(pSource);
-#endif
-    return vreinterpretq_f32_u32(vsetq_lane_u32(0, V, 3));
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    __m128 z = _mm_load_ss(reinterpret_cast<const float*>(pSource + 2));
-    return _mm_insert_ps(xy, z, 0x20);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    __m128 z = _mm_load_ss(reinterpret_cast<const float*>(pSource + 2));
-    return _mm_movelh_ps(xy, z);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadFloat3(const XMFLOAT3* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = pSource->x;
-    V.vector4_f32[1] = pSource->y;
-    V.vector4_f32[2] = pSource->z;
-    V.vector4_f32[3] = 0.f;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t x = vld1_f32(reinterpret_cast<const float*>(pSource));
-    float32x2_t zero = vdup_n_f32(0);
-    float32x2_t y = vld1_lane_f32(reinterpret_cast<const float*>(pSource) + 2, zero, 0);
-    return vcombine_f32(x, y);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    __m128 z = _mm_load_ss(&pSource->z);
-    return _mm_insert_ps(xy, z, 0x20);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    __m128 z = _mm_load_ss(&pSource->z);
-    return _mm_movelh_ps(xy, z);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadFloat3A(const XMFLOAT3A* pSource) noexcept
-{
-    assert(pSource);
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = pSource->x;
-    V.vector4_f32[1] = pSource->y;
-    V.vector4_f32[2] = pSource->z;
-    V.vector4_f32[3] = 0.f;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Reads an extra float which is zero'd
-#if defined(_MSC_VER) && !defined(__clang__)
-    float32x4_t V = vld1q_f32_ex(reinterpret_cast<const float*>(pSource), 128);
-#else
-    float32x4_t V = vld1q_f32(reinterpret_cast<const float*>(pSource));
-#endif
-    return vsetq_lane_f32(0, V, 3);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Reads an extra float which is zero'd
-    __m128 V = _mm_load_ps(&pSource->x);
-    return _mm_and_ps(V, g_XMMask3);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadSInt3(const XMINT3* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR V;
-    V.vector4_f32[0] = static_cast<float>(pSource->x);
-    V.vector4_f32[1] = static_cast<float>(pSource->y);
-    V.vector4_f32[2] = static_cast<float>(pSource->z);
-    V.vector4_f32[3] = 0.f;
-    return V;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int32x2_t x = vld1_s32(reinterpret_cast<const int32_t*>(pSource));
-    int32x2_t zero = vdup_n_s32(0);
-    int32x2_t y = vld1_lane_s32(reinterpret_cast<const int32_t*>(pSource) + 2, zero, 0);
-    int32x4_t v = vcombine_s32(x, y);
-    return vcvtq_f32_s32(v);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    __m128 z = _mm_load_ss(reinterpret_cast<const float*>(&pSource->z));
-    __m128 V = _mm_movelh_ps(xy, z);
-    return _mm_cvtepi32_ps(_mm_castps_si128(V));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUInt3(const XMUINT3* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = static_cast<float>(pSource->x);
-    V.vector4_f32[1] = static_cast<float>(pSource->y);
-    V.vector4_f32[2] = static_cast<float>(pSource->z);
-    V.vector4_f32[3] = 0.f;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t x = vld1_u32(reinterpret_cast<const uint32_t*>(pSource));
-    uint32x2_t zero = vdup_n_u32(0);
-    uint32x2_t y = vld1_lane_u32(reinterpret_cast<const uint32_t*>(pSource) + 2, zero, 0);
-    uint32x4_t v = vcombine_u32(x, y);
-    return vcvtq_f32_u32(v);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pSource)));
-    __m128 z = _mm_load_ss(reinterpret_cast<const float*>(&pSource->z));
-    __m128 V = _mm_movelh_ps(xy, z);
-    // For the values that are higher than 0x7FFFFFFF, a fixup is needed
-    // Determine which ones need the fix.
-    XMVECTOR vMask = _mm_and_ps(V, g_XMNegativeZero);
-    // Force all values positive
-    XMVECTOR vResult = _mm_xor_ps(V, vMask);
-    // Convert to floats
-    vResult = _mm_cvtepi32_ps(_mm_castps_si128(vResult));
-    // Convert 0x80000000 -> 0xFFFFFFFF
-    __m128i iMask = _mm_srai_epi32(_mm_castps_si128(vMask), 31);
-    // For only the ones that are too big, add the fixup
-    vMask = _mm_and_ps(_mm_castsi128_ps(iMask), g_XMFixUnsigned);
-    vResult = _mm_add_ps(vResult, vMask);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadInt4(const uint32_t* pSource) noexcept
-{
-    assert(pSource);
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_u32[0] = pSource[0];
-    V.vector4_u32[1] = pSource[1];
-    V.vector4_u32[2] = pSource[2];
-    V.vector4_u32[3] = pSource[3];
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vld1q_u32(pSource));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pSource));
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadInt4A(const uint32_t* pSource) noexcept
-{
-    assert(pSource);
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_u32[0] = pSource[0];
-    V.vector4_u32[1] = pSource[1];
-    V.vector4_u32[2] = pSource[2];
-    V.vector4_u32[3] = pSource[3];
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    return vld1q_u32_ex(pSource, 128);
-#else
-    return vreinterpretq_f32_u32(vld1q_u32(pSource));
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_load_si128(reinterpret_cast<const __m128i*>(pSource));
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadFloat4(const XMFLOAT4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = pSource->x;
-    V.vector4_f32[1] = pSource->y;
-    V.vector4_f32[2] = pSource->z;
-    V.vector4_f32[3] = pSource->w;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vld1q_f32(reinterpret_cast<const float*>(pSource));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_loadu_ps(&pSource->x);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadFloat4A(const XMFLOAT4A* pSource) noexcept
-{
-    assert(pSource);
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = pSource->x;
-    V.vector4_f32[1] = pSource->y;
-    V.vector4_f32[2] = pSource->z;
-    V.vector4_f32[3] = pSource->w;
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    return vld1q_f32_ex(reinterpret_cast<const float*>(pSource), 128);
-#else
-    return vld1q_f32(reinterpret_cast<const float*>(pSource));
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_load_ps(&pSource->x);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadSInt4(const XMINT4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR V;
-    V.vector4_f32[0] = static_cast<float>(pSource->x);
-    V.vector4_f32[1] = static_cast<float>(pSource->y);
-    V.vector4_f32[2] = static_cast<float>(pSource->z);
-    V.vector4_f32[3] = static_cast<float>(pSource->w);
-    return V;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int32x4_t v = vld1q_s32(reinterpret_cast<const int32_t*>(pSource));
-    return vcvtq_f32_s32(v);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pSource));
-    return _mm_cvtepi32_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUInt4(const XMUINT4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR V;
-    V.vector4_f32[0] = static_cast<float>(pSource->x);
-    V.vector4_f32[1] = static_cast<float>(pSource->y);
-    V.vector4_f32[2] = static_cast<float>(pSource->z);
-    V.vector4_f32[3] = static_cast<float>(pSource->w);
-    return V;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t v = vld1q_u32(reinterpret_cast<const uint32_t*>(pSource));
-    return vcvtq_f32_u32(v);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pSource));
-    // For the values that are higher than 0x7FFFFFFF, a fixup is needed
-    // Determine which ones need the fix.
-    XMVECTOR vMask = _mm_and_ps(_mm_castsi128_ps(V), g_XMNegativeZero);
-    // Force all values positive
-    XMVECTOR vResult = _mm_xor_ps(_mm_castsi128_ps(V), vMask);
-    // Convert to floats
-    vResult = _mm_cvtepi32_ps(_mm_castps_si128(vResult));
-    // Convert 0x80000000 -> 0xFFFFFFFF
-    __m128i iMask = _mm_srai_epi32(_mm_castps_si128(vMask), 31);
-    // For only the ones that are too big, add the fixup
-    vMask = _mm_and_ps(_mm_castsi128_ps(iMask), g_XMFixUnsigned);
-    vResult = _mm_add_ps(vResult, vMask);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMMATRIX XM_CALLCONV XMLoadFloat3x3(const XMFLOAT3X3* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.r[0].vector4_f32[0] = pSource->m[0][0];
-    M.r[0].vector4_f32[1] = pSource->m[0][1];
-    M.r[0].vector4_f32[2] = pSource->m[0][2];
-    M.r[0].vector4_f32[3] = 0.0f;
-
-    M.r[1].vector4_f32[0] = pSource->m[1][0];
-    M.r[1].vector4_f32[1] = pSource->m[1][1];
-    M.r[1].vector4_f32[2] = pSource->m[1][2];
-    M.r[1].vector4_f32[3] = 0.0f;
-
-    M.r[2].vector4_f32[0] = pSource->m[2][0];
-    M.r[2].vector4_f32[1] = pSource->m[2][1];
-    M.r[2].vector4_f32[2] = pSource->m[2][2];
-    M.r[2].vector4_f32[3] = 0.0f;
-    M.r[3].vector4_f32[0] = 0.0f;
-    M.r[3].vector4_f32[1] = 0.0f;
-    M.r[3].vector4_f32[2] = 0.0f;
-    M.r[3].vector4_f32[3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t v0 = vld1q_f32(&pSource->m[0][0]);
-    float32x4_t v1 = vld1q_f32(&pSource->m[1][1]);
-    float32x2_t v2 = vcreate_f32(static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&pSource->m[2][2])));
-    float32x4_t T = vextq_f32(v0, v1, 3);
-
-    XMMATRIX M;
-    M.r[0] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(v0), g_XMMask3));
-    M.r[1] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T), g_XMMask3));
-    M.r[2] = vcombine_f32(vget_high_f32(v1), v2);
-    M.r[3] = g_XMIdentityR3;
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 Z = _mm_setzero_ps();
-
-    __m128 V1 = _mm_loadu_ps(&pSource->m[0][0]);
-    __m128 V2 = _mm_loadu_ps(&pSource->m[1][1]);
-    __m128 V3 = _mm_load_ss(&pSource->m[2][2]);
-
-    __m128 T1 = _mm_unpackhi_ps(V1, Z);
-    __m128 T2 = _mm_unpacklo_ps(V2, Z);
-    __m128 T3 = _mm_shuffle_ps(V3, T2, _MM_SHUFFLE(0, 1, 0, 0));
-    __m128 T4 = _mm_movehl_ps(T2, T3);
-    __m128 T5 = _mm_movehl_ps(Z, T1);
-
-    XMMATRIX M;
-    M.r[0] = _mm_movelh_ps(V1, T1);
-    M.r[1] = _mm_add_ps(T4, T5);
-    M.r[2] = _mm_shuffle_ps(V2, V3, _MM_SHUFFLE(1, 0, 3, 2));
-    M.r[3] = g_XMIdentityR3;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMMATRIX XM_CALLCONV XMLoadFloat4x3(const XMFLOAT4X3* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.r[0].vector4_f32[0] = pSource->m[0][0];
-    M.r[0].vector4_f32[1] = pSource->m[0][1];
-    M.r[0].vector4_f32[2] = pSource->m[0][2];
-    M.r[0].vector4_f32[3] = 0.0f;
-
-    M.r[1].vector4_f32[0] = pSource->m[1][0];
-    M.r[1].vector4_f32[1] = pSource->m[1][1];
-    M.r[1].vector4_f32[2] = pSource->m[1][2];
-    M.r[1].vector4_f32[3] = 0.0f;
-
-    M.r[2].vector4_f32[0] = pSource->m[2][0];
-    M.r[2].vector4_f32[1] = pSource->m[2][1];
-    M.r[2].vector4_f32[2] = pSource->m[2][2];
-    M.r[2].vector4_f32[3] = 0.0f;
-
-    M.r[3].vector4_f32[0] = pSource->m[3][0];
-    M.r[3].vector4_f32[1] = pSource->m[3][1];
-    M.r[3].vector4_f32[2] = pSource->m[3][2];
-    M.r[3].vector4_f32[3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t v0 = vld1q_f32(&pSource->m[0][0]);
-    float32x4_t v1 = vld1q_f32(&pSource->m[1][1]);
-    float32x4_t v2 = vld1q_f32(&pSource->m[2][2]);
-
-    float32x4_t T1 = vextq_f32(v0, v1, 3);
-    float32x4_t T2 = vcombine_f32(vget_high_f32(v1), vget_low_f32(v2));
-    float32x4_t T3 = vextq_f32(v2, v2, 1);
-
-    XMMATRIX M;
-    M.r[0] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(v0), g_XMMask3));
-    M.r[1] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T1), g_XMMask3));
-    M.r[2] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T2), g_XMMask3));
-    M.r[3] = vsetq_lane_f32(1.f, T3, 3);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Use unaligned load instructions to
-    // load the 12 floats
-    // vTemp1 = x1,y1,z1,x2
-    XMVECTOR vTemp1 = _mm_loadu_ps(&pSource->m[0][0]);
-    // vTemp2 = y2,z2,x3,y3
-    XMVECTOR vTemp2 = _mm_loadu_ps(&pSource->m[1][1]);
-    // vTemp4 = z3,x4,y4,z4
-    XMVECTOR vTemp4 = _mm_loadu_ps(&pSource->m[2][2]);
-    // vTemp3 = x3,y3,z3,z3
-    XMVECTOR vTemp3 = _mm_shuffle_ps(vTemp2, vTemp4, _MM_SHUFFLE(0, 0, 3, 2));
-    // vTemp2 = y2,z2,x2,x2
-    vTemp2 = _mm_shuffle_ps(vTemp2, vTemp1, _MM_SHUFFLE(3, 3, 1, 0));
-    // vTemp2 = x2,y2,z2,z2
-    vTemp2 = XM_PERMUTE_PS(vTemp2, _MM_SHUFFLE(1, 1, 0, 2));
-    // vTemp1 = x1,y1,z1,0
-    vTemp1 = _mm_and_ps(vTemp1, g_XMMask3);
-    // vTemp2 = x2,y2,z2,0
-    vTemp2 = _mm_and_ps(vTemp2, g_XMMask3);
-    // vTemp3 = x3,y3,z3,0
-    vTemp3 = _mm_and_ps(vTemp3, g_XMMask3);
-    // vTemp4i = x4,y4,z4,0
-    __m128i vTemp4i = _mm_srli_si128(_mm_castps_si128(vTemp4), 32 / 8);
-    // vTemp4i = x4,y4,z4,1.0f
-    vTemp4i = _mm_or_si128(vTemp4i, g_XMIdentityR3);
-    XMMATRIX M(vTemp1,
-               vTemp2,
-               vTemp3,
-               _mm_castsi128_ps(vTemp4i));
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMMATRIX XM_CALLCONV XMLoadFloat4x3A(const XMFLOAT4X3A* pSource) noexcept
-{
-    assert(pSource);
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.r[0].vector4_f32[0] = pSource->m[0][0];
-    M.r[0].vector4_f32[1] = pSource->m[0][1];
-    M.r[0].vector4_f32[2] = pSource->m[0][2];
-    M.r[0].vector4_f32[3] = 0.0f;
-
-    M.r[1].vector4_f32[0] = pSource->m[1][0];
-    M.r[1].vector4_f32[1] = pSource->m[1][1];
-    M.r[1].vector4_f32[2] = pSource->m[1][2];
-    M.r[1].vector4_f32[3] = 0.0f;
-
-    M.r[2].vector4_f32[0] = pSource->m[2][0];
-    M.r[2].vector4_f32[1] = pSource->m[2][1];
-    M.r[2].vector4_f32[2] = pSource->m[2][2];
-    M.r[2].vector4_f32[3] = 0.0f;
-
-    M.r[3].vector4_f32[0] = pSource->m[3][0];
-    M.r[3].vector4_f32[1] = pSource->m[3][1];
-    M.r[3].vector4_f32[2] = pSource->m[3][2];
-    M.r[3].vector4_f32[3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    float32x4_t v0 = vld1q_f32_ex(&pSource->m[0][0], 128);
-    float32x4_t v1 = vld1q_f32_ex(&pSource->m[1][1], 128);
-    float32x4_t v2 = vld1q_f32_ex(&pSource->m[2][2], 128);
-#else
-    float32x4_t v0 = vld1q_f32(&pSource->m[0][0]);
-    float32x4_t v1 = vld1q_f32(&pSource->m[1][1]);
-    float32x4_t v2 = vld1q_f32(&pSource->m[2][2]);
-#endif
-
-    float32x4_t T1 = vextq_f32(v0, v1, 3);
-    float32x4_t T2 = vcombine_f32(vget_high_f32(v1), vget_low_f32(v2));
-    float32x4_t T3 = vextq_f32(v2, v2, 1);
-
-    XMMATRIX M;
-    M.r[0] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(v0), g_XMMask3));
-    M.r[1] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T1), g_XMMask3));
-    M.r[2] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T2), g_XMMask3));
-    M.r[3] = vsetq_lane_f32(1.f, T3, 3);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Use aligned load instructions to
-    // load the 12 floats
-    // vTemp1 = x1,y1,z1,x2
-    XMVECTOR vTemp1 = _mm_load_ps(&pSource->m[0][0]);
-    // vTemp2 = y2,z2,x3,y3
-    XMVECTOR vTemp2 = _mm_load_ps(&pSource->m[1][1]);
-    // vTemp4 = z3,x4,y4,z4
-    XMVECTOR vTemp4 = _mm_load_ps(&pSource->m[2][2]);
-    // vTemp3 = x3,y3,z3,z3
-    XMVECTOR vTemp3 = _mm_shuffle_ps(vTemp2, vTemp4, _MM_SHUFFLE(0, 0, 3, 2));
-    // vTemp2 = y2,z2,x2,x2
-    vTemp2 = _mm_shuffle_ps(vTemp2, vTemp1, _MM_SHUFFLE(3, 3, 1, 0));
-    // vTemp2 = x2,y2,z2,z2
-    vTemp2 = XM_PERMUTE_PS(vTemp2, _MM_SHUFFLE(1, 1, 0, 2));
-    // vTemp1 = x1,y1,z1,0
-    vTemp1 = _mm_and_ps(vTemp1, g_XMMask3);
-    // vTemp2 = x2,y2,z2,0
-    vTemp2 = _mm_and_ps(vTemp2, g_XMMask3);
-    // vTemp3 = x3,y3,z3,0
-    vTemp3 = _mm_and_ps(vTemp3, g_XMMask3);
-    // vTemp4i = x4,y4,z4,0
-    __m128i vTemp4i = _mm_srli_si128(_mm_castps_si128(vTemp4), 32 / 8);
-    // vTemp4i = x4,y4,z4,1.0f
-    vTemp4i = _mm_or_si128(vTemp4i, g_XMIdentityR3);
-    XMMATRIX M(vTemp1,
-               vTemp2,
-               vTemp3,
-               _mm_castsi128_ps(vTemp4i));
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMMATRIX XM_CALLCONV XMLoadFloat3x4(const XMFLOAT3X4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.r[0].vector4_f32[0] = pSource->m[0][0];
-    M.r[0].vector4_f32[1] = pSource->m[1][0];
-    M.r[0].vector4_f32[2] = pSource->m[2][0];
-    M.r[0].vector4_f32[3] = 0.0f;
-
-    M.r[1].vector4_f32[0] = pSource->m[0][1];
-    M.r[1].vector4_f32[1] = pSource->m[1][1];
-    M.r[1].vector4_f32[2] = pSource->m[2][1];
-    M.r[1].vector4_f32[3] = 0.0f;
-
-    M.r[2].vector4_f32[0] = pSource->m[0][2];
-    M.r[2].vector4_f32[1] = pSource->m[1][2];
-    M.r[2].vector4_f32[2] = pSource->m[2][2];
-    M.r[2].vector4_f32[3] = 0.0f;
-
-    M.r[3].vector4_f32[0] = pSource->m[0][3];
-    M.r[3].vector4_f32[1] = pSource->m[1][3];
-    M.r[3].vector4_f32[2] = pSource->m[2][3];
-    M.r[3].vector4_f32[3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2x4_t vTemp0 = vld4_f32(&pSource->_11);
-    float32x4_t vTemp1 = vld1q_f32(&pSource->_31);
-
-    float32x2_t l = vget_low_f32(vTemp1);
-    float32x4_t T0 = vcombine_f32(vTemp0.val[0], l);
-    float32x2_t rl = vrev64_f32(l);
-    float32x4_t T1 = vcombine_f32(vTemp0.val[1], rl);
-
-    float32x2_t h = vget_high_f32(vTemp1);
-    float32x4_t T2 = vcombine_f32(vTemp0.val[2], h);
-    float32x2_t rh = vrev64_f32(h);
-    float32x4_t T3 = vcombine_f32(vTemp0.val[3], rh);
-
-    XMMATRIX M = {};
-    M.r[0] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T0), g_XMMask3));
-    M.r[1] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T1), g_XMMask3));
-    M.r[2] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T2), g_XMMask3));
-    M.r[3] = vsetq_lane_f32(1.f, T3, 3);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = _mm_loadu_ps(&pSource->_11);
-    M.r[1] = _mm_loadu_ps(&pSource->_21);
-    M.r[2] = _mm_loadu_ps(&pSource->_31);
-    M.r[3] = g_XMIdentityR3;
-
-    // x.x,x.y,y.x,y.y
-    XMVECTOR vTemp1 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(1, 0, 1, 0));
-    // x.z,x.w,y.z,y.w
-    XMVECTOR vTemp3 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(3, 2, 3, 2));
-    // z.x,z.y,w.x,w.y
-    XMVECTOR vTemp2 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(1, 0, 1, 0));
-    // z.z,z.w,w.z,w.w
-    XMVECTOR vTemp4 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(3, 2, 3, 2));
-    XMMATRIX mResult;
-
-    // x.x,y.x,z.x,w.x
-    mResult.r[0] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.y,y.y,z.y,w.y
-    mResult.r[1] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(3, 1, 3, 1));
-    // x.z,y.z,z.z,w.z
-    mResult.r[2] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.w,y.w,z.w,w.w
-    mResult.r[3] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(3, 1, 3, 1));
-    return mResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMMATRIX XM_CALLCONV XMLoadFloat3x4A(const XMFLOAT3X4A* pSource) noexcept
-{
-    assert(pSource);
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.r[0].vector4_f32[0] = pSource->m[0][0];
-    M.r[0].vector4_f32[1] = pSource->m[1][0];
-    M.r[0].vector4_f32[2] = pSource->m[2][0];
-    M.r[0].vector4_f32[3] = 0.0f;
-
-    M.r[1].vector4_f32[0] = pSource->m[0][1];
-    M.r[1].vector4_f32[1] = pSource->m[1][1];
-    M.r[1].vector4_f32[2] = pSource->m[2][1];
-    M.r[1].vector4_f32[3] = 0.0f;
-
-    M.r[2].vector4_f32[0] = pSource->m[0][2];
-    M.r[2].vector4_f32[1] = pSource->m[1][2];
-    M.r[2].vector4_f32[2] = pSource->m[2][2];
-    M.r[2].vector4_f32[3] = 0.0f;
-
-    M.r[3].vector4_f32[0] = pSource->m[0][3];
-    M.r[3].vector4_f32[1] = pSource->m[1][3];
-    M.r[3].vector4_f32[2] = pSource->m[2][3];
-    M.r[3].vector4_f32[3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    float32x2x4_t vTemp0 = vld4_f32_ex(&pSource->_11, 128);
-    float32x4_t vTemp1 = vld1q_f32_ex(&pSource->_31, 128);
-#else
-    float32x2x4_t vTemp0 = vld4_f32(&pSource->_11);
-    float32x4_t vTemp1 = vld1q_f32(&pSource->_31);
-#endif
-
-    float32x2_t l = vget_low_f32(vTemp1);
-    float32x4_t T0 = vcombine_f32(vTemp0.val[0], l);
-    float32x2_t rl = vrev64_f32(l);
-    float32x4_t T1 = vcombine_f32(vTemp0.val[1], rl);
-
-    float32x2_t h = vget_high_f32(vTemp1);
-    float32x4_t T2 = vcombine_f32(vTemp0.val[2], h);
-    float32x2_t rh = vrev64_f32(h);
-    float32x4_t T3 = vcombine_f32(vTemp0.val[3], rh);
-
-    XMMATRIX M = {};
-    M.r[0] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T0), g_XMMask3));
-    M.r[1] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T1), g_XMMask3));
-    M.r[2] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T2), g_XMMask3));
-    M.r[3] = vsetq_lane_f32(1.f, T3, 3);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = _mm_load_ps(&pSource->_11);
-    M.r[1] = _mm_load_ps(&pSource->_21);
-    M.r[2] = _mm_load_ps(&pSource->_31);
-    M.r[3] = g_XMIdentityR3;
-
-    // x.x,x.y,y.x,y.y
-    XMVECTOR vTemp1 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(1, 0, 1, 0));
-    // x.z,x.w,y.z,y.w
-    XMVECTOR vTemp3 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(3, 2, 3, 2));
-    // z.x,z.y,w.x,w.y
-    XMVECTOR vTemp2 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(1, 0, 1, 0));
-    // z.z,z.w,w.z,w.w
-    XMVECTOR vTemp4 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(3, 2, 3, 2));
-    XMMATRIX mResult;
-
-    // x.x,y.x,z.x,w.x
-    mResult.r[0] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.y,y.y,z.y,w.y
-    mResult.r[1] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(3, 1, 3, 1));
-    // x.z,y.z,z.z,w.z
-    mResult.r[2] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.w,y.w,z.w,w.w
-    mResult.r[3] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(3, 1, 3, 1));
-    return mResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMMATRIX XM_CALLCONV XMLoadFloat4x4(const XMFLOAT4X4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.r[0].vector4_f32[0] = pSource->m[0][0];
-    M.r[0].vector4_f32[1] = pSource->m[0][1];
-    M.r[0].vector4_f32[2] = pSource->m[0][2];
-    M.r[0].vector4_f32[3] = pSource->m[0][3];
-
-    M.r[1].vector4_f32[0] = pSource->m[1][0];
-    M.r[1].vector4_f32[1] = pSource->m[1][1];
-    M.r[1].vector4_f32[2] = pSource->m[1][2];
-    M.r[1].vector4_f32[3] = pSource->m[1][3];
-
-    M.r[2].vector4_f32[0] = pSource->m[2][0];
-    M.r[2].vector4_f32[1] = pSource->m[2][1];
-    M.r[2].vector4_f32[2] = pSource->m[2][2];
-    M.r[2].vector4_f32[3] = pSource->m[2][3];
-
-    M.r[3].vector4_f32[0] = pSource->m[3][0];
-    M.r[3].vector4_f32[1] = pSource->m[3][1];
-    M.r[3].vector4_f32[2] = pSource->m[3][2];
-    M.r[3].vector4_f32[3] = pSource->m[3][3];
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = vld1q_f32(reinterpret_cast<const float*>(&pSource->_11));
-    M.r[1] = vld1q_f32(reinterpret_cast<const float*>(&pSource->_21));
-    M.r[2] = vld1q_f32(reinterpret_cast<const float*>(&pSource->_31));
-    M.r[3] = vld1q_f32(reinterpret_cast<const float*>(&pSource->_41));
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = _mm_loadu_ps(&pSource->_11);
-    M.r[1] = _mm_loadu_ps(&pSource->_21);
-    M.r[2] = _mm_loadu_ps(&pSource->_31);
-    M.r[3] = _mm_loadu_ps(&pSource->_41);
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMMATRIX XM_CALLCONV XMLoadFloat4x4A(const XMFLOAT4X4A* pSource) noexcept
-{
-    assert(pSource);
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.r[0].vector4_f32[0] = pSource->m[0][0];
-    M.r[0].vector4_f32[1] = pSource->m[0][1];
-    M.r[0].vector4_f32[2] = pSource->m[0][2];
-    M.r[0].vector4_f32[3] = pSource->m[0][3];
-
-    M.r[1].vector4_f32[0] = pSource->m[1][0];
-    M.r[1].vector4_f32[1] = pSource->m[1][1];
-    M.r[1].vector4_f32[2] = pSource->m[1][2];
-    M.r[1].vector4_f32[3] = pSource->m[1][3];
-
-    M.r[2].vector4_f32[0] = pSource->m[2][0];
-    M.r[2].vector4_f32[1] = pSource->m[2][1];
-    M.r[2].vector4_f32[2] = pSource->m[2][2];
-    M.r[2].vector4_f32[3] = pSource->m[2][3];
-
-    M.r[3].vector4_f32[0] = pSource->m[3][0];
-    M.r[3].vector4_f32[1] = pSource->m[3][1];
-    M.r[3].vector4_f32[2] = pSource->m[3][2];
-    M.r[3].vector4_f32[3] = pSource->m[3][3];
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMMATRIX M;
-#if defined(_MSC_VER) && !defined(__clang__)
-    M.r[0] = vld1q_f32_ex(reinterpret_cast<const float*>(&pSource->_11), 128);
-    M.r[1] = vld1q_f32_ex(reinterpret_cast<const float*>(&pSource->_21), 128);
-    M.r[2] = vld1q_f32_ex(reinterpret_cast<const float*>(&pSource->_31), 128);
-    M.r[3] = vld1q_f32_ex(reinterpret_cast<const float*>(&pSource->_41), 128);
-#else
-    M.r[0] = vld1q_f32(reinterpret_cast<const float*>(&pSource->_11));
-    M.r[1] = vld1q_f32(reinterpret_cast<const float*>(&pSource->_21));
-    M.r[2] = vld1q_f32(reinterpret_cast<const float*>(&pSource->_31));
-    M.r[3] = vld1q_f32(reinterpret_cast<const float*>(&pSource->_41));
-#endif
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = _mm_load_ps(&pSource->_11);
-    M.r[1] = _mm_load_ps(&pSource->_21);
-    M.r[2] = _mm_load_ps(&pSource->_31);
-    M.r[3] = _mm_load_ps(&pSource->_41);
-    return M;
-#endif
-}
-
-/****************************************************************************
- *
- * Vector and matrix store operations
- *
- ****************************************************************************/
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreInt
-        (
-                uint32_t* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    *pDestination = XMVectorGetIntX(V);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_u32(pDestination, *reinterpret_cast<const uint32x4_t*>(&V), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_ss(reinterpret_cast<float*>(pDestination), V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat
-        (
-                float* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    *pDestination = XMVectorGetX(V);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_f32(pDestination, V, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_ss(pDestination, V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreInt2
-        (
-                uint32_t* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination[0] = V.vector4_u32[0];
-    pDestination[1] = V.vector4_u32[1];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t VL = vget_low_u32(vreinterpretq_u32_f32(V));
-    vst1_u32(pDestination, VL);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(V));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreInt2A
-        (
-                uint32_t* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-    assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination[0] = V.vector4_u32[0];
-    pDestination[1] = V.vector4_u32[1];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t VL = vget_low_u32(vreinterpretq_u32_f32(V));
-#if defined(_MSC_VER) && !defined(__clang__)
-    vst1_u32_ex(pDestination, VL, 64);
-#else
-    vst1_u32(pDestination, VL);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(V));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat2
-        (
-                XMFLOAT2* pDestination,
-                FXMVECTOR  V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = V.vector4_f32[0];
-    pDestination->y = V.vector4_f32[1];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    vst1_f32(reinterpret_cast<float*>(pDestination), VL);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(V));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat2A
-        (
-                XMFLOAT2A* pDestination,
-                FXMVECTOR     V
-        ) noexcept
-{
-    assert(pDestination);
-    assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = V.vector4_f32[0];
-    pDestination->y = V.vector4_f32[1];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-#if defined(_MSC_VER) && !defined(__clang__)
-    vst1_f32_ex(reinterpret_cast<float*>(pDestination), VL, 64);
-#else
-    vst1_f32(reinterpret_cast<float*>(pDestination), VL);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(V));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreSInt2
-        (
-                XMINT2* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = static_cast<int32_t>(V.vector4_f32[0]);
-    pDestination->y = static_cast<int32_t>(V.vector4_f32[1]);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t v = vget_low_f32(V);
-    int32x2_t iv = vcvt_s32_f32(v);
-    vst1_s32(reinterpret_cast<int32_t*>(pDestination), iv);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // In case of positive overflow, detect it
-    XMVECTOR vOverflow = _mm_cmpgt_ps(V, g_XMMaxInt);
-    // Float to int conversion
-    __m128i vResulti = _mm_cvttps_epi32(V);
-    // If there was positive overflow, set to 0x7FFFFFFF
-    XMVECTOR vResult = _mm_and_ps(vOverflow, g_XMAbsMask);
-    vOverflow = _mm_andnot_ps(vOverflow, _mm_castsi128_ps(vResulti));
-    vOverflow = _mm_or_ps(vOverflow, vResult);
-    // Write two ints
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(vOverflow));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUInt2
-        (
-                XMUINT2* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = static_cast<uint32_t>(V.vector4_f32[0]);
-    pDestination->y = static_cast<uint32_t>(V.vector4_f32[1]);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t v = vget_low_f32(V);
-    uint32x2_t iv = vcvt_u32_f32(v);
-    vst1_u32(reinterpret_cast<uint32_t*>(pDestination), iv);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Clamp to >=0
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    // Any numbers that are too big, set to 0xFFFFFFFFU
-    XMVECTOR vOverflow = _mm_cmpgt_ps(vResult, g_XMMaxUInt);
-    XMVECTOR vValue = g_XMUnsignedFix;
-    // Too large for a signed integer?
-    XMVECTOR vMask = _mm_cmpge_ps(vResult, vValue);
-    // Zero for number's lower than 0x80000000, 32768.0f*65536.0f otherwise
-    vValue = _mm_and_ps(vValue, vMask);
-    // Perform fixup only on numbers too large (Keeps low bit precision)
-    vResult = _mm_sub_ps(vResult, vValue);
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Convert from signed to unsigned pnly if greater than 0x80000000
-    vMask = _mm_and_ps(vMask, g_XMNegativeZero);
-    vResult = _mm_xor_ps(_mm_castsi128_ps(vResulti), vMask);
-    // On those that are too large, set to 0xFFFFFFFF
-    vResult = _mm_or_ps(vResult, vOverflow);
-    // Write two uints
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(vResult));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreInt3
-        (
-                uint32_t* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination[0] = V.vector4_u32[0];
-    pDestination[1] = V.vector4_u32[1];
-    pDestination[2] = V.vector4_u32[2];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t VL = vget_low_u32(vreinterpretq_u32_f32(V));
-    vst1_u32(pDestination, VL);
-    vst1q_lane_u32(pDestination + 2, *reinterpret_cast<const uint32x4_t*>(&V), 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(V));
-    __m128 z = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination[2]), z);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreInt3A
-        (
-                uint32_t* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-    assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination[0] = V.vector4_u32[0];
-    pDestination[1] = V.vector4_u32[1];
-    pDestination[2] = V.vector4_u32[2];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t VL = vget_low_u32(vreinterpretq_u32_f32(V));
-#if defined(_MSC_VER) && !defined(__clang__)
-    vst1_u32_ex(pDestination, VL, 64);
-#else
-    vst1_u32(pDestination, VL);
-#endif
-    vst1q_lane_u32(pDestination + 2, *reinterpret_cast<const uint32x4_t*>(&V), 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(V));
-    __m128 z = _mm_movehl_ps(V, V);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination[2]), z);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat3
-        (
-                XMFLOAT3* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = V.vector4_f32[0];
-    pDestination->y = V.vector4_f32[1];
-    pDestination->z = V.vector4_f32[2];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    vst1_f32(reinterpret_cast<float*>(pDestination), VL);
-    vst1q_lane_f32(reinterpret_cast<float*>(pDestination) + 2, V, 2);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    * reinterpret_cast<int*>(&pDestination->x) = _mm_extract_ps(V, 0);
-    *reinterpret_cast<int*>(&pDestination->y) = _mm_extract_ps(V, 1);
-    *reinterpret_cast<int*>(&pDestination->z) = _mm_extract_ps(V, 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(V));
-    __m128 z = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-    _mm_store_ss(&pDestination->z, z);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat3A
-        (
-                XMFLOAT3A* pDestination,
-                FXMVECTOR     V
-        ) noexcept
-{
-    assert(pDestination);
-    assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = V.vector4_f32[0];
-    pDestination->y = V.vector4_f32[1];
-    pDestination->z = V.vector4_f32[2];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-#if defined(_MSC_VER) && !defined(__clang__)
-    vst1_f32_ex(reinterpret_cast<float*>(pDestination), VL, 64);
-#else
-    vst1_f32(reinterpret_cast<float*>(pDestination), VL);
-#endif
-    vst1q_lane_f32(reinterpret_cast<float*>(pDestination) + 2, V, 2);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(V));
-    *reinterpret_cast<int*>(&pDestination->z) = _mm_extract_ps(V, 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(V));
-    __m128 z = _mm_movehl_ps(V, V);
-    _mm_store_ss(&pDestination->z, z);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreSInt3
-        (
-                XMINT3* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = static_cast<int32_t>(V.vector4_f32[0]);
-    pDestination->y = static_cast<int32_t>(V.vector4_f32[1]);
-    pDestination->z = static_cast<int32_t>(V.vector4_f32[2]);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int32x4_t v = vcvtq_s32_f32(V);
-    int32x2_t vL = vget_low_s32(v);
-    vst1_s32(reinterpret_cast<int32_t*>(pDestination), vL);
-    vst1q_lane_s32(reinterpret_cast<int32_t*>(pDestination) + 2, v, 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // In case of positive overflow, detect it
-    XMVECTOR vOverflow = _mm_cmpgt_ps(V, g_XMMaxInt);
-    // Float to int conversion
-    __m128i vResulti = _mm_cvttps_epi32(V);
-    // If there was positive overflow, set to 0x7FFFFFFF
-    XMVECTOR vResult = _mm_and_ps(vOverflow, g_XMAbsMask);
-    vOverflow = _mm_andnot_ps(vOverflow, _mm_castsi128_ps(vResulti));
-    vOverflow = _mm_or_ps(vOverflow, vResult);
-    // Write 3 uints
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(vOverflow));
-    __m128 z = XM_PERMUTE_PS(vOverflow, _MM_SHUFFLE(2, 2, 2, 2));
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->z), z);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUInt3
-        (
-                XMUINT3* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = static_cast<uint32_t>(V.vector4_f32[0]);
-    pDestination->y = static_cast<uint32_t>(V.vector4_f32[1]);
-    pDestination->z = static_cast<uint32_t>(V.vector4_f32[2]);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t v = vcvtq_u32_f32(V);
-    uint32x2_t vL = vget_low_u32(v);
-    vst1_u32(reinterpret_cast<uint32_t*>(pDestination), vL);
-    vst1q_lane_u32(reinterpret_cast<uint32_t*>(pDestination) + 2, v, 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Clamp to >=0
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    // Any numbers that are too big, set to 0xFFFFFFFFU
-    XMVECTOR vOverflow = _mm_cmpgt_ps(vResult, g_XMMaxUInt);
-    XMVECTOR vValue = g_XMUnsignedFix;
-    // Too large for a signed integer?
-    XMVECTOR vMask = _mm_cmpge_ps(vResult, vValue);
-    // Zero for number's lower than 0x80000000, 32768.0f*65536.0f otherwise
-    vValue = _mm_and_ps(vValue, vMask);
-    // Perform fixup only on numbers too large (Keeps low bit precision)
-    vResult = _mm_sub_ps(vResult, vValue);
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Convert from signed to unsigned pnly if greater than 0x80000000
-    vMask = _mm_and_ps(vMask, g_XMNegativeZero);
-    vResult = _mm_xor_ps(_mm_castsi128_ps(vResulti), vMask);
-    // On those that are too large, set to 0xFFFFFFFF
-    vResult = _mm_or_ps(vResult, vOverflow);
-    // Write 3 uints
-    _mm_store_sd(reinterpret_cast<double*>(pDestination), _mm_castps_pd(vResult));
-    __m128 z = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(2, 2, 2, 2));
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->z), z);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreInt4
-        (
-                uint32_t* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination[0] = V.vector4_u32[0];
-    pDestination[1] = V.vector4_u32[1];
-    pDestination[2] = V.vector4_u32[2];
-    pDestination[3] = V.vector4_u32[3];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_u32(pDestination, vreinterpretq_u32_f32(V));
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_storeu_si128(reinterpret_cast<__m128i*>(pDestination), _mm_castps_si128(V));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreInt4A
-        (
-                uint32_t* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-    assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination[0] = V.vector4_u32[0];
-    pDestination[1] = V.vector4_u32[1];
-    pDestination[2] = V.vector4_u32[2];
-    pDestination[3] = V.vector4_u32[3];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    vst1q_u32_ex(pDestination, V, 128);
-#else
-    vst1q_u32(pDestination, vreinterpretq_u32_f32(V));
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_si128(reinterpret_cast<__m128i*>(pDestination), _mm_castps_si128(V));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat4
-        (
-                XMFLOAT4* pDestination,
-                FXMVECTOR  V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = V.vector4_f32[0];
-    pDestination->y = V.vector4_f32[1];
-    pDestination->z = V.vector4_f32[2];
-    pDestination->w = V.vector4_f32[3];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_f32(reinterpret_cast<float*>(pDestination), V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_storeu_ps(&pDestination->x, V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat4A
-        (
-                XMFLOAT4A* pDestination,
-                FXMVECTOR     V
-        ) noexcept
-{
-    assert(pDestination);
-    assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = V.vector4_f32[0];
-    pDestination->y = V.vector4_f32[1];
-    pDestination->z = V.vector4_f32[2];
-    pDestination->w = V.vector4_f32[3];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    vst1q_f32_ex(reinterpret_cast<float*>(pDestination), V, 128);
-#else
-    vst1q_f32(reinterpret_cast<float*>(pDestination), V);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_ps(&pDestination->x, V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreSInt4
-        (
-                XMINT4* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = static_cast<int32_t>(V.vector4_f32[0]);
-    pDestination->y = static_cast<int32_t>(V.vector4_f32[1]);
-    pDestination->z = static_cast<int32_t>(V.vector4_f32[2]);
-    pDestination->w = static_cast<int32_t>(V.vector4_f32[3]);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int32x4_t v = vcvtq_s32_f32(V);
-    vst1q_s32(reinterpret_cast<int32_t*>(pDestination), v);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // In case of positive overflow, detect it
-    XMVECTOR vOverflow = _mm_cmpgt_ps(V, g_XMMaxInt);
-    // Float to int conversion
-    __m128i vResulti = _mm_cvttps_epi32(V);
-    // If there was positive overflow, set to 0x7FFFFFFF
-    XMVECTOR vResult = _mm_and_ps(vOverflow, g_XMAbsMask);
-    vOverflow = _mm_andnot_ps(vOverflow, _mm_castsi128_ps(vResulti));
-    vOverflow = _mm_or_ps(vOverflow, vResult);
-    _mm_storeu_si128(reinterpret_cast<__m128i*>(pDestination), _mm_castps_si128(vOverflow));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUInt4
-        (
-                XMUINT4* pDestination,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-    pDestination->x = static_cast<uint32_t>(V.vector4_f32[0]);
-    pDestination->y = static_cast<uint32_t>(V.vector4_f32[1]);
-    pDestination->z = static_cast<uint32_t>(V.vector4_f32[2]);
-    pDestination->w = static_cast<uint32_t>(V.vector4_f32[3]);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t v = vcvtq_u32_f32(V);
-    vst1q_u32(reinterpret_cast<uint32_t*>(pDestination), v);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Clamp to >=0
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    // Any numbers that are too big, set to 0xFFFFFFFFU
-    XMVECTOR vOverflow = _mm_cmpgt_ps(vResult, g_XMMaxUInt);
-    XMVECTOR vValue = g_XMUnsignedFix;
-    // Too large for a signed integer?
-    XMVECTOR vMask = _mm_cmpge_ps(vResult, vValue);
-    // Zero for number's lower than 0x80000000, 32768.0f*65536.0f otherwise
-    vValue = _mm_and_ps(vValue, vMask);
-    // Perform fixup only on numbers too large (Keeps low bit precision)
-    vResult = _mm_sub_ps(vResult, vValue);
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Convert from signed to unsigned pnly if greater than 0x80000000
-    vMask = _mm_and_ps(vMask, g_XMNegativeZero);
-    vResult = _mm_xor_ps(_mm_castsi128_ps(vResulti), vMask);
-    // On those that are too large, set to 0xFFFFFFFF
-    vResult = _mm_or_ps(vResult, vOverflow);
-    _mm_storeu_si128(reinterpret_cast<__m128i*>(pDestination), _mm_castps_si128(vResult));
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat3x3
-        (
-                XMFLOAT3X3* pDestination,
-                FXMMATRIX   M
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-    pDestination->m[0][0] = M.r[0].vector4_f32[0];
-    pDestination->m[0][1] = M.r[0].vector4_f32[1];
-    pDestination->m[0][2] = M.r[0].vector4_f32[2];
-
-    pDestination->m[1][0] = M.r[1].vector4_f32[0];
-    pDestination->m[1][1] = M.r[1].vector4_f32[1];
-    pDestination->m[1][2] = M.r[1].vector4_f32[2];
-
-    pDestination->m[2][0] = M.r[2].vector4_f32[0];
-    pDestination->m[2][1] = M.r[2].vector4_f32[1];
-    pDestination->m[2][2] = M.r[2].vector4_f32[2];
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t T1 = vextq_f32(M.r[0], M.r[1], 1);
-    float32x4_t T2 = vbslq_f32(g_XMMask3, M.r[0], T1);
-    vst1q_f32(&pDestination->m[0][0], T2);
-
-    T1 = vextq_f32(M.r[1], M.r[1], 1);
-    T2 = vcombine_f32(vget_low_f32(T1), vget_low_f32(M.r[2]));
-    vst1q_f32(&pDestination->m[1][1], T2);
-
-    vst1q_lane_f32(&pDestination->m[2][2], M.r[2], 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp1 = M.r[0];
-    XMVECTOR vTemp2 = M.r[1];
-    XMVECTOR vTemp3 = M.r[2];
-    XMVECTOR vWork = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(0, 0, 2, 2));
-    vTemp1 = _mm_shuffle_ps(vTemp1, vWork, _MM_SHUFFLE(2, 0, 1, 0));
-    _mm_storeu_ps(&pDestination->m[0][0], vTemp1);
-    vTemp2 = _mm_shuffle_ps(vTemp2, vTemp3, _MM_SHUFFLE(1, 0, 2, 1));
-    _mm_storeu_ps(&pDestination->m[1][1], vTemp2);
-    vTemp3 = XM_PERMUTE_PS(vTemp3, _MM_SHUFFLE(2, 2, 2, 2));
-    _mm_store_ss(&pDestination->m[2][2], vTemp3);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat4x3
-        (
-                XMFLOAT4X3* pDestination,
-                FXMMATRIX M
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-    pDestination->m[0][0] = M.r[0].vector4_f32[0];
-    pDestination->m[0][1] = M.r[0].vector4_f32[1];
-    pDestination->m[0][2] = M.r[0].vector4_f32[2];
-
-    pDestination->m[1][0] = M.r[1].vector4_f32[0];
-    pDestination->m[1][1] = M.r[1].vector4_f32[1];
-    pDestination->m[1][2] = M.r[1].vector4_f32[2];
-
-    pDestination->m[2][0] = M.r[2].vector4_f32[0];
-    pDestination->m[2][1] = M.r[2].vector4_f32[1];
-    pDestination->m[2][2] = M.r[2].vector4_f32[2];
-
-    pDestination->m[3][0] = M.r[3].vector4_f32[0];
-    pDestination->m[3][1] = M.r[3].vector4_f32[1];
-    pDestination->m[3][2] = M.r[3].vector4_f32[2];
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t T1 = vextq_f32(M.r[0], M.r[1], 1);
-    float32x4_t T2 = vbslq_f32(g_XMMask3, M.r[0], T1);
-    vst1q_f32(&pDestination->m[0][0], T2);
-
-    T1 = vextq_f32(M.r[1], M.r[1], 1);
-    T2 = vcombine_f32(vget_low_f32(T1), vget_low_f32(M.r[2]));
-    vst1q_f32(&pDestination->m[1][1], T2);
-
-    T1 = vdupq_lane_f32(vget_high_f32(M.r[2]), 0);
-    T2 = vextq_f32(T1, M.r[3], 3);
-    vst1q_f32(&pDestination->m[2][2], T2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp1 = M.r[0];
-    XMVECTOR vTemp2 = M.r[1];
-    XMVECTOR vTemp3 = M.r[2];
-    XMVECTOR vTemp4 = M.r[3];
-    XMVECTOR vTemp2x = _mm_shuffle_ps(vTemp2, vTemp3, _MM_SHUFFLE(1, 0, 2, 1));
-    vTemp2 = _mm_shuffle_ps(vTemp2, vTemp1, _MM_SHUFFLE(2, 2, 0, 0));
-    vTemp1 = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(0, 2, 1, 0));
-    vTemp3 = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(0, 0, 2, 2));
-    vTemp3 = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(2, 1, 2, 0));
-    _mm_storeu_ps(&pDestination->m[0][0], vTemp1);
-    _mm_storeu_ps(&pDestination->m[1][1], vTemp2x);
-    _mm_storeu_ps(&pDestination->m[2][2], vTemp3);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat4x3A
-        (
-                XMFLOAT4X3A* pDestination,
-                FXMMATRIX       M
-        ) noexcept
-{
-    assert(pDestination);
-    assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-
-    pDestination->m[0][0] = M.r[0].vector4_f32[0];
-    pDestination->m[0][1] = M.r[0].vector4_f32[1];
-    pDestination->m[0][2] = M.r[0].vector4_f32[2];
-
-    pDestination->m[1][0] = M.r[1].vector4_f32[0];
-    pDestination->m[1][1] = M.r[1].vector4_f32[1];
-    pDestination->m[1][2] = M.r[1].vector4_f32[2];
-
-    pDestination->m[2][0] = M.r[2].vector4_f32[0];
-    pDestination->m[2][1] = M.r[2].vector4_f32[1];
-    pDestination->m[2][2] = M.r[2].vector4_f32[2];
-
-    pDestination->m[3][0] = M.r[3].vector4_f32[0];
-    pDestination->m[3][1] = M.r[3].vector4_f32[1];
-    pDestination->m[3][2] = M.r[3].vector4_f32[2];
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    float32x4_t T1 = vextq_f32(M.r[0], M.r[1], 1);
-    float32x4_t T2 = vbslq_f32(g_XMMask3, M.r[0], T1);
-    vst1q_f32_ex(&pDestination->m[0][0], T2, 128);
-
-    T1 = vextq_f32(M.r[1], M.r[1], 1);
-    T2 = vcombine_f32(vget_low_f32(T1), vget_low_f32(M.r[2]));
-    vst1q_f32_ex(&pDestination->m[1][1], T2, 128);
-
-    T1 = vdupq_lane_f32(vget_high_f32(M.r[2]), 0);
-    T2 = vextq_f32(T1, M.r[3], 3);
-    vst1q_f32_ex(&pDestination->m[2][2], T2, 128);
-#else
-    float32x4_t T1 = vextq_f32(M.r[0], M.r[1], 1);
-    float32x4_t T2 = vbslq_f32(g_XMMask3, M.r[0], T1);
-    vst1q_f32(&pDestination->m[0][0], T2);
-
-    T1 = vextq_f32(M.r[1], M.r[1], 1);
-    T2 = vcombine_f32(vget_low_f32(T1), vget_low_f32(M.r[2]));
-    vst1q_f32(&pDestination->m[1][1], T2);
-
-    T1 = vdupq_lane_f32(vget_high_f32(M.r[2]), 0);
-    T2 = vextq_f32(T1, M.r[3], 3);
-    vst1q_f32(&pDestination->m[2][2], T2);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    // x1,y1,z1,w1
-    XMVECTOR vTemp1 = M.r[0];
-    // x2,y2,z2,w2
-    XMVECTOR vTemp2 = M.r[1];
-    // x3,y3,z3,w3
-    XMVECTOR vTemp3 = M.r[2];
-    // x4,y4,z4,w4
-    XMVECTOR vTemp4 = M.r[3];
-    // z1,z1,x2,y2
-    XMVECTOR vTemp = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(1, 0, 2, 2));
-    // y2,z2,x3,y3 (Final)
-    vTemp2 = _mm_shuffle_ps(vTemp2, vTemp3, _MM_SHUFFLE(1, 0, 2, 1));
-    // x1,y1,z1,x2 (Final)
-    vTemp1 = _mm_shuffle_ps(vTemp1, vTemp, _MM_SHUFFLE(2, 0, 1, 0));
-    // z3,z3,x4,x4
-    vTemp3 = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(0, 0, 2, 2));
-    // z3,x4,y4,z4 (Final)
-    vTemp3 = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(2, 1, 2, 0));
-    // Store in 3 operations
-    _mm_store_ps(&pDestination->m[0][0], vTemp1);
-    _mm_store_ps(&pDestination->m[1][1], vTemp2);
-    _mm_store_ps(&pDestination->m[2][2], vTemp3);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat3x4
-        (
-                XMFLOAT3X4* pDestination,
-                FXMMATRIX M
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-    pDestination->m[0][0] = M.r[0].vector4_f32[0];
-    pDestination->m[0][1] = M.r[1].vector4_f32[0];
-    pDestination->m[0][2] = M.r[2].vector4_f32[0];
-    pDestination->m[0][3] = M.r[3].vector4_f32[0];
-
-    pDestination->m[1][0] = M.r[0].vector4_f32[1];
-    pDestination->m[1][1] = M.r[1].vector4_f32[1];
-    pDestination->m[1][2] = M.r[2].vector4_f32[1];
-    pDestination->m[1][3] = M.r[3].vector4_f32[1];
-
-    pDestination->m[2][0] = M.r[0].vector4_f32[2];
-    pDestination->m[2][1] = M.r[1].vector4_f32[2];
-    pDestination->m[2][2] = M.r[2].vector4_f32[2];
-    pDestination->m[2][3] = M.r[3].vector4_f32[2];
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4x2_t P0 = vzipq_f32(M.r[0], M.r[2]);
-    float32x4x2_t P1 = vzipq_f32(M.r[1], M.r[3]);
-
-    float32x4x2_t T0 = vzipq_f32(P0.val[0], P1.val[0]);
-    float32x4x2_t T1 = vzipq_f32(P0.val[1], P1.val[1]);
-
-    vst1q_f32(&pDestination->m[0][0], T0.val[0]);
-    vst1q_f32(&pDestination->m[1][0], T0.val[1]);
-    vst1q_f32(&pDestination->m[2][0], T1.val[0]);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // x.x,x.y,y.x,y.y
-    XMVECTOR vTemp1 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(1, 0, 1, 0));
-    // x.z,x.w,y.z,y.w
-    XMVECTOR vTemp3 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(3, 2, 3, 2));
-    // z.x,z.y,w.x,w.y
-    XMVECTOR vTemp2 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(1, 0, 1, 0));
-    // z.z,z.w,w.z,w.w
-    XMVECTOR vTemp4 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(3, 2, 3, 2));
-
-    // x.x,y.x,z.x,w.x
-    XMVECTOR r0 = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.y,y.y,z.y,w.y
-    XMVECTOR r1 = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(3, 1, 3, 1));
-    // x.z,y.z,z.z,w.z
-    XMVECTOR r2 = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(2, 0, 2, 0));
-
-    _mm_storeu_ps(&pDestination->m[0][0], r0);
-    _mm_storeu_ps(&pDestination->m[1][0], r1);
-    _mm_storeu_ps(&pDestination->m[2][0], r2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat3x4A
-        (
-                XMFLOAT3X4A* pDestination,
-                FXMMATRIX M
-        ) noexcept
-{
-    assert(pDestination);
-    assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-
-    pDestination->m[0][0] = M.r[0].vector4_f32[0];
-    pDestination->m[0][1] = M.r[1].vector4_f32[0];
-    pDestination->m[0][2] = M.r[2].vector4_f32[0];
-    pDestination->m[0][3] = M.r[3].vector4_f32[0];
-
-    pDestination->m[1][0] = M.r[0].vector4_f32[1];
-    pDestination->m[1][1] = M.r[1].vector4_f32[1];
-    pDestination->m[1][2] = M.r[2].vector4_f32[1];
-    pDestination->m[1][3] = M.r[3].vector4_f32[1];
-
-    pDestination->m[2][0] = M.r[0].vector4_f32[2];
-    pDestination->m[2][1] = M.r[1].vector4_f32[2];
-    pDestination->m[2][2] = M.r[2].vector4_f32[2];
-    pDestination->m[2][3] = M.r[3].vector4_f32[2];
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4x2_t P0 = vzipq_f32(M.r[0], M.r[2]);
-    float32x4x2_t P1 = vzipq_f32(M.r[1], M.r[3]);
-
-    float32x4x2_t T0 = vzipq_f32(P0.val[0], P1.val[0]);
-    float32x4x2_t T1 = vzipq_f32(P0.val[1], P1.val[1]);
-
-#if defined(_MSC_VER) && !defined(__clang__)
-    vst1q_f32_ex(&pDestination->m[0][0], T0.val[0], 128);
-    vst1q_f32_ex(&pDestination->m[1][0], T0.val[1], 128);
-    vst1q_f32_ex(&pDestination->m[2][0], T1.val[0], 128);
-#else
-    vst1q_f32(&pDestination->m[0][0], T0.val[0]);
-    vst1q_f32(&pDestination->m[1][0], T0.val[1]);
-    vst1q_f32(&pDestination->m[2][0], T1.val[0]);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    // x.x,x.y,y.x,y.y
-    XMVECTOR vTemp1 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(1, 0, 1, 0));
-    // x.z,x.w,y.z,y.w
-    XMVECTOR vTemp3 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(3, 2, 3, 2));
-    // z.x,z.y,w.x,w.y
-    XMVECTOR vTemp2 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(1, 0, 1, 0));
-    // z.z,z.w,w.z,w.w
-    XMVECTOR vTemp4 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(3, 2, 3, 2));
-
-    // x.x,y.x,z.x,w.x
-    XMVECTOR r0 = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.y,y.y,z.y,w.y
-    XMVECTOR r1 = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(3, 1, 3, 1));
-    // x.z,y.z,z.z,w.z
-    XMVECTOR r2 = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(2, 0, 2, 0));
-
-    _mm_store_ps(&pDestination->m[0][0], r0);
-    _mm_store_ps(&pDestination->m[1][0], r1);
-    _mm_store_ps(&pDestination->m[2][0], r2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat4x4
-        (
-                XMFLOAT4X4* pDestination,
-                FXMMATRIX M
-        ) noexcept
-{
-    assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-    pDestination->m[0][0] = M.r[0].vector4_f32[0];
-    pDestination->m[0][1] = M.r[0].vector4_f32[1];
-    pDestination->m[0][2] = M.r[0].vector4_f32[2];
-    pDestination->m[0][3] = M.r[0].vector4_f32[3];
-
-    pDestination->m[1][0] = M.r[1].vector4_f32[0];
-    pDestination->m[1][1] = M.r[1].vector4_f32[1];
-    pDestination->m[1][2] = M.r[1].vector4_f32[2];
-    pDestination->m[1][3] = M.r[1].vector4_f32[3];
-
-    pDestination->m[2][0] = M.r[2].vector4_f32[0];
-    pDestination->m[2][1] = M.r[2].vector4_f32[1];
-    pDestination->m[2][2] = M.r[2].vector4_f32[2];
-    pDestination->m[2][3] = M.r[2].vector4_f32[3];
-
-    pDestination->m[3][0] = M.r[3].vector4_f32[0];
-    pDestination->m[3][1] = M.r[3].vector4_f32[1];
-    pDestination->m[3][2] = M.r[3].vector4_f32[2];
-    pDestination->m[3][3] = M.r[3].vector4_f32[3];
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_f32(reinterpret_cast<float*>(&pDestination->_11), M.r[0]);
-    vst1q_f32(reinterpret_cast<float*>(&pDestination->_21), M.r[1]);
-    vst1q_f32(reinterpret_cast<float*>(&pDestination->_31), M.r[2]);
-    vst1q_f32(reinterpret_cast<float*>(&pDestination->_41), M.r[3]);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_storeu_ps(&pDestination->_11, M.r[0]);
-    _mm_storeu_ps(&pDestination->_21, M.r[1]);
-    _mm_storeu_ps(&pDestination->_31, M.r[2]);
-    _mm_storeu_ps(&pDestination->_41, M.r[3]);
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat4x4A
-        (
-                XMFLOAT4X4A* pDestination,
-                FXMMATRIX       M
-        ) noexcept
-{
-    assert(pDestination);
-    assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
-#if defined(_XM_NO_INTRINSICS_)
-
-    pDestination->m[0][0] = M.r[0].vector4_f32[0];
-    pDestination->m[0][1] = M.r[0].vector4_f32[1];
-    pDestination->m[0][2] = M.r[0].vector4_f32[2];
-    pDestination->m[0][3] = M.r[0].vector4_f32[3];
-
-    pDestination->m[1][0] = M.r[1].vector4_f32[0];
-    pDestination->m[1][1] = M.r[1].vector4_f32[1];
-    pDestination->m[1][2] = M.r[1].vector4_f32[2];
-    pDestination->m[1][3] = M.r[1].vector4_f32[3];
-
-    pDestination->m[2][0] = M.r[2].vector4_f32[0];
-    pDestination->m[2][1] = M.r[2].vector4_f32[1];
-    pDestination->m[2][2] = M.r[2].vector4_f32[2];
-    pDestination->m[2][3] = M.r[2].vector4_f32[3];
-
-    pDestination->m[3][0] = M.r[3].vector4_f32[0];
-    pDestination->m[3][1] = M.r[3].vector4_f32[1];
-    pDestination->m[3][2] = M.r[3].vector4_f32[2];
-    pDestination->m[3][3] = M.r[3].vector4_f32[3];
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_MSC_VER) && !defined(__clang__)
-    vst1q_f32_ex(reinterpret_cast<float*>(&pDestination->_11), M.r[0], 128);
-    vst1q_f32_ex(reinterpret_cast<float*>(&pDestination->_21), M.r[1], 128);
-    vst1q_f32_ex(reinterpret_cast<float*>(&pDestination->_31), M.r[2], 128);
-    vst1q_f32_ex(reinterpret_cast<float*>(&pDestination->_41), M.r[3], 128);
-#else
-    vst1q_f32(reinterpret_cast<float*>(&pDestination->_11), M.r[0]);
-    vst1q_f32(reinterpret_cast<float*>(&pDestination->_21), M.r[1]);
-    vst1q_f32(reinterpret_cast<float*>(&pDestination->_31), M.r[2]);
-    vst1q_f32(reinterpret_cast<float*>(&pDestination->_41), M.r[3]);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_ps(&pDestination->_11, M.r[0]);
-    _mm_store_ps(&pDestination->_21, M.r[1]);
-    _mm_store_ps(&pDestination->_31, M.r[2]);
-    _mm_store_ps(&pDestination->_41, M.r[3]);
-#endif
-}
-
diff --git a/thirdparty/directxmath/DirectXMathMatrix.inl b/thirdparty/directxmath/DirectXMathMatrix.inl
deleted file mode 100644
index ca179ce..0000000
--- a/thirdparty/directxmath/DirectXMathMatrix.inl
+++ /dev/null
@@ -1,3550 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXMathMatrix.inl -- SIMD C++ Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-/****************************************************************************
- *
- * Matrix
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-// Comparison operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(push)
-#pragma float_control(precise, on)
-#endif
-
-// Return true if any entry in the matrix is NaN
-inline bool XM_CALLCONV XMMatrixIsNaN(FXMMATRIX M) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    size_t i = 16;
-    auto pWork = reinterpret_cast<const uint32_t*>(&M.m[0][0]);
-    do {
-        // Fetch value into integer unit
-        uint32_t uTest = pWork[0];
-        // Remove sign
-        uTest &= 0x7FFFFFFFU;
-        // NaN is 0x7F800001 through 0x7FFFFFFF inclusive
-        uTest -= 0x7F800001U;
-        if (uTest < 0x007FFFFFU)
-        {
-            break;      // NaN found
-        }
-        ++pWork;        // Next entry
-    } while (--i);
-    return (i != 0);      // i == 0 if nothing matched
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Load in registers
-    float32x4_t vX = M.r[0];
-    float32x4_t vY = M.r[1];
-    float32x4_t vZ = M.r[2];
-    float32x4_t vW = M.r[3];
-    // Test themselves to check for NaN
-    uint32x4_t xmask = vmvnq_u32(vceqq_f32(vX, vX));
-    uint32x4_t ymask = vmvnq_u32(vceqq_f32(vY, vY));
-    uint32x4_t zmask = vmvnq_u32(vceqq_f32(vZ, vZ));
-    uint32x4_t wmask = vmvnq_u32(vceqq_f32(vW, vW));
-    // Or all the results
-    xmask = vorrq_u32(xmask, zmask);
-    ymask = vorrq_u32(ymask, wmask);
-    xmask = vorrq_u32(xmask, ymask);
-    // If any tested true, return true
-    uint8x8x2_t vTemp = vzip_u8(
-        vget_low_u8(vreinterpretq_u8_u32(xmask)),
-        vget_high_u8(vreinterpretq_u8_u32(xmask)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-    return (r != 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Load in registers
-    XMVECTOR vX = M.r[0];
-    XMVECTOR vY = M.r[1];
-    XMVECTOR vZ = M.r[2];
-    XMVECTOR vW = M.r[3];
-    // Test themselves to check for NaN
-    vX = _mm_cmpneq_ps(vX, vX);
-    vY = _mm_cmpneq_ps(vY, vY);
-    vZ = _mm_cmpneq_ps(vZ, vZ);
-    vW = _mm_cmpneq_ps(vW, vW);
-    // Or all the results
-    vX = _mm_or_ps(vX, vZ);
-    vY = _mm_or_ps(vY, vW);
-    vX = _mm_or_ps(vX, vY);
-    // If any tested true, return true
-    return (_mm_movemask_ps(vX) != 0);
-#else
-#endif
-}
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-// Return true if any entry in the matrix is +/-INF
-inline bool XM_CALLCONV XMMatrixIsInfinite(FXMMATRIX M) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    size_t i = 16;
-    auto pWork = reinterpret_cast<const uint32_t*>(&M.m[0][0]);
-    do {
-        // Fetch value into integer unit
-        uint32_t uTest = pWork[0];
-        // Remove sign
-        uTest &= 0x7FFFFFFFU;
-        // INF is 0x7F800000
-        if (uTest == 0x7F800000U)
-        {
-            break;      // INF found
-        }
-        ++pWork;        // Next entry
-    } while (--i);
-    return (i != 0);      // i == 0 if nothing matched
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Load in registers
-    float32x4_t vX = M.r[0];
-    float32x4_t vY = M.r[1];
-    float32x4_t vZ = M.r[2];
-    float32x4_t vW = M.r[3];
-    // Mask off the sign bits
-    vX = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(vX), g_XMAbsMask));
-    vY = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(vY), g_XMAbsMask));
-    vZ = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(vZ), g_XMAbsMask));
-    vW = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(vW), g_XMAbsMask));
-    // Compare to infinity
-    uint32x4_t xmask = vceqq_f32(vX, g_XMInfinity);
-    uint32x4_t ymask = vceqq_f32(vY, g_XMInfinity);
-    uint32x4_t zmask = vceqq_f32(vZ, g_XMInfinity);
-    uint32x4_t wmask = vceqq_f32(vW, g_XMInfinity);
-    // Or the answers together
-    xmask = vorrq_u32(xmask, zmask);
-    ymask = vorrq_u32(ymask, wmask);
-    xmask = vorrq_u32(xmask, ymask);
-    // If any tested true, return true
-    uint8x8x2_t vTemp = vzip_u8(
-        vget_low_u8(vreinterpretq_u8_u32(xmask)),
-        vget_high_u8(vreinterpretq_u8_u32(xmask)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-    return (r != 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Mask off the sign bits
-    XMVECTOR vTemp1 = _mm_and_ps(M.r[0], g_XMAbsMask);
-    XMVECTOR vTemp2 = _mm_and_ps(M.r[1], g_XMAbsMask);
-    XMVECTOR vTemp3 = _mm_and_ps(M.r[2], g_XMAbsMask);
-    XMVECTOR vTemp4 = _mm_and_ps(M.r[3], g_XMAbsMask);
-    // Compare to infinity
-    vTemp1 = _mm_cmpeq_ps(vTemp1, g_XMInfinity);
-    vTemp2 = _mm_cmpeq_ps(vTemp2, g_XMInfinity);
-    vTemp3 = _mm_cmpeq_ps(vTemp3, g_XMInfinity);
-    vTemp4 = _mm_cmpeq_ps(vTemp4, g_XMInfinity);
-    // Or the answers together
-    vTemp1 = _mm_or_ps(vTemp1, vTemp2);
-    vTemp3 = _mm_or_ps(vTemp3, vTemp4);
-    vTemp1 = _mm_or_ps(vTemp1, vTemp3);
-    // If any are infinity, the signs are true.
-    return (_mm_movemask_ps(vTemp1) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Return true if the XMMatrix is equal to identity
-inline bool XM_CALLCONV XMMatrixIsIdentity(FXMMATRIX M) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    // Use the integer pipeline to reduce branching to a minimum
-    auto pWork = reinterpret_cast<const uint32_t*>(&M.m[0][0]);
-    // Convert 1.0f to zero and or them together
-    uint32_t uOne = pWork[0] ^ 0x3F800000U;
-    // Or all the 0.0f entries together
-    uint32_t uZero = pWork[1];
-    uZero |= pWork[2];
-    uZero |= pWork[3];
-    // 2nd row
-    uZero |= pWork[4];
-    uOne |= pWork[5] ^ 0x3F800000U;
-    uZero |= pWork[6];
-    uZero |= pWork[7];
-    // 3rd row
-    uZero |= pWork[8];
-    uZero |= pWork[9];
-    uOne |= pWork[10] ^ 0x3F800000U;
-    uZero |= pWork[11];
-    // 4th row
-    uZero |= pWork[12];
-    uZero |= pWork[13];
-    uZero |= pWork[14];
-    uOne |= pWork[15] ^ 0x3F800000U;
-    // If all zero entries are zero, the uZero==0
-    uZero &= 0x7FFFFFFF;    // Allow -0.0f
-    // If all 1.0f entries are 1.0f, then uOne==0
-    uOne |= uZero;
-    return (uOne == 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t xmask = vceqq_f32(M.r[0], g_XMIdentityR0);
-    uint32x4_t ymask = vceqq_f32(M.r[1], g_XMIdentityR1);
-    uint32x4_t zmask = vceqq_f32(M.r[2], g_XMIdentityR2);
-    uint32x4_t wmask = vceqq_f32(M.r[3], g_XMIdentityR3);
-    xmask = vandq_u32(xmask, zmask);
-    ymask = vandq_u32(ymask, wmask);
-    xmask = vandq_u32(xmask, ymask);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(xmask)), vget_high_u8(vreinterpretq_u8_u32(xmask)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-    return (r == 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp1 = _mm_cmpeq_ps(M.r[0], g_XMIdentityR0);
-    XMVECTOR vTemp2 = _mm_cmpeq_ps(M.r[1], g_XMIdentityR1);
-    XMVECTOR vTemp3 = _mm_cmpeq_ps(M.r[2], g_XMIdentityR2);
-    XMVECTOR vTemp4 = _mm_cmpeq_ps(M.r[3], g_XMIdentityR3);
-    vTemp1 = _mm_and_ps(vTemp1, vTemp2);
-    vTemp3 = _mm_and_ps(vTemp3, vTemp4);
-    vTemp1 = _mm_and_ps(vTemp1, vTemp3);
-    return (_mm_movemask_ps(vTemp1) == 0x0f);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Computation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-// Perform a 4x4 matrix multiply by a 4x4 matrix
-inline XMMATRIX XM_CALLCONV XMMatrixMultiply
-        (
-                FXMMATRIX M1,
-                CXMMATRIX M2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMMATRIX mResult;
-    // Cache the invariants in registers
-    float x = M1.m[0][0];
-    float y = M1.m[0][1];
-    float z = M1.m[0][2];
-    float w = M1.m[0][3];
-    // Perform the operation on the first row
-    mResult.m[0][0] = (M2.m[0][0] * x) + (M2.m[1][0] * y) + (M2.m[2][0] * z) + (M2.m[3][0] * w);
-    mResult.m[0][1] = (M2.m[0][1] * x) + (M2.m[1][1] * y) + (M2.m[2][1] * z) + (M2.m[3][1] * w);
-    mResult.m[0][2] = (M2.m[0][2] * x) + (M2.m[1][2] * y) + (M2.m[2][2] * z) + (M2.m[3][2] * w);
-    mResult.m[0][3] = (M2.m[0][3] * x) + (M2.m[1][3] * y) + (M2.m[2][3] * z) + (M2.m[3][3] * w);
-    // Repeat for all the other rows
-    x = M1.m[1][0];
-    y = M1.m[1][1];
-    z = M1.m[1][2];
-    w = M1.m[1][3];
-    mResult.m[1][0] = (M2.m[0][0] * x) + (M2.m[1][0] * y) + (M2.m[2][0] * z) + (M2.m[3][0] * w);
-    mResult.m[1][1] = (M2.m[0][1] * x) + (M2.m[1][1] * y) + (M2.m[2][1] * z) + (M2.m[3][1] * w);
-    mResult.m[1][2] = (M2.m[0][2] * x) + (M2.m[1][2] * y) + (M2.m[2][2] * z) + (M2.m[3][2] * w);
-    mResult.m[1][3] = (M2.m[0][3] * x) + (M2.m[1][3] * y) + (M2.m[2][3] * z) + (M2.m[3][3] * w);
-    x = M1.m[2][0];
-    y = M1.m[2][1];
-    z = M1.m[2][2];
-    w = M1.m[2][3];
-    mResult.m[2][0] = (M2.m[0][0] * x) + (M2.m[1][0] * y) + (M2.m[2][0] * z) + (M2.m[3][0] * w);
-    mResult.m[2][1] = (M2.m[0][1] * x) + (M2.m[1][1] * y) + (M2.m[2][1] * z) + (M2.m[3][1] * w);
-    mResult.m[2][2] = (M2.m[0][2] * x) + (M2.m[1][2] * y) + (M2.m[2][2] * z) + (M2.m[3][2] * w);
-    mResult.m[2][3] = (M2.m[0][3] * x) + (M2.m[1][3] * y) + (M2.m[2][3] * z) + (M2.m[3][3] * w);
-    x = M1.m[3][0];
-    y = M1.m[3][1];
-    z = M1.m[3][2];
-    w = M1.m[3][3];
-    mResult.m[3][0] = (M2.m[0][0] * x) + (M2.m[1][0] * y) + (M2.m[2][0] * z) + (M2.m[3][0] * w);
-    mResult.m[3][1] = (M2.m[0][1] * x) + (M2.m[1][1] * y) + (M2.m[2][1] * z) + (M2.m[3][1] * w);
-    mResult.m[3][2] = (M2.m[0][2] * x) + (M2.m[1][2] * y) + (M2.m[2][2] * z) + (M2.m[3][2] * w);
-    mResult.m[3][3] = (M2.m[0][3] * x) + (M2.m[1][3] * y) + (M2.m[2][3] * z) + (M2.m[3][3] * w);
-    return mResult;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMMATRIX mResult;
-    float32x2_t VL = vget_low_f32(M1.r[0]);
-    float32x2_t VH = vget_high_f32(M1.r[0]);
-    // Perform the operation on the first row
-    float32x4_t vX = vmulq_lane_f32(M2.r[0], VL, 0);
-    float32x4_t vY = vmulq_lane_f32(M2.r[1], VL, 1);
-    float32x4_t vZ = vmlaq_lane_f32(vX, M2.r[2], VH, 0);
-    float32x4_t vW = vmlaq_lane_f32(vY, M2.r[3], VH, 1);
-    mResult.r[0] = vaddq_f32(vZ, vW);
-    // Repeat for the other 3 rows
-    VL = vget_low_f32(M1.r[1]);
-    VH = vget_high_f32(M1.r[1]);
-    vX = vmulq_lane_f32(M2.r[0], VL, 0);
-    vY = vmulq_lane_f32(M2.r[1], VL, 1);
-    vZ = vmlaq_lane_f32(vX, M2.r[2], VH, 0);
-    vW = vmlaq_lane_f32(vY, M2.r[3], VH, 1);
-    mResult.r[1] = vaddq_f32(vZ, vW);
-    VL = vget_low_f32(M1.r[2]);
-    VH = vget_high_f32(M1.r[2]);
-    vX = vmulq_lane_f32(M2.r[0], VL, 0);
-    vY = vmulq_lane_f32(M2.r[1], VL, 1);
-    vZ = vmlaq_lane_f32(vX, M2.r[2], VH, 0);
-    vW = vmlaq_lane_f32(vY, M2.r[3], VH, 1);
-    mResult.r[2] = vaddq_f32(vZ, vW);
-    VL = vget_low_f32(M1.r[3]);
-    VH = vget_high_f32(M1.r[3]);
-    vX = vmulq_lane_f32(M2.r[0], VL, 0);
-    vY = vmulq_lane_f32(M2.r[1], VL, 1);
-    vZ = vmlaq_lane_f32(vX, M2.r[2], VH, 0);
-    vW = vmlaq_lane_f32(vY, M2.r[3], VH, 1);
-    mResult.r[3] = vaddq_f32(vZ, vW);
-    return mResult;
-#elif defined(_XM_AVX2_INTRINSICS_)
-    __m256 t0 = _mm256_castps128_ps256(M1.r[0]);
-    t0 = _mm256_insertf128_ps(t0, M1.r[1], 1);
-    __m256 t1 = _mm256_castps128_ps256(M1.r[2]);
-    t1 = _mm256_insertf128_ps(t1, M1.r[3], 1);
-
-    __m256 u0 = _mm256_castps128_ps256(M2.r[0]);
-    u0 = _mm256_insertf128_ps(u0, M2.r[1], 1);
-    __m256 u1 = _mm256_castps128_ps256(M2.r[2]);
-    u1 = _mm256_insertf128_ps(u1, M2.r[3], 1);
-
-    __m256 a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(0, 0, 0, 0));
-    __m256 a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(0, 0, 0, 0));
-    __m256 b0 = _mm256_permute2f128_ps(u0, u0, 0x00);
-    __m256 c0 = _mm256_mul_ps(a0, b0);
-    __m256 c1 = _mm256_mul_ps(a1, b0);
-
-    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(1, 1, 1, 1));
-    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(1, 1, 1, 1));
-    b0 = _mm256_permute2f128_ps(u0, u0, 0x11);
-    __m256 c2 = _mm256_fmadd_ps(a0, b0, c0);
-    __m256 c3 = _mm256_fmadd_ps(a1, b0, c1);
-
-    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(2, 2, 2, 2));
-    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(2, 2, 2, 2));
-    __m256 b1 = _mm256_permute2f128_ps(u1, u1, 0x00);
-    __m256 c4 = _mm256_mul_ps(a0, b1);
-    __m256 c5 = _mm256_mul_ps(a1, b1);
-
-    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(3, 3, 3, 3));
-    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(3, 3, 3, 3));
-    b1 = _mm256_permute2f128_ps(u1, u1, 0x11);
-    __m256 c6 = _mm256_fmadd_ps(a0, b1, c4);
-    __m256 c7 = _mm256_fmadd_ps(a1, b1, c5);
-
-    t0 = _mm256_add_ps(c2, c6);
-    t1 = _mm256_add_ps(c3, c7);
-
-    XMMATRIX mResult;
-    mResult.r[0] = _mm256_castps256_ps128(t0);
-    mResult.r[1] = _mm256_extractf128_ps(t0, 1);
-    mResult.r[2] = _mm256_castps256_ps128(t1);
-    mResult.r[3] = _mm256_extractf128_ps(t1, 1);
-    return mResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX mResult;
-    // Splat the component X,Y,Z then W
-#if defined(_XM_AVX_INTRINSICS_)
-    XMVECTOR vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 0);
-    XMVECTOR vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 1);
-    XMVECTOR vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 2);
-    XMVECTOR vW = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 3);
-#else
-    // Use vW to hold the original row
-    XMVECTOR vW = M1.r[0];
-    XMVECTOR vX = XM_PERMUTE_PS(vW, _MM_SHUFFLE(0, 0, 0, 0));
-    XMVECTOR vY = XM_PERMUTE_PS(vW, _MM_SHUFFLE(1, 1, 1, 1));
-    XMVECTOR vZ = XM_PERMUTE_PS(vW, _MM_SHUFFLE(2, 2, 2, 2));
-    vW = XM_PERMUTE_PS(vW, _MM_SHUFFLE(3, 3, 3, 3));
-#endif
-    // Perform the operation on the first row
-    vX = _mm_mul_ps(vX, M2.r[0]);
-    vY = _mm_mul_ps(vY, M2.r[1]);
-    vZ = _mm_mul_ps(vZ, M2.r[2]);
-    vW = _mm_mul_ps(vW, M2.r[3]);
-    // Perform a binary add to reduce cumulative errors
-    vX = _mm_add_ps(vX, vZ);
-    vY = _mm_add_ps(vY, vW);
-    vX = _mm_add_ps(vX, vY);
-    mResult.r[0] = vX;
-    // Repeat for the other 3 rows
-#if defined(_XM_AVX_INTRINSICS_)
-    vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 0);
-    vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 1);
-    vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 2);
-    vW = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 3);
-#else
-    vW = M1.r[1];
-    vX = XM_PERMUTE_PS(vW, _MM_SHUFFLE(0, 0, 0, 0));
-    vY = XM_PERMUTE_PS(vW, _MM_SHUFFLE(1, 1, 1, 1));
-    vZ = XM_PERMUTE_PS(vW, _MM_SHUFFLE(2, 2, 2, 2));
-    vW = XM_PERMUTE_PS(vW, _MM_SHUFFLE(3, 3, 3, 3));
-#endif
-    vX = _mm_mul_ps(vX, M2.r[0]);
-    vY = _mm_mul_ps(vY, M2.r[1]);
-    vZ = _mm_mul_ps(vZ, M2.r[2]);
-    vW = _mm_mul_ps(vW, M2.r[3]);
-    vX = _mm_add_ps(vX, vZ);
-    vY = _mm_add_ps(vY, vW);
-    vX = _mm_add_ps(vX, vY);
-    mResult.r[1] = vX;
-#if defined(_XM_AVX_INTRINSICS_)
-    vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 0);
-    vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 1);
-    vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 2);
-    vW = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 3);
-#else
-    vW = M1.r[2];
-    vX = XM_PERMUTE_PS(vW, _MM_SHUFFLE(0, 0, 0, 0));
-    vY = XM_PERMUTE_PS(vW, _MM_SHUFFLE(1, 1, 1, 1));
-    vZ = XM_PERMUTE_PS(vW, _MM_SHUFFLE(2, 2, 2, 2));
-    vW = XM_PERMUTE_PS(vW, _MM_SHUFFLE(3, 3, 3, 3));
-#endif
-    vX = _mm_mul_ps(vX, M2.r[0]);
-    vY = _mm_mul_ps(vY, M2.r[1]);
-    vZ = _mm_mul_ps(vZ, M2.r[2]);
-    vW = _mm_mul_ps(vW, M2.r[3]);
-    vX = _mm_add_ps(vX, vZ);
-    vY = _mm_add_ps(vY, vW);
-    vX = _mm_add_ps(vX, vY);
-    mResult.r[2] = vX;
-#if defined(_XM_AVX_INTRINSICS_)
-    vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 0);
-    vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 1);
-    vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 2);
-    vW = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 3);
-#else
-    vW = M1.r[3];
-    vX = XM_PERMUTE_PS(vW, _MM_SHUFFLE(0, 0, 0, 0));
-    vY = XM_PERMUTE_PS(vW, _MM_SHUFFLE(1, 1, 1, 1));
-    vZ = XM_PERMUTE_PS(vW, _MM_SHUFFLE(2, 2, 2, 2));
-    vW = XM_PERMUTE_PS(vW, _MM_SHUFFLE(3, 3, 3, 3));
-#endif
-    vX = _mm_mul_ps(vX, M2.r[0]);
-    vY = _mm_mul_ps(vY, M2.r[1]);
-    vZ = _mm_mul_ps(vZ, M2.r[2]);
-    vW = _mm_mul_ps(vW, M2.r[3]);
-    vX = _mm_add_ps(vX, vZ);
-    vY = _mm_add_ps(vY, vW);
-    vX = _mm_add_ps(vX, vY);
-    mResult.r[3] = vX;
-    return mResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixMultiplyTranspose
-        (
-                FXMMATRIX M1,
-                CXMMATRIX M2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMMATRIX mResult;
-    // Cache the invariants in registers
-    float x = M2.m[0][0];
-    float y = M2.m[1][0];
-    float z = M2.m[2][0];
-    float w = M2.m[3][0];
-    // Perform the operation on the first row
-    mResult.m[0][0] = (M1.m[0][0] * x) + (M1.m[0][1] * y) + (M1.m[0][2] * z) + (M1.m[0][3] * w);
-    mResult.m[0][1] = (M1.m[1][0] * x) + (M1.m[1][1] * y) + (M1.m[1][2] * z) + (M1.m[1][3] * w);
-    mResult.m[0][2] = (M1.m[2][0] * x) + (M1.m[2][1] * y) + (M1.m[2][2] * z) + (M1.m[2][3] * w);
-    mResult.m[0][3] = (M1.m[3][0] * x) + (M1.m[3][1] * y) + (M1.m[3][2] * z) + (M1.m[3][3] * w);
-    // Repeat for all the other rows
-    x = M2.m[0][1];
-    y = M2.m[1][1];
-    z = M2.m[2][1];
-    w = M2.m[3][1];
-    mResult.m[1][0] = (M1.m[0][0] * x) + (M1.m[0][1] * y) + (M1.m[0][2] * z) + (M1.m[0][3] * w);
-    mResult.m[1][1] = (M1.m[1][0] * x) + (M1.m[1][1] * y) + (M1.m[1][2] * z) + (M1.m[1][3] * w);
-    mResult.m[1][2] = (M1.m[2][0] * x) + (M1.m[2][1] * y) + (M1.m[2][2] * z) + (M1.m[2][3] * w);
-    mResult.m[1][3] = (M1.m[3][0] * x) + (M1.m[3][1] * y) + (M1.m[3][2] * z) + (M1.m[3][3] * w);
-    x = M2.m[0][2];
-    y = M2.m[1][2];
-    z = M2.m[2][2];
-    w = M2.m[3][2];
-    mResult.m[2][0] = (M1.m[0][0] * x) + (M1.m[0][1] * y) + (M1.m[0][2] * z) + (M1.m[0][3] * w);
-    mResult.m[2][1] = (M1.m[1][0] * x) + (M1.m[1][1] * y) + (M1.m[1][2] * z) + (M1.m[1][3] * w);
-    mResult.m[2][2] = (M1.m[2][0] * x) + (M1.m[2][1] * y) + (M1.m[2][2] * z) + (M1.m[2][3] * w);
-    mResult.m[2][3] = (M1.m[3][0] * x) + (M1.m[3][1] * y) + (M1.m[3][2] * z) + (M1.m[3][3] * w);
-    x = M2.m[0][3];
-    y = M2.m[1][3];
-    z = M2.m[2][3];
-    w = M2.m[3][3];
-    mResult.m[3][0] = (M1.m[0][0] * x) + (M1.m[0][1] * y) + (M1.m[0][2] * z) + (M1.m[0][3] * w);
-    mResult.m[3][1] = (M1.m[1][0] * x) + (M1.m[1][1] * y) + (M1.m[1][2] * z) + (M1.m[1][3] * w);
-    mResult.m[3][2] = (M1.m[2][0] * x) + (M1.m[2][1] * y) + (M1.m[2][2] * z) + (M1.m[2][3] * w);
-    mResult.m[3][3] = (M1.m[3][0] * x) + (M1.m[3][1] * y) + (M1.m[3][2] * z) + (M1.m[3][3] * w);
-    return mResult;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(M1.r[0]);
-    float32x2_t VH = vget_high_f32(M1.r[0]);
-    // Perform the operation on the first row
-    float32x4_t vX = vmulq_lane_f32(M2.r[0], VL, 0);
-    float32x4_t vY = vmulq_lane_f32(M2.r[1], VL, 1);
-    float32x4_t vZ = vmlaq_lane_f32(vX, M2.r[2], VH, 0);
-    float32x4_t vW = vmlaq_lane_f32(vY, M2.r[3], VH, 1);
-    float32x4_t r0 = vaddq_f32(vZ, vW);
-    // Repeat for the other 3 rows
-    VL = vget_low_f32(M1.r[1]);
-    VH = vget_high_f32(M1.r[1]);
-    vX = vmulq_lane_f32(M2.r[0], VL, 0);
-    vY = vmulq_lane_f32(M2.r[1], VL, 1);
-    vZ = vmlaq_lane_f32(vX, M2.r[2], VH, 0);
-    vW = vmlaq_lane_f32(vY, M2.r[3], VH, 1);
-    float32x4_t r1 = vaddq_f32(vZ, vW);
-    VL = vget_low_f32(M1.r[2]);
-    VH = vget_high_f32(M1.r[2]);
-    vX = vmulq_lane_f32(M2.r[0], VL, 0);
-    vY = vmulq_lane_f32(M2.r[1], VL, 1);
-    vZ = vmlaq_lane_f32(vX, M2.r[2], VH, 0);
-    vW = vmlaq_lane_f32(vY, M2.r[3], VH, 1);
-    float32x4_t r2 = vaddq_f32(vZ, vW);
-    VL = vget_low_f32(M1.r[3]);
-    VH = vget_high_f32(M1.r[3]);
-    vX = vmulq_lane_f32(M2.r[0], VL, 0);
-    vY = vmulq_lane_f32(M2.r[1], VL, 1);
-    vZ = vmlaq_lane_f32(vX, M2.r[2], VH, 0);
-    vW = vmlaq_lane_f32(vY, M2.r[3], VH, 1);
-    float32x4_t r3 = vaddq_f32(vZ, vW);
-
-    // Transpose result
-    float32x4x2_t P0 = vzipq_f32(r0, r2);
-    float32x4x2_t P1 = vzipq_f32(r1, r3);
-
-    float32x4x2_t T0 = vzipq_f32(P0.val[0], P1.val[0]);
-    float32x4x2_t T1 = vzipq_f32(P0.val[1], P1.val[1]);
-
-    XMMATRIX mResult;
-    mResult.r[0] = T0.val[0];
-    mResult.r[1] = T0.val[1];
-    mResult.r[2] = T1.val[0];
-    mResult.r[3] = T1.val[1];
-    return mResult;
-#elif defined(_XM_AVX2_INTRINSICS_)
-    __m256 t0 = _mm256_castps128_ps256(M1.r[0]);
-    t0 = _mm256_insertf128_ps(t0, M1.r[1], 1);
-    __m256 t1 = _mm256_castps128_ps256(M1.r[2]);
-    t1 = _mm256_insertf128_ps(t1, M1.r[3], 1);
-
-    __m256 u0 = _mm256_castps128_ps256(M2.r[0]);
-    u0 = _mm256_insertf128_ps(u0, M2.r[1], 1);
-    __m256 u1 = _mm256_castps128_ps256(M2.r[2]);
-    u1 = _mm256_insertf128_ps(u1, M2.r[3], 1);
-
-    __m256 a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(0, 0, 0, 0));
-    __m256 a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(0, 0, 0, 0));
-    __m256 b0 = _mm256_permute2f128_ps(u0, u0, 0x00);
-    __m256 c0 = _mm256_mul_ps(a0, b0);
-    __m256 c1 = _mm256_mul_ps(a1, b0);
-
-    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(1, 1, 1, 1));
-    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(1, 1, 1, 1));
-    b0 = _mm256_permute2f128_ps(u0, u0, 0x11);
-    __m256 c2 = _mm256_fmadd_ps(a0, b0, c0);
-    __m256 c3 = _mm256_fmadd_ps(a1, b0, c1);
-
-    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(2, 2, 2, 2));
-    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(2, 2, 2, 2));
-    __m256 b1 = _mm256_permute2f128_ps(u1, u1, 0x00);
-    __m256 c4 = _mm256_mul_ps(a0, b1);
-    __m256 c5 = _mm256_mul_ps(a1, b1);
-
-    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(3, 3, 3, 3));
-    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(3, 3, 3, 3));
-    b1 = _mm256_permute2f128_ps(u1, u1, 0x11);
-    __m256 c6 = _mm256_fmadd_ps(a0, b1, c4);
-    __m256 c7 = _mm256_fmadd_ps(a1, b1, c5);
-
-    t0 = _mm256_add_ps(c2, c6);
-    t1 = _mm256_add_ps(c3, c7);
-
-    // Transpose result
-    __m256 vTemp = _mm256_unpacklo_ps(t0, t1);
-    __m256 vTemp2 = _mm256_unpackhi_ps(t0, t1);
-    __m256 vTemp3 = _mm256_permute2f128_ps(vTemp, vTemp2, 0x20);
-    __m256 vTemp4 = _mm256_permute2f128_ps(vTemp, vTemp2, 0x31);
-    vTemp = _mm256_unpacklo_ps(vTemp3, vTemp4);
-    vTemp2 = _mm256_unpackhi_ps(vTemp3, vTemp4);
-    t0 = _mm256_permute2f128_ps(vTemp, vTemp2, 0x20);
-    t1 = _mm256_permute2f128_ps(vTemp, vTemp2, 0x31);
-
-    XMMATRIX mResult;
-    mResult.r[0] = _mm256_castps256_ps128(t0);
-    mResult.r[1] = _mm256_extractf128_ps(t0, 1);
-    mResult.r[2] = _mm256_castps256_ps128(t1);
-    mResult.r[3] = _mm256_extractf128_ps(t1, 1);
-    return mResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Splat the component X,Y,Z then W
-#if defined(_XM_AVX_INTRINSICS_)
-    XMVECTOR vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 0);
-    XMVECTOR vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 1);
-    XMVECTOR vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 2);
-    XMVECTOR vW = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 3);
-#else
-    // Use vW to hold the original row
-    XMVECTOR vW = M1.r[0];
-    XMVECTOR vX = XM_PERMUTE_PS(vW, _MM_SHUFFLE(0, 0, 0, 0));
-    XMVECTOR vY = XM_PERMUTE_PS(vW, _MM_SHUFFLE(1, 1, 1, 1));
-    XMVECTOR vZ = XM_PERMUTE_PS(vW, _MM_SHUFFLE(2, 2, 2, 2));
-    vW = XM_PERMUTE_PS(vW, _MM_SHUFFLE(3, 3, 3, 3));
-#endif
-    // Perform the operation on the first row
-    vX = _mm_mul_ps(vX, M2.r[0]);
-    vY = _mm_mul_ps(vY, M2.r[1]);
-    vZ = _mm_mul_ps(vZ, M2.r[2]);
-    vW = _mm_mul_ps(vW, M2.r[3]);
-    // Perform a binary add to reduce cumulative errors
-    vX = _mm_add_ps(vX, vZ);
-    vY = _mm_add_ps(vY, vW);
-    vX = _mm_add_ps(vX, vY);
-    XMVECTOR r0 = vX;
-    // Repeat for the other 3 rows
-#if defined(_XM_AVX_INTRINSICS_)
-    vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 0);
-    vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 1);
-    vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 2);
-    vW = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 3);
-#else
-    vW = M1.r[1];
-    vX = XM_PERMUTE_PS(vW, _MM_SHUFFLE(0, 0, 0, 0));
-    vY = XM_PERMUTE_PS(vW, _MM_SHUFFLE(1, 1, 1, 1));
-    vZ = XM_PERMUTE_PS(vW, _MM_SHUFFLE(2, 2, 2, 2));
-    vW = XM_PERMUTE_PS(vW, _MM_SHUFFLE(3, 3, 3, 3));
-#endif
-    vX = _mm_mul_ps(vX, M2.r[0]);
-    vY = _mm_mul_ps(vY, M2.r[1]);
-    vZ = _mm_mul_ps(vZ, M2.r[2]);
-    vW = _mm_mul_ps(vW, M2.r[3]);
-    vX = _mm_add_ps(vX, vZ);
-    vY = _mm_add_ps(vY, vW);
-    vX = _mm_add_ps(vX, vY);
-    XMVECTOR r1 = vX;
-#if defined(_XM_AVX_INTRINSICS_)
-    vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 0);
-    vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 1);
-    vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 2);
-    vW = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 3);
-#else
-    vW = M1.r[2];
-    vX = XM_PERMUTE_PS(vW, _MM_SHUFFLE(0, 0, 0, 0));
-    vY = XM_PERMUTE_PS(vW, _MM_SHUFFLE(1, 1, 1, 1));
-    vZ = XM_PERMUTE_PS(vW, _MM_SHUFFLE(2, 2, 2, 2));
-    vW = XM_PERMUTE_PS(vW, _MM_SHUFFLE(3, 3, 3, 3));
-#endif
-    vX = _mm_mul_ps(vX, M2.r[0]);
-    vY = _mm_mul_ps(vY, M2.r[1]);
-    vZ = _mm_mul_ps(vZ, M2.r[2]);
-    vW = _mm_mul_ps(vW, M2.r[3]);
-    vX = _mm_add_ps(vX, vZ);
-    vY = _mm_add_ps(vY, vW);
-    vX = _mm_add_ps(vX, vY);
-    XMVECTOR r2 = vX;
-#if defined(_XM_AVX_INTRINSICS_)
-    vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 0);
-    vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 1);
-    vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 2);
-    vW = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 3);
-#else
-    vW = M1.r[3];
-    vX = XM_PERMUTE_PS(vW, _MM_SHUFFLE(0, 0, 0, 0));
-    vY = XM_PERMUTE_PS(vW, _MM_SHUFFLE(1, 1, 1, 1));
-    vZ = XM_PERMUTE_PS(vW, _MM_SHUFFLE(2, 2, 2, 2));
-    vW = XM_PERMUTE_PS(vW, _MM_SHUFFLE(3, 3, 3, 3));
-#endif
-    vX = _mm_mul_ps(vX, M2.r[0]);
-    vY = _mm_mul_ps(vY, M2.r[1]);
-    vZ = _mm_mul_ps(vZ, M2.r[2]);
-    vW = _mm_mul_ps(vW, M2.r[3]);
-    vX = _mm_add_ps(vX, vZ);
-    vY = _mm_add_ps(vY, vW);
-    vX = _mm_add_ps(vX, vY);
-    XMVECTOR r3 = vX;
-
-    // Transpose result
-    // x.x,x.y,y.x,y.y
-    XMVECTOR vTemp1 = _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(1, 0, 1, 0));
-    // x.z,x.w,y.z,y.w
-    XMVECTOR vTemp3 = _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(3, 2, 3, 2));
-    // z.x,z.y,w.x,w.y
-    XMVECTOR vTemp2 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(1, 0, 1, 0));
-    // z.z,z.w,w.z,w.w
-    XMVECTOR vTemp4 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(3, 2, 3, 2));
-
-    XMMATRIX mResult;
-    // x.x,y.x,z.x,w.x
-    mResult.r[0] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.y,y.y,z.y,w.y
-    mResult.r[1] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(3, 1, 3, 1));
-    // x.z,y.z,z.z,w.z
-    mResult.r[2] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.w,y.w,z.w,w.w
-    mResult.r[3] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(3, 1, 3, 1));
-    return mResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixTranspose(FXMMATRIX M) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    // Original matrix:
-    //
-    //     m00m01m02m03
-    //     m10m11m12m13
-    //     m20m21m22m23
-    //     m30m31m32m33
-
-    XMMATRIX P;
-    P.r[0] = XMVectorMergeXY(M.r[0], M.r[2]); // m00m20m01m21
-    P.r[1] = XMVectorMergeXY(M.r[1], M.r[3]); // m10m30m11m31
-    P.r[2] = XMVectorMergeZW(M.r[0], M.r[2]); // m02m22m03m23
-    P.r[3] = XMVectorMergeZW(M.r[1], M.r[3]); // m12m32m13m33
-
-    XMMATRIX MT;
-    MT.r[0] = XMVectorMergeXY(P.r[0], P.r[1]); // m00m10m20m30
-    MT.r[1] = XMVectorMergeZW(P.r[0], P.r[1]); // m01m11m21m31
-    MT.r[2] = XMVectorMergeXY(P.r[2], P.r[3]); // m02m12m22m32
-    MT.r[3] = XMVectorMergeZW(P.r[2], P.r[3]); // m03m13m23m33
-    return MT;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4x2_t P0 = vzipq_f32(M.r[0], M.r[2]);
-    float32x4x2_t P1 = vzipq_f32(M.r[1], M.r[3]);
-
-    float32x4x2_t T0 = vzipq_f32(P0.val[0], P1.val[0]);
-    float32x4x2_t T1 = vzipq_f32(P0.val[1], P1.val[1]);
-
-    XMMATRIX mResult;
-    mResult.r[0] = T0.val[0];
-    mResult.r[1] = T0.val[1];
-    mResult.r[2] = T1.val[0];
-    mResult.r[3] = T1.val[1];
-    return mResult;
-#elif defined(_XM_AVX2_INTRINSICS_)
-    __m256 t0 = _mm256_castps128_ps256(M.r[0]);
-    t0 = _mm256_insertf128_ps(t0, M.r[1], 1);
-    __m256 t1 = _mm256_castps128_ps256(M.r[2]);
-    t1 = _mm256_insertf128_ps(t1, M.r[3], 1);
-
-    __m256 vTemp = _mm256_unpacklo_ps(t0, t1);
-    __m256 vTemp2 = _mm256_unpackhi_ps(t0, t1);
-    __m256 vTemp3 = _mm256_permute2f128_ps(vTemp, vTemp2, 0x20);
-    __m256 vTemp4 = _mm256_permute2f128_ps(vTemp, vTemp2, 0x31);
-    vTemp = _mm256_unpacklo_ps(vTemp3, vTemp4);
-    vTemp2 = _mm256_unpackhi_ps(vTemp3, vTemp4);
-    t0 = _mm256_permute2f128_ps(vTemp, vTemp2, 0x20);
-    t1 = _mm256_permute2f128_ps(vTemp, vTemp2, 0x31);
-
-    XMMATRIX mResult;
-    mResult.r[0] = _mm256_castps256_ps128(t0);
-    mResult.r[1] = _mm256_extractf128_ps(t0, 1);
-    mResult.r[2] = _mm256_castps256_ps128(t1);
-    mResult.r[3] = _mm256_extractf128_ps(t1, 1);
-    return mResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // x.x,x.y,y.x,y.y
-    XMVECTOR vTemp1 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(1, 0, 1, 0));
-    // x.z,x.w,y.z,y.w
-    XMVECTOR vTemp3 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(3, 2, 3, 2));
-    // z.x,z.y,w.x,w.y
-    XMVECTOR vTemp2 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(1, 0, 1, 0));
-    // z.z,z.w,w.z,w.w
-    XMVECTOR vTemp4 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(3, 2, 3, 2));
-
-    XMMATRIX mResult;
-    // x.x,y.x,z.x,w.x
-    mResult.r[0] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.y,y.y,z.y,w.y
-    mResult.r[1] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(3, 1, 3, 1));
-    // x.z,y.z,z.z,w.z
-    mResult.r[2] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(2, 0, 2, 0));
-    // x.w,y.w,z.w,w.w
-    mResult.r[3] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(3, 1, 3, 1));
-    return mResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Return the inverse and the determinant of a 4x4 matrix
-    _Use_decl_annotations_
-inline XMMATRIX XM_CALLCONV XMMatrixInverse
-        (
-                XMVECTOR* pDeterminant,
-                FXMMATRIX  M
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-
-    XMMATRIX MT = XMMatrixTranspose(M);
-
-    XMVECTOR V0[4], V1[4];
-    V0[0] = XMVectorSwizzle<XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(MT.r[2]);
-    V1[0] = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_W>(MT.r[3]);
-    V0[1] = XMVectorSwizzle<XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(MT.r[0]);
-    V1[1] = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_W>(MT.r[1]);
-    V0[2] = XMVectorPermute<XM_PERMUTE_0X, XM_PERMUTE_0Z, XM_PERMUTE_1X, XM_PERMUTE_1Z>(MT.r[2], MT.r[0]);
-    V1[2] = XMVectorPermute<XM_PERMUTE_0Y, XM_PERMUTE_0W, XM_PERMUTE_1Y, XM_PERMUTE_1W>(MT.r[3], MT.r[1]);
-
-    XMVECTOR D0 = XMVectorMultiply(V0[0], V1[0]);
-    XMVECTOR D1 = XMVectorMultiply(V0[1], V1[1]);
-    XMVECTOR D2 = XMVectorMultiply(V0[2], V1[2]);
-
-    V0[0] = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_W>(MT.r[2]);
-    V1[0] = XMVectorSwizzle<XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(MT.r[3]);
-    V0[1] = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_W>(MT.r[0]);
-    V1[1] = XMVectorSwizzle<XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(MT.r[1]);
-    V0[2] = XMVectorPermute<XM_PERMUTE_0Y, XM_PERMUTE_0W, XM_PERMUTE_1Y, XM_PERMUTE_1W>(MT.r[2], MT.r[0]);
-    V1[2] = XMVectorPermute<XM_PERMUTE_0X, XM_PERMUTE_0Z, XM_PERMUTE_1X, XM_PERMUTE_1Z>(MT.r[3], MT.r[1]);
-
-    D0 = XMVectorNegativeMultiplySubtract(V0[0], V1[0], D0);
-    D1 = XMVectorNegativeMultiplySubtract(V0[1], V1[1], D1);
-    D2 = XMVectorNegativeMultiplySubtract(V0[2], V1[2], D2);
-
-    V0[0] = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_X, XM_SWIZZLE_Y>(MT.r[1]);
-    V1[0] = XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0Y, XM_PERMUTE_0W, XM_PERMUTE_0X>(D0, D2);
-    V0[1] = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_X>(MT.r[0]);
-    V1[1] = XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Y, XM_PERMUTE_0Y, XM_PERMUTE_0Z>(D0, D2);
-    V0[2] = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_X, XM_SWIZZLE_Y>(MT.r[3]);
-    V1[2] = XMVectorPermute<XM_PERMUTE_1W, XM_PERMUTE_0Y, XM_PERMUTE_0W, XM_PERMUTE_0X>(D1, D2);
-    V0[3] = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_X>(MT.r[2]);
-    V1[3] = XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1W, XM_PERMUTE_0Y, XM_PERMUTE_0Z>(D1, D2);
-
-    XMVECTOR C0 = XMVectorMultiply(V0[0], V1[0]);
-    XMVECTOR C2 = XMVectorMultiply(V0[1], V1[1]);
-    XMVECTOR C4 = XMVectorMultiply(V0[2], V1[2]);
-    XMVECTOR C6 = XMVectorMultiply(V0[3], V1[3]);
-
-    V0[0] = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_Y, XM_SWIZZLE_Z>(MT.r[1]);
-    V1[0] = XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_1X>(D0, D2);
-    V0[1] = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_Y>(MT.r[0]);
-    V1[1] = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0Y, XM_PERMUTE_1X, XM_PERMUTE_0X>(D0, D2);
-    V0[2] = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_Y, XM_SWIZZLE_Z>(MT.r[3]);
-    V1[2] = XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_1Z>(D1, D2);
-    V0[3] = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_Y>(MT.r[2]);
-    V1[3] = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0Y, XM_PERMUTE_1Z, XM_PERMUTE_0X>(D1, D2);
-
-    C0 = XMVectorNegativeMultiplySubtract(V0[0], V1[0], C0);
-    C2 = XMVectorNegativeMultiplySubtract(V0[1], V1[1], C2);
-    C4 = XMVectorNegativeMultiplySubtract(V0[2], V1[2], C4);
-    C6 = XMVectorNegativeMultiplySubtract(V0[3], V1[3], C6);
-
-    V0[0] = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_X>(MT.r[1]);
-    V1[0] = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_1Y, XM_PERMUTE_1X, XM_PERMUTE_0Z>(D0, D2);
-    V0[1] = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Z>(MT.r[0]);
-    V1[1] = XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_1X>(D0, D2);
-    V0[2] = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_X>(MT.r[3]);
-    V1[2] = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_1W, XM_PERMUTE_1Z, XM_PERMUTE_0Z>(D1, D2);
-    V0[3] = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Z>(MT.r[2]);
-    V1[3] = XMVectorPermute<XM_PERMUTE_1W, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_1Z>(D1, D2);
-
-    XMVECTOR C1 = XMVectorNegativeMultiplySubtract(V0[0], V1[0], C0);
-    C0 = XMVectorMultiplyAdd(V0[0], V1[0], C0);
-    XMVECTOR C3 = XMVectorMultiplyAdd(V0[1], V1[1], C2);
-    C2 = XMVectorNegativeMultiplySubtract(V0[1], V1[1], C2);
-    XMVECTOR C5 = XMVectorNegativeMultiplySubtract(V0[2], V1[2], C4);
-    C4 = XMVectorMultiplyAdd(V0[2], V1[2], C4);
-    XMVECTOR C7 = XMVectorMultiplyAdd(V0[3], V1[3], C6);
-    C6 = XMVectorNegativeMultiplySubtract(V0[3], V1[3], C6);
-
-    XMMATRIX R;
-    R.r[0] = XMVectorSelect(C0, C1, g_XMSelect0101.v);
-    R.r[1] = XMVectorSelect(C2, C3, g_XMSelect0101.v);
-    R.r[2] = XMVectorSelect(C4, C5, g_XMSelect0101.v);
-    R.r[3] = XMVectorSelect(C6, C7, g_XMSelect0101.v);
-
-    XMVECTOR Determinant = XMVector4Dot(R.r[0], MT.r[0]);
-
-    if (pDeterminant != nullptr)
-        *pDeterminant = Determinant;
-
-    XMVECTOR Reciprocal = XMVectorReciprocal(Determinant);
-
-    XMMATRIX Result;
-    Result.r[0] = XMVectorMultiply(R.r[0], Reciprocal);
-    Result.r[1] = XMVectorMultiply(R.r[1], Reciprocal);
-    Result.r[2] = XMVectorMultiply(R.r[2], Reciprocal);
-    Result.r[3] = XMVectorMultiply(R.r[3], Reciprocal);
-    return Result;
-
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Transpose matrix
-    XMVECTOR vTemp1 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(1, 0, 1, 0));
-    XMVECTOR vTemp3 = _mm_shuffle_ps(M.r[0], M.r[1], _MM_SHUFFLE(3, 2, 3, 2));
-    XMVECTOR vTemp2 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(1, 0, 1, 0));
-    XMVECTOR vTemp4 = _mm_shuffle_ps(M.r[2], M.r[3], _MM_SHUFFLE(3, 2, 3, 2));
-
-    XMMATRIX MT;
-    MT.r[0] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(2, 0, 2, 0));
-    MT.r[1] = _mm_shuffle_ps(vTemp1, vTemp2, _MM_SHUFFLE(3, 1, 3, 1));
-    MT.r[2] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(2, 0, 2, 0));
-    MT.r[3] = _mm_shuffle_ps(vTemp3, vTemp4, _MM_SHUFFLE(3, 1, 3, 1));
-
-    XMVECTOR V00 = XM_PERMUTE_PS(MT.r[2], _MM_SHUFFLE(1, 1, 0, 0));
-    XMVECTOR V10 = XM_PERMUTE_PS(MT.r[3], _MM_SHUFFLE(3, 2, 3, 2));
-    XMVECTOR V01 = XM_PERMUTE_PS(MT.r[0], _MM_SHUFFLE(1, 1, 0, 0));
-    XMVECTOR V11 = XM_PERMUTE_PS(MT.r[1], _MM_SHUFFLE(3, 2, 3, 2));
-    XMVECTOR V02 = _mm_shuffle_ps(MT.r[2], MT.r[0], _MM_SHUFFLE(2, 0, 2, 0));
-    XMVECTOR V12 = _mm_shuffle_ps(MT.r[3], MT.r[1], _MM_SHUFFLE(3, 1, 3, 1));
-
-    XMVECTOR D0 = _mm_mul_ps(V00, V10);
-    XMVECTOR D1 = _mm_mul_ps(V01, V11);
-    XMVECTOR D2 = _mm_mul_ps(V02, V12);
-
-    V00 = XM_PERMUTE_PS(MT.r[2], _MM_SHUFFLE(3, 2, 3, 2));
-    V10 = XM_PERMUTE_PS(MT.r[3], _MM_SHUFFLE(1, 1, 0, 0));
-    V01 = XM_PERMUTE_PS(MT.r[0], _MM_SHUFFLE(3, 2, 3, 2));
-    V11 = XM_PERMUTE_PS(MT.r[1], _MM_SHUFFLE(1, 1, 0, 0));
-    V02 = _mm_shuffle_ps(MT.r[2], MT.r[0], _MM_SHUFFLE(3, 1, 3, 1));
-    V12 = _mm_shuffle_ps(MT.r[3], MT.r[1], _MM_SHUFFLE(2, 0, 2, 0));
-
-    D0 = XM_FNMADD_PS(V00, V10, D0);
-    D1 = XM_FNMADD_PS(V01, V11, D1);
-    D2 = XM_FNMADD_PS(V02, V12, D2);
-    // V11 = D0Y,D0W,D2Y,D2Y
-    V11 = _mm_shuffle_ps(D0, D2, _MM_SHUFFLE(1, 1, 3, 1));
-    V00 = XM_PERMUTE_PS(MT.r[1], _MM_SHUFFLE(1, 0, 2, 1));
-    V10 = _mm_shuffle_ps(V11, D0, _MM_SHUFFLE(0, 3, 0, 2));
-    V01 = XM_PERMUTE_PS(MT.r[0], _MM_SHUFFLE(0, 1, 0, 2));
-    V11 = _mm_shuffle_ps(V11, D0, _MM_SHUFFLE(2, 1, 2, 1));
-    // V13 = D1Y,D1W,D2W,D2W
-    XMVECTOR V13 = _mm_shuffle_ps(D1, D2, _MM_SHUFFLE(3, 3, 3, 1));
-    V02 = XM_PERMUTE_PS(MT.r[3], _MM_SHUFFLE(1, 0, 2, 1));
-    V12 = _mm_shuffle_ps(V13, D1, _MM_SHUFFLE(0, 3, 0, 2));
-    XMVECTOR V03 = XM_PERMUTE_PS(MT.r[2], _MM_SHUFFLE(0, 1, 0, 2));
-    V13 = _mm_shuffle_ps(V13, D1, _MM_SHUFFLE(2, 1, 2, 1));
-
-    XMVECTOR C0 = _mm_mul_ps(V00, V10);
-    XMVECTOR C2 = _mm_mul_ps(V01, V11);
-    XMVECTOR C4 = _mm_mul_ps(V02, V12);
-    XMVECTOR C6 = _mm_mul_ps(V03, V13);
-
-    // V11 = D0X,D0Y,D2X,D2X
-    V11 = _mm_shuffle_ps(D0, D2, _MM_SHUFFLE(0, 0, 1, 0));
-    V00 = XM_PERMUTE_PS(MT.r[1], _MM_SHUFFLE(2, 1, 3, 2));
-    V10 = _mm_shuffle_ps(D0, V11, _MM_SHUFFLE(2, 1, 0, 3));
-    V01 = XM_PERMUTE_PS(MT.r[0], _MM_SHUFFLE(1, 3, 2, 3));
-    V11 = _mm_shuffle_ps(D0, V11, _MM_SHUFFLE(0, 2, 1, 2));
-    // V13 = D1X,D1Y,D2Z,D2Z
-    V13 = _mm_shuffle_ps(D1, D2, _MM_SHUFFLE(2, 2, 1, 0));
-    V02 = XM_PERMUTE_PS(MT.r[3], _MM_SHUFFLE(2, 1, 3, 2));
-    V12 = _mm_shuffle_ps(D1, V13, _MM_SHUFFLE(2, 1, 0, 3));
-    V03 = XM_PERMUTE_PS(MT.r[2], _MM_SHUFFLE(1, 3, 2, 3));
-    V13 = _mm_shuffle_ps(D1, V13, _MM_SHUFFLE(0, 2, 1, 2));
-
-    C0 = XM_FNMADD_PS(V00, V10, C0);
-    C2 = XM_FNMADD_PS(V01, V11, C2);
-    C4 = XM_FNMADD_PS(V02, V12, C4);
-    C6 = XM_FNMADD_PS(V03, V13, C6);
-
-    V00 = XM_PERMUTE_PS(MT.r[1], _MM_SHUFFLE(0, 3, 0, 3));
-    // V10 = D0Z,D0Z,D2X,D2Y
-    V10 = _mm_shuffle_ps(D0, D2, _MM_SHUFFLE(1, 0, 2, 2));
-    V10 = XM_PERMUTE_PS(V10, _MM_SHUFFLE(0, 2, 3, 0));
-    V01 = XM_PERMUTE_PS(MT.r[0], _MM_SHUFFLE(2, 0, 3, 1));
-    // V11 = D0X,D0W,D2X,D2Y
-    V11 = _mm_shuffle_ps(D0, D2, _MM_SHUFFLE(1, 0, 3, 0));
-    V11 = XM_PERMUTE_PS(V11, _MM_SHUFFLE(2, 1, 0, 3));
-    V02 = XM_PERMUTE_PS(MT.r[3], _MM_SHUFFLE(0, 3, 0, 3));
-    // V12 = D1Z,D1Z,D2Z,D2W
-    V12 = _mm_shuffle_ps(D1, D2, _MM_SHUFFLE(3, 2, 2, 2));
-    V12 = XM_PERMUTE_PS(V12, _MM_SHUFFLE(0, 2, 3, 0));
-    V03 = XM_PERMUTE_PS(MT.r[2], _MM_SHUFFLE(2, 0, 3, 1));
-    // V13 = D1X,D1W,D2Z,D2W
-    V13 = _mm_shuffle_ps(D1, D2, _MM_SHUFFLE(3, 2, 3, 0));
-    V13 = XM_PERMUTE_PS(V13, _MM_SHUFFLE(2, 1, 0, 3));
-
-    V00 = _mm_mul_ps(V00, V10);
-    V01 = _mm_mul_ps(V01, V11);
-    V02 = _mm_mul_ps(V02, V12);
-    V03 = _mm_mul_ps(V03, V13);
-    XMVECTOR C1 = _mm_sub_ps(C0, V00);
-    C0 = _mm_add_ps(C0, V00);
-    XMVECTOR C3 = _mm_add_ps(C2, V01);
-    C2 = _mm_sub_ps(C2, V01);
-    XMVECTOR C5 = _mm_sub_ps(C4, V02);
-    C4 = _mm_add_ps(C4, V02);
-    XMVECTOR C7 = _mm_add_ps(C6, V03);
-    C6 = _mm_sub_ps(C6, V03);
-
-    C0 = _mm_shuffle_ps(C0, C1, _MM_SHUFFLE(3, 1, 2, 0));
-    C2 = _mm_shuffle_ps(C2, C3, _MM_SHUFFLE(3, 1, 2, 0));
-    C4 = _mm_shuffle_ps(C4, C5, _MM_SHUFFLE(3, 1, 2, 0));
-    C6 = _mm_shuffle_ps(C6, C7, _MM_SHUFFLE(3, 1, 2, 0));
-    C0 = XM_PERMUTE_PS(C0, _MM_SHUFFLE(3, 1, 2, 0));
-    C2 = XM_PERMUTE_PS(C2, _MM_SHUFFLE(3, 1, 2, 0));
-    C4 = XM_PERMUTE_PS(C4, _MM_SHUFFLE(3, 1, 2, 0));
-    C6 = XM_PERMUTE_PS(C6, _MM_SHUFFLE(3, 1, 2, 0));
-    // Get the determinant
-    XMVECTOR vTemp = XMVector4Dot(C0, MT.r[0]);
-    if (pDeterminant != nullptr)
-        *pDeterminant = vTemp;
-    vTemp = _mm_div_ps(g_XMOne, vTemp);
-    XMMATRIX mResult;
-    mResult.r[0] = _mm_mul_ps(C0, vTemp);
-    mResult.r[1] = _mm_mul_ps(C2, vTemp);
-    mResult.r[2] = _mm_mul_ps(C4, vTemp);
-    mResult.r[3] = _mm_mul_ps(C6, vTemp);
-    return mResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixVectorTensorProduct
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    XMMATRIX mResult;
-    mResult.r[0] = XMVectorMultiply(XMVectorSwizzle<0, 0, 0, 0>(V1), V2);
-    mResult.r[1] = XMVectorMultiply(XMVectorSwizzle<1, 1, 1, 1>(V1), V2);
-    mResult.r[2] = XMVectorMultiply(XMVectorSwizzle<2, 2, 2, 2>(V1), V2);
-    mResult.r[3] = XMVectorMultiply(XMVectorSwizzle<3, 3, 3, 3>(V1), V2);
-    return mResult;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMMatrixDeterminant(FXMMATRIX M) noexcept
-{
-    static const XMVECTORF32 Sign = { { { 1.0f, -1.0f, 1.0f, -1.0f } } };
-
-    XMVECTOR V0 = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_X>(M.r[2]);
-    XMVECTOR V1 = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(M.r[3]);
-    XMVECTOR V2 = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_X>(M.r[2]);
-    XMVECTOR V3 = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_Z>(M.r[3]);
-    XMVECTOR V4 = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(M.r[2]);
-    XMVECTOR V5 = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_Z>(M.r[3]);
-
-    XMVECTOR P0 = XMVectorMultiply(V0, V1);
-    XMVECTOR P1 = XMVectorMultiply(V2, V3);
-    XMVECTOR P2 = XMVectorMultiply(V4, V5);
-
-    V0 = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(M.r[2]);
-    V1 = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_X>(M.r[3]);
-    V2 = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_Z>(M.r[2]);
-    V3 = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_X>(M.r[3]);
-    V4 = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_Z>(M.r[2]);
-    V5 = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(M.r[3]);
-
-    P0 = XMVectorNegativeMultiplySubtract(V0, V1, P0);
-    P1 = XMVectorNegativeMultiplySubtract(V2, V3, P1);
-    P2 = XMVectorNegativeMultiplySubtract(V4, V5, P2);
-
-    V0 = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_W, XM_SWIZZLE_Z>(M.r[1]);
-    V1 = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(M.r[1]);
-    V2 = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_X>(M.r[1]);
-
-    XMVECTOR S = XMVectorMultiply(M.r[0], Sign.v);
-    XMVECTOR R = XMVectorMultiply(V0, P0);
-    R = XMVectorNegativeMultiplySubtract(V1, P1, R);
-    R = XMVectorMultiplyAdd(V2, P2, R);
-
-    return XMVector4Dot(S, R);
-}
-
-#define XM3RANKDECOMPOSE(a, b, c, x, y, z)      \
-    if((x) < (y))                   \
-    {                               \
-        if((y) < (z))               \
-        {                           \
-            (a) = 2;                \
-            (b) = 1;                \
-            (c) = 0;                \
-        }                           \
-        else                        \
-        {                           \
-            (a) = 1;                \
-                                    \
-            if((x) < (z))           \
-            {                       \
-                (b) = 2;            \
-                (c) = 0;            \
-            }                       \
-            else                    \
-            {                       \
-                (b) = 0;            \
-                (c) = 2;            \
-            }                       \
-        }                           \
-    }                               \
-    else                            \
-    {                               \
-        if((x) < (z))               \
-        {                           \
-            (a) = 2;                \
-            (b) = 0;                \
-            (c) = 1;                \
-        }                           \
-        else                        \
-        {                           \
-            (a) = 0;                \
-                                    \
-            if((y) < (z))           \
-            {                       \
-                (b) = 2;            \
-                (c) = 1;            \
-            }                       \
-            else                    \
-            {                       \
-                (b) = 1;            \
-                (c) = 2;            \
-            }                       \
-        }                           \
-    }
-
-#define XM3_DECOMP_EPSILON 0.0001f
-
-    _Use_decl_annotations_
-inline bool XM_CALLCONV XMMatrixDecompose
-        (
-                XMVECTOR* outScale,
-                XMVECTOR* outRotQuat,
-                XMVECTOR* outTrans,
-                FXMMATRIX M
-        ) noexcept
-{
-    static const XMVECTOR* pvCanonicalBasis[3] = {
-            &g_XMIdentityR0.v,
-            &g_XMIdentityR1.v,
-            &g_XMIdentityR2.v
-    };
-
-    assert(outScale != nullptr);
-    assert(outRotQuat != nullptr);
-    assert(outTrans != nullptr);
-
-    // Get the translation
-    outTrans[0] = M.r[3];
-
-    XMVECTOR* ppvBasis[3];
-    XMMATRIX matTemp;
-    ppvBasis[0] = &matTemp.r[0];
-    ppvBasis[1] = &matTemp.r[1];
-    ppvBasis[2] = &matTemp.r[2];
-
-    matTemp.r[0] = M.r[0];
-    matTemp.r[1] = M.r[1];
-    matTemp.r[2] = M.r[2];
-    matTemp.r[3] = g_XMIdentityR3.v;
-
-    auto pfScales = reinterpret_cast<float*>(outScale);
-
-    size_t a, b, c;
-    XMVectorGetXPtr(&pfScales[0], XMVector3Length(ppvBasis[0][0]));
-    XMVectorGetXPtr(&pfScales[1], XMVector3Length(ppvBasis[1][0]));
-    XMVectorGetXPtr(&pfScales[2], XMVector3Length(ppvBasis[2][0]));
-    pfScales[3] = 0.f;
-
-    XM3RANKDECOMPOSE(a, b, c, pfScales[0], pfScales[1], pfScales[2])
-
-    if (pfScales[a] < XM3_DECOMP_EPSILON)
-    {
-        ppvBasis[a][0] = pvCanonicalBasis[a][0];
-    }
-    ppvBasis[a][0] = XMVector3Normalize(ppvBasis[a][0]);
-
-    if (pfScales[b] < XM3_DECOMP_EPSILON)
-    {
-        size_t aa, bb, cc;
-        float fAbsX, fAbsY, fAbsZ;
-
-        fAbsX = fabsf(XMVectorGetX(ppvBasis[a][0]));
-        fAbsY = fabsf(XMVectorGetY(ppvBasis[a][0]));
-        fAbsZ = fabsf(XMVectorGetZ(ppvBasis[a][0]));
-
-        XM3RANKDECOMPOSE(aa, bb, cc, fAbsX, fAbsY, fAbsZ)
-
-        ppvBasis[b][0] = XMVector3Cross(ppvBasis[a][0], pvCanonicalBasis[cc][0]);
-    }
-
-    ppvBasis[b][0] = XMVector3Normalize(ppvBasis[b][0]);
-
-    if (pfScales[c] < XM3_DECOMP_EPSILON)
-    {
-        ppvBasis[c][0] = XMVector3Cross(ppvBasis[a][0], ppvBasis[b][0]);
-    }
-
-    ppvBasis[c][0] = XMVector3Normalize(ppvBasis[c][0]);
-
-    float fDet = XMVectorGetX(XMMatrixDeterminant(matTemp));
-
-    // use Kramer's rule to check for handedness of coordinate system
-    if (fDet < 0.0f)
-    {
-        // switch coordinate system by negating the scale and inverting the basis vector on the x-axis
-        pfScales[a] = -pfScales[a];
-        ppvBasis[a][0] = XMVectorNegate(ppvBasis[a][0]);
-
-        fDet = -fDet;
-    }
-
-    fDet -= 1.0f;
-    fDet *= fDet;
-
-    if (XM3_DECOMP_EPSILON < fDet)
-    {
-        // Non-SRT matrix encountered
-        return false;
-    }
-
-    // generate the quaternion from the matrix
-    outRotQuat[0] = XMQuaternionRotationMatrix(matTemp);
-    return true;
-}
-
-#undef XM3_DECOMP_EPSILON
-#undef XM3RANKDECOMPOSE
-
-//------------------------------------------------------------------------------
-// Transformation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixIdentity() noexcept
-{
-    XMMATRIX M;
-    M.r[0] = g_XMIdentityR0.v;
-    M.r[1] = g_XMIdentityR1.v;
-    M.r[2] = g_XMIdentityR2.v;
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixSet
-        (
-                float m00, float m01, float m02, float m03,
-                float m10, float m11, float m12, float m13,
-                float m20, float m21, float m22, float m23,
-                float m30, float m31, float m32, float m33
-        ) noexcept
-{
-    XMMATRIX M;
-#if defined(_XM_NO_INTRINSICS_)
-    M.m[0][0] = m00; M.m[0][1] = m01; M.m[0][2] = m02; M.m[0][3] = m03;
-    M.m[1][0] = m10; M.m[1][1] = m11; M.m[1][2] = m12; M.m[1][3] = m13;
-    M.m[2][0] = m20; M.m[2][1] = m21; M.m[2][2] = m22; M.m[2][3] = m23;
-    M.m[3][0] = m30; M.m[3][1] = m31; M.m[3][2] = m32; M.m[3][3] = m33;
-#else
-    M.r[0] = XMVectorSet(m00, m01, m02, m03);
-    M.r[1] = XMVectorSet(m10, m11, m12, m13);
-    M.r[2] = XMVectorSet(m20, m21, m22, m23);
-    M.r[3] = XMVectorSet(m30, m31, m32, m33);
-#endif
-    return M;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixTranslation
-        (
-                float OffsetX,
-                float OffsetY,
-                float OffsetZ
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.m[0][0] = 1.0f;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = 1.0f;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = 1.0f;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = OffsetX;
-    M.m[3][1] = OffsetY;
-    M.m[3][2] = OffsetZ;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = g_XMIdentityR0.v;
-    M.r[1] = g_XMIdentityR1.v;
-    M.r[2] = g_XMIdentityR2.v;
-    M.r[3] = XMVectorSet(OffsetX, OffsetY, OffsetZ, 1.f);
-    return M;
-#endif
-}
-
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixTranslationFromVector(FXMVECTOR Offset) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.m[0][0] = 1.0f;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = 1.0f;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = 1.0f;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = Offset.vector4_f32[0];
-    M.m[3][1] = Offset.vector4_f32[1];
-    M.m[3][2] = Offset.vector4_f32[2];
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = g_XMIdentityR0.v;
-    M.r[1] = g_XMIdentityR1.v;
-    M.r[2] = g_XMIdentityR2.v;
-    M.r[3] = XMVectorSelect(g_XMIdentityR3.v, Offset, g_XMSelect1110.v);
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixScaling
-        (
-                float ScaleX,
-                float ScaleY,
-                float ScaleZ
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.m[0][0] = ScaleX;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = ScaleY;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = ScaleZ;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = 0.0f;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    const XMVECTOR Zero = vdupq_n_f32(0);
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(ScaleX, Zero, 0);
-    M.r[1] = vsetq_lane_f32(ScaleY, Zero, 1);
-    M.r[2] = vsetq_lane_f32(ScaleZ, Zero, 2);
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = _mm_set_ps(0, 0, 0, ScaleX);
-    M.r[1] = _mm_set_ps(0, 0, ScaleY, 0);
-    M.r[2] = _mm_set_ps(0, ScaleZ, 0, 0);
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixScalingFromVector(FXMVECTOR Scale) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMMATRIX M;
-    M.m[0][0] = Scale.vector4_f32[0];
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = Scale.vector4_f32[1];
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = Scale.vector4_f32[2];
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = 0.0f;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(Scale), g_XMMaskX));
-    M.r[1] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(Scale), g_XMMaskY));
-    M.r[2] = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(Scale), g_XMMaskZ));
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    M.r[0] = _mm_and_ps(Scale, g_XMMaskX);
-    M.r[1] = _mm_and_ps(Scale, g_XMMaskY);
-    M.r[2] = _mm_and_ps(Scale, g_XMMaskZ);
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixRotationX(float Angle) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    float    fSinAngle;
-    float    fCosAngle;
-    XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
-
-    XMMATRIX M;
-    M.m[0][0] = 1.0f;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = fCosAngle;
-    M.m[1][2] = fSinAngle;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = -fSinAngle;
-    M.m[2][2] = fCosAngle;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = 0.0f;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float    fSinAngle;
-    float    fCosAngle;
-    XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
-
-    const float32x4_t Zero = vdupq_n_f32(0);
-
-    float32x4_t T1 = vsetq_lane_f32(fCosAngle, Zero, 1);
-    T1 = vsetq_lane_f32(fSinAngle, T1, 2);
-
-    float32x4_t T2 = vsetq_lane_f32(-fSinAngle, Zero, 1);
-    T2 = vsetq_lane_f32(fCosAngle, T2, 2);
-
-    XMMATRIX M;
-    M.r[0] = g_XMIdentityR0.v;
-    M.r[1] = T1;
-    M.r[2] = T2;
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    float    SinAngle;
-    float    CosAngle;
-    XMScalarSinCos(&SinAngle, &CosAngle, Angle);
-
-    XMVECTOR vSin = _mm_set_ss(SinAngle);
-    XMVECTOR vCos = _mm_set_ss(CosAngle);
-    // x = 0,y = cos,z = sin, w = 0
-    vCos = _mm_shuffle_ps(vCos, vSin, _MM_SHUFFLE(3, 0, 0, 3));
-    XMMATRIX M;
-    M.r[0] = g_XMIdentityR0;
-    M.r[1] = vCos;
-    // x = 0,y = sin,z = cos, w = 0
-    vCos = XM_PERMUTE_PS(vCos, _MM_SHUFFLE(3, 1, 2, 0));
-    // x = 0,y = -sin,z = cos, w = 0
-    vCos = _mm_mul_ps(vCos, g_XMNegateY);
-    M.r[2] = vCos;
-    M.r[3] = g_XMIdentityR3;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixRotationY(float Angle) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    float    fSinAngle;
-    float    fCosAngle;
-    XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
-
-    XMMATRIX M;
-    M.m[0][0] = fCosAngle;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = -fSinAngle;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = 1.0f;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = fSinAngle;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = fCosAngle;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = 0.0f;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float    fSinAngle;
-    float    fCosAngle;
-    XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
-
-    const float32x4_t Zero = vdupq_n_f32(0);
-
-    float32x4_t T0 = vsetq_lane_f32(fCosAngle, Zero, 0);
-    T0 = vsetq_lane_f32(-fSinAngle, T0, 2);
-
-    float32x4_t T2 = vsetq_lane_f32(fSinAngle, Zero, 0);
-    T2 = vsetq_lane_f32(fCosAngle, T2, 2);
-
-    XMMATRIX M;
-    M.r[0] = T0;
-    M.r[1] = g_XMIdentityR1.v;
-    M.r[2] = T2;
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    float    SinAngle;
-    float    CosAngle;
-    XMScalarSinCos(&SinAngle, &CosAngle, Angle);
-
-    XMVECTOR vSin = _mm_set_ss(SinAngle);
-    XMVECTOR vCos = _mm_set_ss(CosAngle);
-    // x = sin,y = 0,z = cos, w = 0
-    vSin = _mm_shuffle_ps(vSin, vCos, _MM_SHUFFLE(3, 0, 3, 0));
-    XMMATRIX M;
-    M.r[2] = vSin;
-    M.r[1] = g_XMIdentityR1;
-    // x = cos,y = 0,z = sin, w = 0
-    vSin = XM_PERMUTE_PS(vSin, _MM_SHUFFLE(3, 0, 1, 2));
-    // x = cos,y = 0,z = -sin, w = 0
-    vSin = _mm_mul_ps(vSin, g_XMNegateZ);
-    M.r[0] = vSin;
-    M.r[3] = g_XMIdentityR3;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixRotationZ(float Angle) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    float    fSinAngle;
-    float    fCosAngle;
-    XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
-
-    XMMATRIX M;
-    M.m[0][0] = fCosAngle;
-    M.m[0][1] = fSinAngle;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = -fSinAngle;
-    M.m[1][1] = fCosAngle;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = 1.0f;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = 0.0f;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float    fSinAngle;
-    float    fCosAngle;
-    XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
-
-    const float32x4_t Zero = vdupq_n_f32(0);
-
-    float32x4_t T0 = vsetq_lane_f32(fCosAngle, Zero, 0);
-    T0 = vsetq_lane_f32(fSinAngle, T0, 1);
-
-    float32x4_t T1 = vsetq_lane_f32(-fSinAngle, Zero, 0);
-    T1 = vsetq_lane_f32(fCosAngle, T1, 1);
-
-    XMMATRIX M;
-    M.r[0] = T0;
-    M.r[1] = T1;
-    M.r[2] = g_XMIdentityR2.v;
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    float    SinAngle;
-    float    CosAngle;
-    XMScalarSinCos(&SinAngle, &CosAngle, Angle);
-
-    XMVECTOR vSin = _mm_set_ss(SinAngle);
-    XMVECTOR vCos = _mm_set_ss(CosAngle);
-    // x = cos,y = sin,z = 0, w = 0
-    vCos = _mm_unpacklo_ps(vCos, vSin);
-    XMMATRIX M;
-    M.r[0] = vCos;
-    // x = sin,y = cos,z = 0, w = 0
-    vCos = XM_PERMUTE_PS(vCos, _MM_SHUFFLE(3, 2, 0, 1));
-    // x = cos,y = -sin,z = 0, w = 0
-    vCos = _mm_mul_ps(vCos, g_XMNegateX);
-    M.r[1] = vCos;
-    M.r[2] = g_XMIdentityR2;
-    M.r[3] = g_XMIdentityR3;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixRotationRollPitchYaw
-        (
-                float Pitch,
-                float Yaw,
-                float Roll
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float cp = cosf(Pitch);
-    float sp = sinf(Pitch);
-
-    float cy = cosf(Yaw);
-    float sy = sinf(Yaw);
-
-    float cr = cosf(Roll);
-    float sr = sinf(Roll);
-
-    XMMATRIX M;
-    M.m[0][0] = cr * cy + sr * sp * sy;
-    M.m[0][1] = sr * cp;
-    M.m[0][2] = sr * sp * cy - cr * sy;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = cr * sp * sy - sr * cy;
-    M.m[1][1] = cr * cp;
-    M.m[1][2] = sr * sy + cr * sp * cy;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = cp * sy;
-    M.m[2][1] = -sp;
-    M.m[2][2] = cp * cy;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = 0.0f;
-    M.m[3][3] = 1.0f;
-    return M;
-#else
-    XMVECTOR Angles = XMVectorSet(Pitch, Yaw, Roll, 0.0f);
-    return XMMatrixRotationRollPitchYawFromVector(Angles);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixRotationRollPitchYawFromVector
-        (
-                FXMVECTOR Angles // <Pitch, Yaw, Roll, undefined>
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float cp = cosf(Angles.vector4_f32[0]);
-    float sp = sinf(Angles.vector4_f32[0]);
-
-    float cy = cosf(Angles.vector4_f32[1]);
-    float sy = sinf(Angles.vector4_f32[1]);
-
-    float cr = cosf(Angles.vector4_f32[2]);
-    float sr = sinf(Angles.vector4_f32[2]);
-
-    XMMATRIX M;
-    M.m[0][0] = cr * cy + sr * sp * sy;
-    M.m[0][1] = sr * cp;
-    M.m[0][2] = sr * sp * cy - cr * sy;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = cr * sp * sy - sr * cy;
-    M.m[1][1] = cr * cp;
-    M.m[1][2] = sr * sy + cr * sp * cy;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = cp * sy;
-    M.m[2][1] = -sp;
-    M.m[2][2] = cp * cy;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = 0.0f;
-    M.m[3][3] = 1.0f;
-    return M;
-#else
-    static const XMVECTORF32  Sign = { { { 1.0f, -1.0f, -1.0f, 1.0f } } };
-
-    XMVECTOR SinAngles, CosAngles;
-    XMVectorSinCos(&SinAngles, &CosAngles, Angles);
-
-    XMVECTOR P0 = XMVectorPermute<XM_PERMUTE_1X, XM_PERMUTE_0Z, XM_PERMUTE_1Z, XM_PERMUTE_1X>(SinAngles, CosAngles);
-    XMVECTOR Y0 = XMVectorPermute<XM_PERMUTE_0Y, XM_PERMUTE_1X, XM_PERMUTE_1X, XM_PERMUTE_1Y>(SinAngles, CosAngles);
-    XMVECTOR P1 = XMVectorPermute<XM_PERMUTE_1Z, XM_PERMUTE_0Z, XM_PERMUTE_1Z, XM_PERMUTE_0Z>(SinAngles, CosAngles);
-    XMVECTOR Y1 = XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_1Y, XM_PERMUTE_0Y, XM_PERMUTE_0Y>(SinAngles, CosAngles);
-    XMVECTOR P2 = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_1Z, XM_PERMUTE_0Z, XM_PERMUTE_1Z>(SinAngles, CosAngles);
-    XMVECTOR P3 = XMVectorPermute<XM_PERMUTE_0Y, XM_PERMUTE_0Y, XM_PERMUTE_1Y, XM_PERMUTE_1Y>(SinAngles, CosAngles);
-    XMVECTOR Y2 = XMVectorSplatX(SinAngles);
-    XMVECTOR NS = XMVectorNegate(SinAngles);
-
-    XMVECTOR Q0 = XMVectorMultiply(P0, Y0);
-    XMVECTOR Q1 = XMVectorMultiply(P1, Sign.v);
-    Q1 = XMVectorMultiply(Q1, Y1);
-    XMVECTOR Q2 = XMVectorMultiply(P2, Y2);
-    Q2 = XMVectorMultiplyAdd(Q2, P3, Q1);
-
-    XMVECTOR V0 = XMVectorPermute<XM_PERMUTE_1X, XM_PERMUTE_0Y, XM_PERMUTE_1Z, XM_PERMUTE_0W>(Q0, Q2);
-    XMVECTOR V1 = XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0Z, XM_PERMUTE_1W, XM_PERMUTE_0W>(Q0, Q2);
-    XMVECTOR V2 = XMVectorPermute<XM_PERMUTE_0X, XM_PERMUTE_1X, XM_PERMUTE_0W, XM_PERMUTE_0W>(Q0, NS);
-
-    XMMATRIX M;
-    M.r[0] = XMVectorSelect(g_XMZero, V0, g_XMSelect1110.v);
-    M.r[1] = XMVectorSelect(g_XMZero, V1, g_XMSelect1110.v);
-    M.r[2] = XMVectorSelect(g_XMZero, V2, g_XMSelect1110.v);
-    M.r[3] = g_XMIdentityR3;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixRotationNormal
-        (
-                FXMVECTOR NormalAxis,
-                float     Angle
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-
-    float    fSinAngle;
-    float    fCosAngle;
-    XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
-
-    XMVECTOR A = XMVectorSet(fSinAngle, fCosAngle, 1.0f - fCosAngle, 0.0f);
-
-    XMVECTOR C2 = XMVectorSplatZ(A);
-    XMVECTOR C1 = XMVectorSplatY(A);
-    XMVECTOR C0 = XMVectorSplatX(A);
-
-    XMVECTOR N0 = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_X, XM_SWIZZLE_W>(NormalAxis);
-    XMVECTOR N1 = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_W>(NormalAxis);
-
-    XMVECTOR V0 = XMVectorMultiply(C2, N0);
-    V0 = XMVectorMultiply(V0, N1);
-
-    XMVECTOR R0 = XMVectorMultiply(C2, NormalAxis);
-    R0 = XMVectorMultiplyAdd(R0, NormalAxis, C1);
-
-    XMVECTOR R1 = XMVectorMultiplyAdd(C0, NormalAxis, V0);
-    XMVECTOR R2 = XMVectorNegativeMultiplySubtract(C0, NormalAxis, V0);
-
-    V0 = XMVectorSelect(A, R0, g_XMSelect1110.v);
-    XMVECTOR V1 = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_1Y, XM_PERMUTE_1Z, XM_PERMUTE_0X>(R1, R2);
-    XMVECTOR V2 = XMVectorPermute<XM_PERMUTE_0Y, XM_PERMUTE_1X, XM_PERMUTE_0Y, XM_PERMUTE_1X>(R1, R2);
-
-    XMMATRIX M;
-    M.r[0] = XMVectorPermute<XM_PERMUTE_0X, XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0W>(V0, V1);
-    M.r[1] = XMVectorPermute<XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_1W, XM_PERMUTE_0W>(V0, V1);
-    M.r[2] = XMVectorPermute<XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0Z, XM_PERMUTE_0W>(V0, V2);
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-
-#elif defined(_XM_SSE_INTRINSICS_)
-    float    fSinAngle;
-    float    fCosAngle;
-    XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
-
-    XMVECTOR C2 = _mm_set_ps1(1.0f - fCosAngle);
-    XMVECTOR C1 = _mm_set_ps1(fCosAngle);
-    XMVECTOR C0 = _mm_set_ps1(fSinAngle);
-
-    XMVECTOR N0 = XM_PERMUTE_PS(NormalAxis, _MM_SHUFFLE(3, 0, 2, 1));
-    XMVECTOR N1 = XM_PERMUTE_PS(NormalAxis, _MM_SHUFFLE(3, 1, 0, 2));
-
-    XMVECTOR V0 = _mm_mul_ps(C2, N0);
-    V0 = _mm_mul_ps(V0, N1);
-
-    XMVECTOR R0 = _mm_mul_ps(C2, NormalAxis);
-    R0 = _mm_mul_ps(R0, NormalAxis);
-    R0 = _mm_add_ps(R0, C1);
-
-    XMVECTOR R1 = _mm_mul_ps(C0, NormalAxis);
-    R1 = _mm_add_ps(R1, V0);
-    XMVECTOR R2 = _mm_mul_ps(C0, NormalAxis);
-    R2 = _mm_sub_ps(V0, R2);
-
-    V0 = _mm_and_ps(R0, g_XMMask3);
-    XMVECTOR V1 = _mm_shuffle_ps(R1, R2, _MM_SHUFFLE(2, 1, 2, 0));
-    V1 = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 3, 2, 1));
-    XMVECTOR V2 = _mm_shuffle_ps(R1, R2, _MM_SHUFFLE(0, 0, 1, 1));
-    V2 = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 0, 2, 0));
-
-    R2 = _mm_shuffle_ps(V0, V1, _MM_SHUFFLE(1, 0, 3, 0));
-    R2 = XM_PERMUTE_PS(R2, _MM_SHUFFLE(1, 3, 2, 0));
-
-    XMMATRIX M;
-    M.r[0] = R2;
-
-    R2 = _mm_shuffle_ps(V0, V1, _MM_SHUFFLE(3, 2, 3, 1));
-    R2 = XM_PERMUTE_PS(R2, _MM_SHUFFLE(1, 3, 0, 2));
-    M.r[1] = R2;
-
-    V2 = _mm_shuffle_ps(V2, V0, _MM_SHUFFLE(3, 2, 1, 0));
-    M.r[2] = V2;
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixRotationAxis
-        (
-                FXMVECTOR Axis,
-                float     Angle
-        ) noexcept
-{
-    assert(!XMVector3Equal(Axis, XMVectorZero()));
-    assert(!XMVector3IsInfinite(Axis));
-
-    XMVECTOR Normal = XMVector3Normalize(Axis);
-    return XMMatrixRotationNormal(Normal, Angle);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixRotationQuaternion(FXMVECTOR Quaternion) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    float qx = Quaternion.vector4_f32[0];
-    float qxx = qx * qx;
-
-    float qy = Quaternion.vector4_f32[1];
-    float qyy = qy * qy;
-
-    float qz = Quaternion.vector4_f32[2];
-    float qzz = qz * qz;
-
-    float qw = Quaternion.vector4_f32[3];
-
-    XMMATRIX M;
-    M.m[0][0] = 1.f - 2.f * qyy - 2.f * qzz;
-    M.m[0][1] = 2.f * qx * qy + 2.f * qz * qw;
-    M.m[0][2] = 2.f * qx * qz - 2.f * qy * qw;
-    M.m[0][3] = 0.f;
-
-    M.m[1][0] = 2.f * qx * qy - 2.f * qz * qw;
-    M.m[1][1] = 1.f - 2.f * qxx - 2.f * qzz;
-    M.m[1][2] = 2.f * qy * qz + 2.f * qx * qw;
-    M.m[1][3] = 0.f;
-
-    M.m[2][0] = 2.f * qx * qz + 2.f * qy * qw;
-    M.m[2][1] = 2.f * qy * qz - 2.f * qx * qw;
-    M.m[2][2] = 1.f - 2.f * qxx - 2.f * qyy;
-    M.m[2][3] = 0.f;
-
-    M.m[3][0] = 0.f;
-    M.m[3][1] = 0.f;
-    M.m[3][2] = 0.f;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 Constant1110 = { { { 1.0f, 1.0f, 1.0f, 0.0f } } };
-
-    XMVECTOR Q0 = XMVectorAdd(Quaternion, Quaternion);
-    XMVECTOR Q1 = XMVectorMultiply(Quaternion, Q0);
-
-    XMVECTOR V0 = XMVectorPermute<XM_PERMUTE_0Y, XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_1W>(Q1, Constant1110.v);
-    XMVECTOR V1 = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0Z, XM_PERMUTE_0Y, XM_PERMUTE_1W>(Q1, Constant1110.v);
-    XMVECTOR R0 = XMVectorSubtract(Constant1110, V0);
-    R0 = XMVectorSubtract(R0, V1);
-
-    V0 = XMVectorSwizzle<XM_SWIZZLE_X, XM_SWIZZLE_X, XM_SWIZZLE_Y, XM_SWIZZLE_W>(Quaternion);
-    V1 = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_W>(Q0);
-    V0 = XMVectorMultiply(V0, V1);
-
-    V1 = XMVectorSplatW(Quaternion);
-    XMVECTOR V2 = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_X, XM_SWIZZLE_W>(Q0);
-    V1 = XMVectorMultiply(V1, V2);
-
-    XMVECTOR R1 = XMVectorAdd(V0, V1);
-    XMVECTOR R2 = XMVectorSubtract(V0, V1);
-
-    V0 = XMVectorPermute<XM_PERMUTE_0Y, XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0Z>(R1, R2);
-    V1 = XMVectorPermute<XM_PERMUTE_0X, XM_PERMUTE_1Z, XM_PERMUTE_0X, XM_PERMUTE_1Z>(R1, R2);
-
-    XMMATRIX M;
-    M.r[0] = XMVectorPermute<XM_PERMUTE_0X, XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0W>(R0, V0);
-    M.r[1] = XMVectorPermute<XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_1W, XM_PERMUTE_0W>(R0, V0);
-    M.r[2] = XMVectorPermute<XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0Z, XM_PERMUTE_0W>(R0, V1);
-    M.r[3] = g_XMIdentityR3.v;
-    return M;
-
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32  Constant1110 = { { { 1.0f, 1.0f, 1.0f, 0.0f } } };
-
-    XMVECTOR Q0 = _mm_add_ps(Quaternion, Quaternion);
-    XMVECTOR Q1 = _mm_mul_ps(Quaternion, Q0);
-
-    XMVECTOR V0 = XM_PERMUTE_PS(Q1, _MM_SHUFFLE(3, 0, 0, 1));
-    V0 = _mm_and_ps(V0, g_XMMask3);
-    XMVECTOR V1 = XM_PERMUTE_PS(Q1, _MM_SHUFFLE(3, 1, 2, 2));
-    V1 = _mm_and_ps(V1, g_XMMask3);
-    XMVECTOR R0 = _mm_sub_ps(Constant1110, V0);
-    R0 = _mm_sub_ps(R0, V1);
-
-    V0 = XM_PERMUTE_PS(Quaternion, _MM_SHUFFLE(3, 1, 0, 0));
-    V1 = XM_PERMUTE_PS(Q0, _MM_SHUFFLE(3, 2, 1, 2));
-    V0 = _mm_mul_ps(V0, V1);
-
-    V1 = XM_PERMUTE_PS(Quaternion, _MM_SHUFFLE(3, 3, 3, 3));
-    XMVECTOR V2 = XM_PERMUTE_PS(Q0, _MM_SHUFFLE(3, 0, 2, 1));
-    V1 = _mm_mul_ps(V1, V2);
-
-    XMVECTOR R1 = _mm_add_ps(V0, V1);
-    XMVECTOR R2 = _mm_sub_ps(V0, V1);
-
-    V0 = _mm_shuffle_ps(R1, R2, _MM_SHUFFLE(1, 0, 2, 1));
-    V0 = XM_PERMUTE_PS(V0, _MM_SHUFFLE(1, 3, 2, 0));
-    V1 = _mm_shuffle_ps(R1, R2, _MM_SHUFFLE(2, 2, 0, 0));
-    V1 = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 0, 2, 0));
-
-    Q1 = _mm_shuffle_ps(R0, V0, _MM_SHUFFLE(1, 0, 3, 0));
-    Q1 = XM_PERMUTE_PS(Q1, _MM_SHUFFLE(1, 3, 2, 0));
-
-    XMMATRIX M;
-    M.r[0] = Q1;
-
-    Q1 = _mm_shuffle_ps(R0, V0, _MM_SHUFFLE(3, 2, 3, 1));
-    Q1 = XM_PERMUTE_PS(Q1, _MM_SHUFFLE(1, 3, 0, 2));
-    M.r[1] = Q1;
-
-    Q1 = _mm_shuffle_ps(V1, R0, _MM_SHUFFLE(3, 2, 1, 0));
-    M.r[2] = Q1;
-    M.r[3] = g_XMIdentityR3;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixTransformation2D
-        (
-                FXMVECTOR ScalingOrigin,
-                float     ScalingOrientation,
-                FXMVECTOR Scaling,
-                FXMVECTOR RotationOrigin,
-                float     Rotation,
-                GXMVECTOR Translation
-        ) noexcept
-{
-    // M = Inverse(MScalingOrigin) * Transpose(MScalingOrientation) * MScaling * MScalingOrientation *
-    //         MScalingOrigin * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
-
-    XMVECTOR VScalingOrigin = XMVectorSelect(g_XMSelect1100.v, ScalingOrigin, g_XMSelect1100.v);
-    XMVECTOR NegScalingOrigin = XMVectorNegate(VScalingOrigin);
-
-    XMMATRIX MScalingOriginI = XMMatrixTranslationFromVector(NegScalingOrigin);
-    XMMATRIX MScalingOrientation = XMMatrixRotationZ(ScalingOrientation);
-    XMMATRIX MScalingOrientationT = XMMatrixTranspose(MScalingOrientation);
-    XMVECTOR VScaling = XMVectorSelect(g_XMOne.v, Scaling, g_XMSelect1100.v);
-    XMMATRIX MScaling = XMMatrixScalingFromVector(VScaling);
-    XMVECTOR VRotationOrigin = XMVectorSelect(g_XMSelect1100.v, RotationOrigin, g_XMSelect1100.v);
-    XMMATRIX MRotation = XMMatrixRotationZ(Rotation);
-    XMVECTOR VTranslation = XMVectorSelect(g_XMSelect1100.v, Translation, g_XMSelect1100.v);
-
-    XMMATRIX M = XMMatrixMultiply(MScalingOriginI, MScalingOrientationT);
-    M = XMMatrixMultiply(M, MScaling);
-    M = XMMatrixMultiply(M, MScalingOrientation);
-    M.r[3] = XMVectorAdd(M.r[3], VScalingOrigin);
-    M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
-    M = XMMatrixMultiply(M, MRotation);
-    M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
-    M.r[3] = XMVectorAdd(M.r[3], VTranslation);
-
-    return M;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixTransformation
-        (
-                FXMVECTOR ScalingOrigin,
-                FXMVECTOR ScalingOrientationQuaternion,
-                FXMVECTOR Scaling,
-                GXMVECTOR RotationOrigin,
-                HXMVECTOR RotationQuaternion,
-                HXMVECTOR Translation
-        ) noexcept
-{
-    // M = Inverse(MScalingOrigin) * Transpose(MScalingOrientation) * MScaling * MScalingOrientation *
-    //         MScalingOrigin * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
-
-    XMVECTOR VScalingOrigin = XMVectorSelect(g_XMSelect1110.v, ScalingOrigin, g_XMSelect1110.v);
-    XMVECTOR NegScalingOrigin = XMVectorNegate(ScalingOrigin);
-
-    XMMATRIX MScalingOriginI = XMMatrixTranslationFromVector(NegScalingOrigin);
-    XMMATRIX MScalingOrientation = XMMatrixRotationQuaternion(ScalingOrientationQuaternion);
-    XMMATRIX MScalingOrientationT = XMMatrixTranspose(MScalingOrientation);
-    XMMATRIX MScaling = XMMatrixScalingFromVector(Scaling);
-    XMVECTOR VRotationOrigin = XMVectorSelect(g_XMSelect1110.v, RotationOrigin, g_XMSelect1110.v);
-    XMMATRIX MRotation = XMMatrixRotationQuaternion(RotationQuaternion);
-    XMVECTOR VTranslation = XMVectorSelect(g_XMSelect1110.v, Translation, g_XMSelect1110.v);
-
-    XMMATRIX M;
-    M = XMMatrixMultiply(MScalingOriginI, MScalingOrientationT);
-    M = XMMatrixMultiply(M, MScaling);
-    M = XMMatrixMultiply(M, MScalingOrientation);
-    M.r[3] = XMVectorAdd(M.r[3], VScalingOrigin);
-    M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
-    M = XMMatrixMultiply(M, MRotation);
-    M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
-    M.r[3] = XMVectorAdd(M.r[3], VTranslation);
-    return M;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixAffineTransformation2D
-        (
-                FXMVECTOR Scaling,
-                FXMVECTOR RotationOrigin,
-                float     Rotation,
-                FXMVECTOR Translation
-        ) noexcept
-{
-    // M = MScaling * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
-
-    XMVECTOR VScaling = XMVectorSelect(g_XMOne.v, Scaling, g_XMSelect1100.v);
-    XMMATRIX MScaling = XMMatrixScalingFromVector(VScaling);
-    XMVECTOR VRotationOrigin = XMVectorSelect(g_XMSelect1100.v, RotationOrigin, g_XMSelect1100.v);
-    XMMATRIX MRotation = XMMatrixRotationZ(Rotation);
-    XMVECTOR VTranslation = XMVectorSelect(g_XMSelect1100.v, Translation, g_XMSelect1100.v);
-
-    XMMATRIX M;
-    M = MScaling;
-    M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
-    M = XMMatrixMultiply(M, MRotation);
-    M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
-    M.r[3] = XMVectorAdd(M.r[3], VTranslation);
-    return M;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixAffineTransformation
-        (
-                FXMVECTOR Scaling,
-                FXMVECTOR RotationOrigin,
-                FXMVECTOR RotationQuaternion,
-                GXMVECTOR Translation
-        ) noexcept
-{
-    // M = MScaling * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
-
-    XMMATRIX MScaling = XMMatrixScalingFromVector(Scaling);
-    XMVECTOR VRotationOrigin = XMVectorSelect(g_XMSelect1110.v, RotationOrigin, g_XMSelect1110.v);
-    XMMATRIX MRotation = XMMatrixRotationQuaternion(RotationQuaternion);
-    XMVECTOR VTranslation = XMVectorSelect(g_XMSelect1110.v, Translation, g_XMSelect1110.v);
-
-    XMMATRIX M;
-    M = MScaling;
-    M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
-    M = XMMatrixMultiply(M, MRotation);
-    M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
-    M.r[3] = XMVectorAdd(M.r[3], VTranslation);
-    return M;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixReflect(FXMVECTOR ReflectionPlane) noexcept
-{
-    assert(!XMVector3Equal(ReflectionPlane, XMVectorZero()));
-    assert(!XMPlaneIsInfinite(ReflectionPlane));
-
-    static const XMVECTORF32 NegativeTwo = { { { -2.0f, -2.0f, -2.0f, 0.0f } } };
-
-    XMVECTOR P = XMPlaneNormalize(ReflectionPlane);
-    XMVECTOR S = XMVectorMultiply(P, NegativeTwo);
-
-    XMVECTOR A = XMVectorSplatX(P);
-    XMVECTOR B = XMVectorSplatY(P);
-    XMVECTOR C = XMVectorSplatZ(P);
-    XMVECTOR D = XMVectorSplatW(P);
-
-    XMMATRIX M;
-    M.r[0] = XMVectorMultiplyAdd(A, S, g_XMIdentityR0.v);
-    M.r[1] = XMVectorMultiplyAdd(B, S, g_XMIdentityR1.v);
-    M.r[2] = XMVectorMultiplyAdd(C, S, g_XMIdentityR2.v);
-    M.r[3] = XMVectorMultiplyAdd(D, S, g_XMIdentityR3.v);
-    return M;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixShadow
-        (
-                FXMVECTOR ShadowPlane,
-                FXMVECTOR LightPosition
-        ) noexcept
-{
-    static const XMVECTORU32 Select0001 = { { { XM_SELECT_0, XM_SELECT_0, XM_SELECT_0, XM_SELECT_1 } } };
-
-    assert(!XMVector3Equal(ShadowPlane, XMVectorZero()));
-    assert(!XMPlaneIsInfinite(ShadowPlane));
-
-    XMVECTOR P = XMPlaneNormalize(ShadowPlane);
-    XMVECTOR Dot = XMPlaneDot(P, LightPosition);
-    P = XMVectorNegate(P);
-    XMVECTOR D = XMVectorSplatW(P);
-    XMVECTOR C = XMVectorSplatZ(P);
-    XMVECTOR B = XMVectorSplatY(P);
-    XMVECTOR A = XMVectorSplatX(P);
-    Dot = XMVectorSelect(Select0001.v, Dot, Select0001.v);
-
-    XMMATRIX M;
-    M.r[3] = XMVectorMultiplyAdd(D, LightPosition, Dot);
-    Dot = XMVectorRotateLeft(Dot, 1);
-    M.r[2] = XMVectorMultiplyAdd(C, LightPosition, Dot);
-    Dot = XMVectorRotateLeft(Dot, 1);
-    M.r[1] = XMVectorMultiplyAdd(B, LightPosition, Dot);
-    Dot = XMVectorRotateLeft(Dot, 1);
-    M.r[0] = XMVectorMultiplyAdd(A, LightPosition, Dot);
-    return M;
-}
-
-//------------------------------------------------------------------------------
-// View and projection initialization operations
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixLookAtLH
-        (
-                FXMVECTOR EyePosition,
-                FXMVECTOR FocusPosition,
-                FXMVECTOR UpDirection
-        ) noexcept
-{
-    XMVECTOR EyeDirection = XMVectorSubtract(FocusPosition, EyePosition);
-    return XMMatrixLookToLH(EyePosition, EyeDirection, UpDirection);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixLookAtRH
-        (
-                FXMVECTOR EyePosition,
-                FXMVECTOR FocusPosition,
-                FXMVECTOR UpDirection
-        ) noexcept
-{
-    XMVECTOR NegEyeDirection = XMVectorSubtract(EyePosition, FocusPosition);
-    return XMMatrixLookToLH(EyePosition, NegEyeDirection, UpDirection);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixLookToLH
-        (
-                FXMVECTOR EyePosition,
-                FXMVECTOR EyeDirection,
-                FXMVECTOR UpDirection
-        ) noexcept
-{
-    assert(!XMVector3Equal(EyeDirection, XMVectorZero()));
-    assert(!XMVector3IsInfinite(EyeDirection));
-    assert(!XMVector3Equal(UpDirection, XMVectorZero()));
-    assert(!XMVector3IsInfinite(UpDirection));
-
-    XMVECTOR R2 = XMVector3Normalize(EyeDirection);
-
-    XMVECTOR R0 = XMVector3Cross(UpDirection, R2);
-    R0 = XMVector3Normalize(R0);
-
-    XMVECTOR R1 = XMVector3Cross(R2, R0);
-
-    XMVECTOR NegEyePosition = XMVectorNegate(EyePosition);
-
-    XMVECTOR D0 = XMVector3Dot(R0, NegEyePosition);
-    XMVECTOR D1 = XMVector3Dot(R1, NegEyePosition);
-    XMVECTOR D2 = XMVector3Dot(R2, NegEyePosition);
-
-    XMMATRIX M;
-    M.r[0] = XMVectorSelect(D0, R0, g_XMSelect1110.v);
-    M.r[1] = XMVectorSelect(D1, R1, g_XMSelect1110.v);
-    M.r[2] = XMVectorSelect(D2, R2, g_XMSelect1110.v);
-    M.r[3] = g_XMIdentityR3.v;
-
-    M = XMMatrixTranspose(M);
-
-    return M;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixLookToRH
-        (
-                FXMVECTOR EyePosition,
-                FXMVECTOR EyeDirection,
-                FXMVECTOR UpDirection
-        ) noexcept
-{
-    XMVECTOR NegEyeDirection = XMVectorNegate(EyeDirection);
-    return XMMatrixLookToLH(EyePosition, NegEyeDirection, UpDirection);
-}
-
-//------------------------------------------------------------------------------
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable:28931, "PREfast noise: Esp:1266")
-#endif
-
-inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveLH
-        (
-                float ViewWidth,
-                float ViewHeight,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(NearZ > 0.f && FarZ > 0.f);
-    assert(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float TwoNearZ = NearZ + NearZ;
-    float fRange = FarZ / (FarZ - NearZ);
-
-    XMMATRIX M;
-    M.m[0][0] = TwoNearZ / ViewWidth;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = TwoNearZ / ViewHeight;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = fRange;
-    M.m[2][3] = 1.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = -fRange * NearZ;
-    M.m[3][3] = 0.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float TwoNearZ = NearZ + NearZ;
-    float fRange = FarZ / (FarZ - NearZ);
-    const float32x4_t Zero = vdupq_n_f32(0);
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(TwoNearZ / ViewWidth, Zero, 0);
-    M.r[1] = vsetq_lane_f32(TwoNearZ / ViewHeight, Zero, 1);
-    M.r[2] = vsetq_lane_f32(fRange, g_XMIdentityR3.v, 2);
-    M.r[3] = vsetq_lane_f32(-fRange * NearZ, Zero, 2);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    float TwoNearZ = NearZ + NearZ;
-    float fRange = FarZ / (FarZ - NearZ);
-    // Note: This is recorded on the stack
-    XMVECTOR rMem = {
-            TwoNearZ / ViewWidth,
-            TwoNearZ / ViewHeight,
-            fRange,
-            -fRange * NearZ
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // TwoNearZ / ViewWidth,0,0,0
-    M.r[0] = vTemp;
-    // 0,TwoNearZ / ViewHeight,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    M.r[1] = vTemp;
-    // x=fRange,y=-fRange * NearZ,0,1.0f
-    vValues = _mm_shuffle_ps(vValues, g_XMIdentityR3, _MM_SHUFFLE(3, 2, 3, 2));
-    // 0,0,fRange,1.0f
-    vTemp = _mm_setzero_ps();
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(3, 0, 0, 0));
-    M.r[2] = vTemp;
-    // 0,0,-fRange * NearZ,0
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(2, 1, 0, 0));
-    M.r[3] = vTemp;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveRH
-        (
-                float ViewWidth,
-                float ViewHeight,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(NearZ > 0.f && FarZ > 0.f);
-    assert(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float TwoNearZ = NearZ + NearZ;
-    float fRange = FarZ / (NearZ - FarZ);
-
-    XMMATRIX M;
-    M.m[0][0] = TwoNearZ / ViewWidth;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = TwoNearZ / ViewHeight;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = fRange;
-    M.m[2][3] = -1.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = fRange * NearZ;
-    M.m[3][3] = 0.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float TwoNearZ = NearZ + NearZ;
-    float fRange = FarZ / (NearZ - FarZ);
-    const float32x4_t Zero = vdupq_n_f32(0);
-
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(TwoNearZ / ViewWidth, Zero, 0);
-    M.r[1] = vsetq_lane_f32(TwoNearZ / ViewHeight, Zero, 1);
-    M.r[2] = vsetq_lane_f32(fRange, g_XMNegIdentityR3.v, 2);
-    M.r[3] = vsetq_lane_f32(fRange * NearZ, Zero, 2);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    float TwoNearZ = NearZ + NearZ;
-    float fRange = FarZ / (NearZ - FarZ);
-    // Note: This is recorded on the stack
-    XMVECTOR rMem = {
-            TwoNearZ / ViewWidth,
-            TwoNearZ / ViewHeight,
-            fRange,
-            fRange * NearZ
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // TwoNearZ / ViewWidth,0,0,0
-    M.r[0] = vTemp;
-    // 0,TwoNearZ / ViewHeight,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    M.r[1] = vTemp;
-    // x=fRange,y=-fRange * NearZ,0,-1.0f
-    vValues = _mm_shuffle_ps(vValues, g_XMNegIdentityR3, _MM_SHUFFLE(3, 2, 3, 2));
-    // 0,0,fRange,-1.0f
-    vTemp = _mm_setzero_ps();
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(3, 0, 0, 0));
-    M.r[2] = vTemp;
-    // 0,0,-fRange * NearZ,0
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(2, 1, 0, 0));
-    M.r[3] = vTemp;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveFovLH
-        (
-                float FovAngleY,
-                float AspectRatio,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(NearZ > 0.f && FarZ > 0.f);
-    assert(!XMScalarNearEqual(FovAngleY, 0.0f, 0.00001f * 2.0f));
-    assert(!XMScalarNearEqual(AspectRatio, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float    SinFov;
-    float    CosFov;
-    XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
-
-    float Height = CosFov / SinFov;
-    float Width = Height / AspectRatio;
-    float fRange = FarZ / (FarZ - NearZ);
-
-    XMMATRIX M;
-    M.m[0][0] = Width;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = Height;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = fRange;
-    M.m[2][3] = 1.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = -fRange * NearZ;
-    M.m[3][3] = 0.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float    SinFov;
-    float    CosFov;
-    XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
-
-    float fRange = FarZ / (FarZ - NearZ);
-    float Height = CosFov / SinFov;
-    float Width = Height / AspectRatio;
-    const float32x4_t Zero = vdupq_n_f32(0);
-
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(Width, Zero, 0);
-    M.r[1] = vsetq_lane_f32(Height, Zero, 1);
-    M.r[2] = vsetq_lane_f32(fRange, g_XMIdentityR3.v, 2);
-    M.r[3] = vsetq_lane_f32(-fRange * NearZ, Zero, 2);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    float    SinFov;
-    float    CosFov;
-    XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
-
-    float fRange = FarZ / (FarZ - NearZ);
-    // Note: This is recorded on the stack
-    float Height = CosFov / SinFov;
-    XMVECTOR rMem = {
-            Height / AspectRatio,
-            Height,
-            fRange,
-            -fRange * NearZ
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // CosFov / SinFov,0,0,0
-    XMMATRIX M;
-    M.r[0] = vTemp;
-    // 0,Height / AspectRatio,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    M.r[1] = vTemp;
-    // x=fRange,y=-fRange * NearZ,0,1.0f
-    vTemp = _mm_setzero_ps();
-    vValues = _mm_shuffle_ps(vValues, g_XMIdentityR3, _MM_SHUFFLE(3, 2, 3, 2));
-    // 0,0,fRange,1.0f
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(3, 0, 0, 0));
-    M.r[2] = vTemp;
-    // 0,0,-fRange * NearZ,0.0f
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(2, 1, 0, 0));
-    M.r[3] = vTemp;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveFovRH
-        (
-                float FovAngleY,
-                float AspectRatio,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(NearZ > 0.f && FarZ > 0.f);
-    assert(!XMScalarNearEqual(FovAngleY, 0.0f, 0.00001f * 2.0f));
-    assert(!XMScalarNearEqual(AspectRatio, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float    SinFov;
-    float    CosFov;
-    XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
-
-    float Height = CosFov / SinFov;
-    float Width = Height / AspectRatio;
-    float fRange = FarZ / (NearZ - FarZ);
-
-    XMMATRIX M;
-    M.m[0][0] = Width;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = Height;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = fRange;
-    M.m[2][3] = -1.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = fRange * NearZ;
-    M.m[3][3] = 0.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float    SinFov;
-    float    CosFov;
-    XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
-    float fRange = FarZ / (NearZ - FarZ);
-    float Height = CosFov / SinFov;
-    float Width = Height / AspectRatio;
-    const float32x4_t Zero = vdupq_n_f32(0);
-
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(Width, Zero, 0);
-    M.r[1] = vsetq_lane_f32(Height, Zero, 1);
-    M.r[2] = vsetq_lane_f32(fRange, g_XMNegIdentityR3.v, 2);
-    M.r[3] = vsetq_lane_f32(fRange * NearZ, Zero, 2);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    float    SinFov;
-    float    CosFov;
-    XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
-    float fRange = FarZ / (NearZ - FarZ);
-    // Note: This is recorded on the stack
-    float Height = CosFov / SinFov;
-    XMVECTOR rMem = {
-            Height / AspectRatio,
-            Height,
-            fRange,
-            fRange * NearZ
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // CosFov / SinFov,0,0,0
-    XMMATRIX M;
-    M.r[0] = vTemp;
-    // 0,Height / AspectRatio,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    M.r[1] = vTemp;
-    // x=fRange,y=-fRange * NearZ,0,-1.0f
-    vTemp = _mm_setzero_ps();
-    vValues = _mm_shuffle_ps(vValues, g_XMNegIdentityR3, _MM_SHUFFLE(3, 2, 3, 2));
-    // 0,0,fRange,-1.0f
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(3, 0, 0, 0));
-    M.r[2] = vTemp;
-    // 0,0,fRange * NearZ,0.0f
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(2, 1, 0, 0));
-    M.r[3] = vTemp;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterLH
-        (
-                float ViewLeft,
-                float ViewRight,
-                float ViewBottom,
-                float ViewTop,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(NearZ > 0.f && FarZ > 0.f);
-    assert(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
-    assert(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float TwoNearZ = NearZ + NearZ;
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = FarZ / (FarZ - NearZ);
-
-    XMMATRIX M;
-    M.m[0][0] = TwoNearZ * ReciprocalWidth;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = TwoNearZ * ReciprocalHeight;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = -(ViewLeft + ViewRight) * ReciprocalWidth;
-    M.m[2][1] = -(ViewTop + ViewBottom) * ReciprocalHeight;
-    M.m[2][2] = fRange;
-    M.m[2][3] = 1.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = -fRange * NearZ;
-    M.m[3][3] = 0.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float TwoNearZ = NearZ + NearZ;
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = FarZ / (FarZ - NearZ);
-    const float32x4_t Zero = vdupq_n_f32(0);
-
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(TwoNearZ * ReciprocalWidth, Zero, 0);
-    M.r[1] = vsetq_lane_f32(TwoNearZ * ReciprocalHeight, Zero, 1);
-    M.r[2] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
-        -(ViewTop + ViewBottom) * ReciprocalHeight,
-        fRange,
-        1.0f);
-    M.r[3] = vsetq_lane_f32(-fRange * NearZ, Zero, 2);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    float TwoNearZ = NearZ + NearZ;
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = FarZ / (FarZ - NearZ);
-    // Note: This is recorded on the stack
-    XMVECTOR rMem = {
-            TwoNearZ * ReciprocalWidth,
-            TwoNearZ * ReciprocalHeight,
-            -fRange * NearZ,
-            0
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // TwoNearZ*ReciprocalWidth,0,0,0
-    M.r[0] = vTemp;
-    // 0,TwoNearZ*ReciprocalHeight,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    M.r[1] = vTemp;
-    // 0,0,fRange,1.0f
-    M.r[2] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
-                         -(ViewTop + ViewBottom) * ReciprocalHeight,
-                         fRange,
-                         1.0f);
-    // 0,0,-fRange * NearZ,0.0f
-    vValues = _mm_and_ps(vValues, g_XMMaskZ);
-    M.r[3] = vValues;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterRH
-        (
-                float ViewLeft,
-                float ViewRight,
-                float ViewBottom,
-                float ViewTop,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(NearZ > 0.f && FarZ > 0.f);
-    assert(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
-    assert(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float TwoNearZ = NearZ + NearZ;
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = FarZ / (NearZ - FarZ);
-
-    XMMATRIX M;
-    M.m[0][0] = TwoNearZ * ReciprocalWidth;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = TwoNearZ * ReciprocalHeight;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = (ViewLeft + ViewRight) * ReciprocalWidth;
-    M.m[2][1] = (ViewTop + ViewBottom) * ReciprocalHeight;
-    M.m[2][2] = fRange;
-    M.m[2][3] = -1.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = fRange * NearZ;
-    M.m[3][3] = 0.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float TwoNearZ = NearZ + NearZ;
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = FarZ / (NearZ - FarZ);
-    const float32x4_t Zero = vdupq_n_f32(0);
-
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(TwoNearZ * ReciprocalWidth, Zero, 0);
-    M.r[1] = vsetq_lane_f32(TwoNearZ * ReciprocalHeight, Zero, 1);
-    M.r[2] = XMVectorSet((ViewLeft + ViewRight) * ReciprocalWidth,
-        (ViewTop + ViewBottom) * ReciprocalHeight,
-        fRange,
-        -1.0f);
-    M.r[3] = vsetq_lane_f32(fRange * NearZ, Zero, 2);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    float TwoNearZ = NearZ + NearZ;
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = FarZ / (NearZ - FarZ);
-    // Note: This is recorded on the stack
-    XMVECTOR rMem = {
-            TwoNearZ * ReciprocalWidth,
-            TwoNearZ * ReciprocalHeight,
-            fRange * NearZ,
-            0
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // TwoNearZ*ReciprocalWidth,0,0,0
-    M.r[0] = vTemp;
-    // 0,TwoNearZ*ReciprocalHeight,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    M.r[1] = vTemp;
-    // 0,0,fRange,1.0f
-    M.r[2] = XMVectorSet((ViewLeft + ViewRight) * ReciprocalWidth,
-                         (ViewTop + ViewBottom) * ReciprocalHeight,
-                         fRange,
-                         -1.0f);
-    // 0,0,-fRange * NearZ,0.0f
-    vValues = _mm_and_ps(vValues, g_XMMaskZ);
-    M.r[3] = vValues;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixOrthographicLH
-        (
-                float ViewWidth,
-                float ViewHeight,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float fRange = 1.0f / (FarZ - NearZ);
-
-    XMMATRIX M;
-    M.m[0][0] = 2.0f / ViewWidth;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = 2.0f / ViewHeight;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = fRange;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = -fRange * NearZ;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float fRange = 1.0f / (FarZ - NearZ);
-
-    const float32x4_t Zero = vdupq_n_f32(0);
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(2.0f / ViewWidth, Zero, 0);
-    M.r[1] = vsetq_lane_f32(2.0f / ViewHeight, Zero, 1);
-    M.r[2] = vsetq_lane_f32(fRange, Zero, 2);
-    M.r[3] = vsetq_lane_f32(-fRange * NearZ, g_XMIdentityR3.v, 2);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    float fRange = 1.0f / (FarZ - NearZ);
-    // Note: This is recorded on the stack
-    XMVECTOR rMem = {
-            2.0f / ViewWidth,
-            2.0f / ViewHeight,
-            fRange,
-            -fRange * NearZ
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // 2.0f / ViewWidth,0,0,0
-    M.r[0] = vTemp;
-    // 0,2.0f / ViewHeight,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    M.r[1] = vTemp;
-    // x=fRange,y=-fRange * NearZ,0,1.0f
-    vTemp = _mm_setzero_ps();
-    vValues = _mm_shuffle_ps(vValues, g_XMIdentityR3, _MM_SHUFFLE(3, 2, 3, 2));
-    // 0,0,fRange,0.0f
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(2, 0, 0, 0));
-    M.r[2] = vTemp;
-    // 0,0,-fRange * NearZ,1.0f
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(3, 1, 0, 0));
-    M.r[3] = vTemp;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixOrthographicRH
-        (
-                float ViewWidth,
-                float ViewHeight,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float fRange = 1.0f / (NearZ - FarZ);
-
-    XMMATRIX M;
-    M.m[0][0] = 2.0f / ViewWidth;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = 2.0f / ViewHeight;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = fRange;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = 0.0f;
-    M.m[3][1] = 0.0f;
-    M.m[3][2] = fRange * NearZ;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float fRange = 1.0f / (NearZ - FarZ);
-
-    const float32x4_t Zero = vdupq_n_f32(0);
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(2.0f / ViewWidth, Zero, 0);
-    M.r[1] = vsetq_lane_f32(2.0f / ViewHeight, Zero, 1);
-    M.r[2] = vsetq_lane_f32(fRange, Zero, 2);
-    M.r[3] = vsetq_lane_f32(fRange * NearZ, g_XMIdentityR3.v, 2);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    float fRange = 1.0f / (NearZ - FarZ);
-    // Note: This is recorded on the stack
-    XMVECTOR rMem = {
-            2.0f / ViewWidth,
-            2.0f / ViewHeight,
-            fRange,
-            fRange * NearZ
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // 2.0f / ViewWidth,0,0,0
-    M.r[0] = vTemp;
-    // 0,2.0f / ViewHeight,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    M.r[1] = vTemp;
-    // x=fRange,y=fRange * NearZ,0,1.0f
-    vTemp = _mm_setzero_ps();
-    vValues = _mm_shuffle_ps(vValues, g_XMIdentityR3, _MM_SHUFFLE(3, 2, 3, 2));
-    // 0,0,fRange,0.0f
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(2, 0, 0, 0));
-    M.r[2] = vTemp;
-    // 0,0,fRange * NearZ,1.0f
-    vTemp = _mm_shuffle_ps(vTemp, vValues, _MM_SHUFFLE(3, 1, 0, 0));
-    M.r[3] = vTemp;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterLH
-        (
-                float ViewLeft,
-                float ViewRight,
-                float ViewBottom,
-                float ViewTop,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
-    assert(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = 1.0f / (FarZ - NearZ);
-
-    XMMATRIX M;
-    M.m[0][0] = ReciprocalWidth + ReciprocalWidth;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = ReciprocalHeight + ReciprocalHeight;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = fRange;
-    M.m[2][3] = 0.0f;
-
-    M.m[3][0] = -(ViewLeft + ViewRight) * ReciprocalWidth;
-    M.m[3][1] = -(ViewTop + ViewBottom) * ReciprocalHeight;
-    M.m[3][2] = -fRange * NearZ;
-    M.m[3][3] = 1.0f;
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = 1.0f / (FarZ - NearZ);
-    const float32x4_t Zero = vdupq_n_f32(0);
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(ReciprocalWidth + ReciprocalWidth, Zero, 0);
-    M.r[1] = vsetq_lane_f32(ReciprocalHeight + ReciprocalHeight, Zero, 1);
-    M.r[2] = vsetq_lane_f32(fRange, Zero, 2);
-    M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
-        -(ViewTop + ViewBottom) * ReciprocalHeight,
-        -fRange * NearZ,
-        1.0f);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    float fReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float fReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = 1.0f / (FarZ - NearZ);
-    // Note: This is recorded on the stack
-    XMVECTOR rMem = {
-            fReciprocalWidth,
-            fReciprocalHeight,
-            fRange,
-            1.0f
-    };
-    XMVECTOR rMem2 = {
-            -(ViewLeft + ViewRight),
-            -(ViewTop + ViewBottom),
-            -NearZ,
-            1.0f
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // fReciprocalWidth*2,0,0,0
-    vTemp = _mm_add_ss(vTemp, vTemp);
-    M.r[0] = vTemp;
-    // 0,fReciprocalHeight*2,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    vTemp = _mm_add_ps(vTemp, vTemp);
-    M.r[1] = vTemp;
-    // 0,0,fRange,0.0f
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskZ);
-    M.r[2] = vTemp;
-    // -(ViewLeft + ViewRight)*fReciprocalWidth,-(ViewTop + ViewBottom)*fReciprocalHeight,fRange*-NearZ,1.0f
-    vValues = _mm_mul_ps(vValues, rMem2);
-    M.r[3] = vValues;
-    return M;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterRH
-        (
-                float ViewLeft,
-                float ViewRight,
-                float ViewBottom,
-                float ViewTop,
-                float NearZ,
-                float FarZ
-        ) noexcept
-{
-    assert(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
-    assert(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
-    assert(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = 1.0f / (NearZ - FarZ);
-
-    XMMATRIX M;
-    M.m[0][0] = ReciprocalWidth + ReciprocalWidth;
-    M.m[0][1] = 0.0f;
-    M.m[0][2] = 0.0f;
-    M.m[0][3] = 0.0f;
-
-    M.m[1][0] = 0.0f;
-    M.m[1][1] = ReciprocalHeight + ReciprocalHeight;
-    M.m[1][2] = 0.0f;
-    M.m[1][3] = 0.0f;
-
-    M.m[2][0] = 0.0f;
-    M.m[2][1] = 0.0f;
-    M.m[2][2] = fRange;
-    M.m[2][3] = 0.0f;
-
-    M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
-        -(ViewTop + ViewBottom) * ReciprocalHeight,
-        fRange * NearZ,
-        1.0f);
-    return M;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = 1.0f / (NearZ - FarZ);
-    const float32x4_t Zero = vdupq_n_f32(0);
-    XMMATRIX M;
-    M.r[0] = vsetq_lane_f32(ReciprocalWidth + ReciprocalWidth, Zero, 0);
-    M.r[1] = vsetq_lane_f32(ReciprocalHeight + ReciprocalHeight, Zero, 1);
-    M.r[2] = vsetq_lane_f32(fRange, Zero, 2);
-    M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
-        -(ViewTop + ViewBottom) * ReciprocalHeight,
-        fRange * NearZ,
-        1.0f);
-    return M;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMMATRIX M;
-    float fReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
-    float fReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
-    float fRange = 1.0f / (NearZ - FarZ);
-    // Note: This is recorded on the stack
-    XMVECTOR rMem = {
-            fReciprocalWidth,
-            fReciprocalHeight,
-            fRange,
-            1.0f
-    };
-    XMVECTOR rMem2 = {
-            -(ViewLeft + ViewRight),
-            -(ViewTop + ViewBottom),
-            NearZ,
-            1.0f
-    };
-    // Copy from memory to SSE register
-    XMVECTOR vValues = rMem;
-    XMVECTOR vTemp = _mm_setzero_ps();
-    // Copy x only
-    vTemp = _mm_move_ss(vTemp, vValues);
-    // fReciprocalWidth*2,0,0,0
-    vTemp = _mm_add_ss(vTemp, vTemp);
-    M.r[0] = vTemp;
-    // 0,fReciprocalHeight*2,0,0
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskY);
-    vTemp = _mm_add_ps(vTemp, vTemp);
-    M.r[1] = vTemp;
-    // 0,0,fRange,0.0f
-    vTemp = vValues;
-    vTemp = _mm_and_ps(vTemp, g_XMMaskZ);
-    M.r[2] = vTemp;
-    // -(ViewLeft + ViewRight)*fReciprocalWidth,-(ViewTop + ViewBottom)*fReciprocalHeight,fRange*-NearZ,1.0f
-    vValues = _mm_mul_ps(vValues, rMem2);
-    M.r[3] = vValues;
-    return M;
-#endif
-}
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-/****************************************************************************
- *
- * XMMATRIX operators and methods
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX::XMMATRIX
-        (
-                float m00, float m01, float m02, float m03,
-                float m10, float m11, float m12, float m13,
-                float m20, float m21, float m22, float m23,
-                float m30, float m31, float m32, float m33
-        ) noexcept
-{
-    r[0] = XMVectorSet(m00, m01, m02, m03);
-    r[1] = XMVectorSet(m10, m11, m12, m13);
-    r[2] = XMVectorSet(m20, m21, m22, m23);
-    r[3] = XMVectorSet(m30, m31, m32, m33);
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMMATRIX::XMMATRIX(const float* pArray) noexcept
-{
-    assert(pArray != nullptr);
-    r[0] = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray));
-    r[1] = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray + 4));
-    r[2] = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray + 8));
-    r[3] = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray + 12));
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XMMATRIX::operator- () const noexcept
-{
-    XMMATRIX R;
-    R.r[0] = XMVectorNegate(r[0]);
-    R.r[1] = XMVectorNegate(r[1]);
-    R.r[2] = XMVectorNegate(r[2]);
-    R.r[3] = XMVectorNegate(r[3]);
-    return R;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX& XM_CALLCONV XMMATRIX::operator+= (FXMMATRIX M) noexcept
-{
-    r[0] = XMVectorAdd(r[0], M.r[0]);
-    r[1] = XMVectorAdd(r[1], M.r[1]);
-    r[2] = XMVectorAdd(r[2], M.r[2]);
-    r[3] = XMVectorAdd(r[3], M.r[3]);
-    return *this;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX& XM_CALLCONV XMMATRIX::operator-= (FXMMATRIX M) noexcept
-{
-    r[0] = XMVectorSubtract(r[0], M.r[0]);
-    r[1] = XMVectorSubtract(r[1], M.r[1]);
-    r[2] = XMVectorSubtract(r[2], M.r[2]);
-    r[3] = XMVectorSubtract(r[3], M.r[3]);
-    return *this;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX& XM_CALLCONV XMMATRIX::operator*=(FXMMATRIX M) noexcept
-{
-    *this = XMMatrixMultiply(*this, M);
-    return *this;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX& XMMATRIX::operator*= (float S) noexcept
-{
-    r[0] = XMVectorScale(r[0], S);
-    r[1] = XMVectorScale(r[1], S);
-    r[2] = XMVectorScale(r[2], S);
-    r[3] = XMVectorScale(r[3], S);
-    return *this;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX& XMMATRIX::operator/= (float S) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR vS = XMVectorReplicate(S);
-    r[0] = XMVectorDivide(r[0], vS);
-    r[1] = XMVectorDivide(r[1], vS);
-    r[2] = XMVectorDivide(r[2], vS);
-    r[3] = XMVectorDivide(r[3], vS);
-    return *this;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    float32x4_t vS = vdupq_n_f32(S);
-    r[0] = vdivq_f32(r[0], vS);
-    r[1] = vdivq_f32(r[1], vS);
-    r[2] = vdivq_f32(r[2], vS);
-    r[3] = vdivq_f32(r[3], vS);
-#else
-    // 2 iterations of Newton-Raphson refinement of reciprocal
-    float32x2_t vS = vdup_n_f32(S);
-    float32x2_t R0 = vrecpe_f32(vS);
-    float32x2_t S0 = vrecps_f32(R0, vS);
-    R0 = vmul_f32(S0, R0);
-    S0 = vrecps_f32(R0, vS);
-    R0 = vmul_f32(S0, R0);
-    float32x4_t Reciprocal = vcombine_f32(R0, R0);
-    r[0] = vmulq_f32(r[0], Reciprocal);
-    r[1] = vmulq_f32(r[1], Reciprocal);
-    r[2] = vmulq_f32(r[2], Reciprocal);
-    r[3] = vmulq_f32(r[3], Reciprocal);
-#endif
-    return *this;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 vS = _mm_set_ps1(S);
-    r[0] = _mm_div_ps(r[0], vS);
-    r[1] = _mm_div_ps(r[1], vS);
-    r[2] = _mm_div_ps(r[2], vS);
-    r[3] = _mm_div_ps(r[3], vS);
-    return *this;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMATRIX::operator+ (FXMMATRIX M) const noexcept
-{
-    XMMATRIX R;
-    R.r[0] = XMVectorAdd(r[0], M.r[0]);
-    R.r[1] = XMVectorAdd(r[1], M.r[1]);
-    R.r[2] = XMVectorAdd(r[2], M.r[2]);
-    R.r[3] = XMVectorAdd(r[3], M.r[3]);
-    return R;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMATRIX::operator- (FXMMATRIX M) const noexcept
-{
-    XMMATRIX R;
-    R.r[0] = XMVectorSubtract(r[0], M.r[0]);
-    R.r[1] = XMVectorSubtract(r[1], M.r[1]);
-    R.r[2] = XMVectorSubtract(r[2], M.r[2]);
-    R.r[3] = XMVectorSubtract(r[3], M.r[3]);
-    return R;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV XMMATRIX::operator*(FXMMATRIX M) const noexcept
-{
-    return XMMatrixMultiply(*this, M);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XMMATRIX::operator* (float S) const noexcept
-{
-    XMMATRIX R;
-    R.r[0] = XMVectorScale(r[0], S);
-    R.r[1] = XMVectorScale(r[1], S);
-    R.r[2] = XMVectorScale(r[2], S);
-    R.r[3] = XMVectorScale(r[3], S);
-    return R;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XMMATRIX::operator/ (float S) const noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR vS = XMVectorReplicate(S);
-    XMMATRIX R;
-    R.r[0] = XMVectorDivide(r[0], vS);
-    R.r[1] = XMVectorDivide(r[1], vS);
-    R.r[2] = XMVectorDivide(r[2], vS);
-    R.r[3] = XMVectorDivide(r[3], vS);
-    return R;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    float32x4_t vS = vdupq_n_f32(S);
-    XMMATRIX R;
-    R.r[0] = vdivq_f32(r[0], vS);
-    R.r[1] = vdivq_f32(r[1], vS);
-    R.r[2] = vdivq_f32(r[2], vS);
-    R.r[3] = vdivq_f32(r[3], vS);
-#else
-    // 2 iterations of Newton-Raphson refinement of reciprocal
-    float32x2_t vS = vdup_n_f32(S);
-    float32x2_t R0 = vrecpe_f32(vS);
-    float32x2_t S0 = vrecps_f32(R0, vS);
-    R0 = vmul_f32(S0, R0);
-    S0 = vrecps_f32(R0, vS);
-    R0 = vmul_f32(S0, R0);
-    float32x4_t Reciprocal = vcombine_f32(R0, R0);
-    XMMATRIX R;
-    R.r[0] = vmulq_f32(r[0], Reciprocal);
-    R.r[1] = vmulq_f32(r[1], Reciprocal);
-    R.r[2] = vmulq_f32(r[2], Reciprocal);
-    R.r[3] = vmulq_f32(r[3], Reciprocal);
-#endif
-    return R;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 vS = _mm_set_ps1(S);
-    XMMATRIX R;
-    R.r[0] = _mm_div_ps(r[0], vS);
-    R.r[1] = _mm_div_ps(r[1], vS);
-    R.r[2] = _mm_div_ps(r[2], vS);
-    R.r[3] = _mm_div_ps(r[3], vS);
-    return R;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMMATRIX XM_CALLCONV operator*
-        (
-                float S,
-                FXMMATRIX M
-        ) noexcept
-{
-    XMMATRIX R;
-    R.r[0] = XMVectorScale(M.r[0], S);
-    R.r[1] = XMVectorScale(M.r[1], S);
-    R.r[2] = XMVectorScale(M.r[2], S);
-    R.r[3] = XMVectorScale(M.r[3], S);
-    return R;
-}
-
-/****************************************************************************
- *
- * XMFLOAT3X3 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMFLOAT3X3::XMFLOAT3X3(const float* pArray) noexcept
-{
-    assert(pArray != nullptr);
-    for (size_t Row = 0; Row < 3; Row++)
-    {
-        for (size_t Column = 0; Column < 3; Column++)
-        {
-            m[Row][Column] = pArray[Row * 3 + Column];
-        }
-    }
-}
-
-/****************************************************************************
- *
- * XMFLOAT4X3 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMFLOAT4X3::XMFLOAT4X3(const float* pArray) noexcept
-{
-    assert(pArray != nullptr);
-
-    m[0][0] = pArray[0];
-    m[0][1] = pArray[1];
-    m[0][2] = pArray[2];
-
-    m[1][0] = pArray[3];
-    m[1][1] = pArray[4];
-    m[1][2] = pArray[5];
-
-    m[2][0] = pArray[6];
-    m[2][1] = pArray[7];
-    m[2][2] = pArray[8];
-
-    m[3][0] = pArray[9];
-    m[3][1] = pArray[10];
-    m[3][2] = pArray[11];
-}
-
-/****************************************************************************
-*
-* XMFLOAT3X4 operators
-*
-****************************************************************************/
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMFLOAT3X4::XMFLOAT3X4(const float* pArray) noexcept
-{
-    assert(pArray != nullptr);
-
-    m[0][0] = pArray[0];
-    m[0][1] = pArray[1];
-    m[0][2] = pArray[2];
-    m[0][3] = pArray[3];
-
-    m[1][0] = pArray[4];
-    m[1][1] = pArray[5];
-    m[1][2] = pArray[6];
-    m[1][3] = pArray[7];
-
-    m[2][0] = pArray[8];
-    m[2][1] = pArray[9];
-    m[2][2] = pArray[10];
-    m[2][3] = pArray[11];
-}
-
-/****************************************************************************
- *
- * XMFLOAT4X4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMFLOAT4X4::XMFLOAT4X4(const float* pArray) noexcept
-{
-    assert(pArray != nullptr);
-
-    m[0][0] = pArray[0];
-    m[0][1] = pArray[1];
-    m[0][2] = pArray[2];
-    m[0][3] = pArray[3];
-
-    m[1][0] = pArray[4];
-    m[1][1] = pArray[5];
-    m[1][2] = pArray[6];
-    m[1][3] = pArray[7];
-
-    m[2][0] = pArray[8];
-    m[2][1] = pArray[9];
-    m[2][2] = pArray[10];
-    m[2][3] = pArray[11];
-
-    m[3][0] = pArray[12];
-    m[3][1] = pArray[13];
-    m[3][2] = pArray[14];
-    m[3][3] = pArray[15];
-}
-
diff --git a/thirdparty/directxmath/DirectXMathMisc.inl b/thirdparty/directxmath/DirectXMathMisc.inl
deleted file mode 100644
index c6ed25d..0000000
--- a/thirdparty/directxmath/DirectXMathMisc.inl
+++ /dev/null
@@ -1,2493 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXMathMisc.inl -- SIMD C++ Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-/****************************************************************************
- *
- * Quaternion
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-// Comparison operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMQuaternionEqual
-        (
-                FXMVECTOR Q1,
-                FXMVECTOR Q2
-        ) noexcept
-{
-    return XMVector4Equal(Q1, Q2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMQuaternionNotEqual
-        (
-                FXMVECTOR Q1,
-                FXMVECTOR Q2
-        ) noexcept
-{
-    return XMVector4NotEqual(Q1, Q2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMQuaternionIsNaN(FXMVECTOR Q) noexcept
-{
-    return XMVector4IsNaN(Q);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMQuaternionIsInfinite(FXMVECTOR Q) noexcept
-{
-    return XMVector4IsInfinite(Q);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMQuaternionIsIdentity(FXMVECTOR Q) noexcept
-{
-    return XMVector4Equal(Q, g_XMIdentityR3.v);
-}
-
-//------------------------------------------------------------------------------
-// Computation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionDot
-        (
-                FXMVECTOR Q1,
-                FXMVECTOR Q2
-        ) noexcept
-{
-    return XMVector4Dot(Q1, Q2);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionMultiply
-        (
-                FXMVECTOR Q1,
-                FXMVECTOR Q2
-        ) noexcept
-{
-    // Returns the product Q2*Q1 (which is the concatenation of a rotation Q1 followed by the rotation Q2)
-
-    // [ (Q2.w * Q1.x) + (Q2.x * Q1.w) + (Q2.y * Q1.z) - (Q2.z * Q1.y),
-    //   (Q2.w * Q1.y) - (Q2.x * Q1.z) + (Q2.y * Q1.w) + (Q2.z * Q1.x),
-    //   (Q2.w * Q1.z) + (Q2.x * Q1.y) - (Q2.y * Q1.x) + (Q2.z * Q1.w),
-    //   (Q2.w * Q1.w) - (Q2.x * Q1.x) - (Q2.y * Q1.y) - (Q2.z * Q1.z) ]
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            (Q2.vector4_f32[3] * Q1.vector4_f32[0]) + (Q2.vector4_f32[0] * Q1.vector4_f32[3]) + (Q2.vector4_f32[1] * Q1.vector4_f32[2]) - (Q2.vector4_f32[2] * Q1.vector4_f32[1]),
-            (Q2.vector4_f32[3] * Q1.vector4_f32[1]) - (Q2.vector4_f32[0] * Q1.vector4_f32[2]) + (Q2.vector4_f32[1] * Q1.vector4_f32[3]) + (Q2.vector4_f32[2] * Q1.vector4_f32[0]),
-            (Q2.vector4_f32[3] * Q1.vector4_f32[2]) + (Q2.vector4_f32[0] * Q1.vector4_f32[1]) - (Q2.vector4_f32[1] * Q1.vector4_f32[0]) + (Q2.vector4_f32[2] * Q1.vector4_f32[3]),
-            (Q2.vector4_f32[3] * Q1.vector4_f32[3]) - (Q2.vector4_f32[0] * Q1.vector4_f32[0]) - (Q2.vector4_f32[1] * Q1.vector4_f32[1]) - (Q2.vector4_f32[2] * Q1.vector4_f32[2])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 ControlWZYX = { { { 1.0f, -1.0f, 1.0f, -1.0f } } };
-    static const XMVECTORF32 ControlZWXY = { { { 1.0f, 1.0f, -1.0f, -1.0f } } };
-    static const XMVECTORF32 ControlYXWZ = { { { -1.0f, 1.0f, 1.0f, -1.0f } } };
-
-    float32x2_t Q2L = vget_low_f32(Q2);
-    float32x2_t Q2H = vget_high_f32(Q2);
-
-    float32x4_t Q2X = vdupq_lane_f32(Q2L, 0);
-    float32x4_t Q2Y = vdupq_lane_f32(Q2L, 1);
-    float32x4_t Q2Z = vdupq_lane_f32(Q2H, 0);
-    XMVECTOR vResult = vmulq_lane_f32(Q1, Q2H, 1);
-
-    // Mul by Q1WZYX
-    float32x4_t vTemp = vrev64q_f32(Q1);
-    vTemp = vcombine_f32(vget_high_f32(vTemp), vget_low_f32(vTemp));
-    Q2X = vmulq_f32(Q2X, vTemp);
-    vResult = vmlaq_f32(vResult, Q2X, ControlWZYX);
-
-    // Mul by Q1ZWXY
-    vTemp = vreinterpretq_f32_u32(vrev64q_u32(vreinterpretq_u32_f32(vTemp)));
-    Q2Y = vmulq_f32(Q2Y, vTemp);
-    vResult = vmlaq_f32(vResult, Q2Y, ControlZWXY);
-
-    // Mul by Q1YXWZ
-    vTemp = vreinterpretq_f32_u32(vrev64q_u32(vreinterpretq_u32_f32(vTemp)));
-    vTemp = vcombine_f32(vget_high_f32(vTemp), vget_low_f32(vTemp));
-    Q2Z = vmulq_f32(Q2Z, vTemp);
-    vResult = vmlaq_f32(vResult, Q2Z, ControlYXWZ);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 ControlWZYX = { { { 1.0f, -1.0f, 1.0f, -1.0f } } };
-    static const XMVECTORF32 ControlZWXY = { { { 1.0f, 1.0f, -1.0f, -1.0f } } };
-    static const XMVECTORF32 ControlYXWZ = { { { -1.0f, 1.0f, 1.0f, -1.0f } } };
-    // Copy to SSE registers and use as few as possible for x86
-    XMVECTOR Q2X = Q2;
-    XMVECTOR Q2Y = Q2;
-    XMVECTOR Q2Z = Q2;
-    XMVECTOR vResult = Q2;
-    // Splat with one instruction
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 3, 3, 3));
-    Q2X = XM_PERMUTE_PS(Q2X, _MM_SHUFFLE(0, 0, 0, 0));
-    Q2Y = XM_PERMUTE_PS(Q2Y, _MM_SHUFFLE(1, 1, 1, 1));
-    Q2Z = XM_PERMUTE_PS(Q2Z, _MM_SHUFFLE(2, 2, 2, 2));
-    // Retire Q1 and perform Q1*Q2W
-    vResult = _mm_mul_ps(vResult, Q1);
-    XMVECTOR Q1Shuffle = Q1;
-    // Shuffle the copies of Q1
-    Q1Shuffle = XM_PERMUTE_PS(Q1Shuffle, _MM_SHUFFLE(0, 1, 2, 3));
-    // Mul by Q1WZYX
-    Q2X = _mm_mul_ps(Q2X, Q1Shuffle);
-    Q1Shuffle = XM_PERMUTE_PS(Q1Shuffle, _MM_SHUFFLE(2, 3, 0, 1));
-    // Flip the signs on y and z
-    vResult = XM_FMADD_PS(Q2X, ControlWZYX, vResult);
-    // Mul by Q1ZWXY
-    Q2Y = _mm_mul_ps(Q2Y, Q1Shuffle);
-    Q1Shuffle = XM_PERMUTE_PS(Q1Shuffle, _MM_SHUFFLE(0, 1, 2, 3));
-    // Flip the signs on z and w
-    Q2Y = _mm_mul_ps(Q2Y, ControlZWXY);
-    // Mul by Q1YXWZ
-    Q2Z = _mm_mul_ps(Q2Z, Q1Shuffle);
-    // Flip the signs on x and w
-    Q2Y = XM_FMADD_PS(Q2Z, ControlYXWZ, Q2Y);
-    vResult = _mm_add_ps(vResult, Q2Y);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionLengthSq(FXMVECTOR Q) noexcept
-{
-    return XMVector4LengthSq(Q);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionReciprocalLength(FXMVECTOR Q) noexcept
-{
-    return XMVector4ReciprocalLength(Q);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionLength(FXMVECTOR Q) noexcept
-{
-    return XMVector4Length(Q);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionNormalizeEst(FXMVECTOR Q) noexcept
-{
-    return XMVector4NormalizeEst(Q);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionNormalize(FXMVECTOR Q) noexcept
-{
-    return XMVector4Normalize(Q);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionConjugate(FXMVECTOR Q) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            -Q.vector4_f32[0],
-            -Q.vector4_f32[1],
-            -Q.vector4_f32[2],
-            Q.vector4_f32[3]
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 NegativeOne3 = { { { -1.0f, -1.0f, -1.0f, 1.0f } } };
-    return vmulq_f32(Q, NegativeOne3.v);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 NegativeOne3 = { { { -1.0f, -1.0f, -1.0f, 1.0f } } };
-    return _mm_mul_ps(Q, NegativeOne3);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionInverse(FXMVECTOR Q) noexcept
-{
-    XMVECTOR L = XMVector4LengthSq(Q);
-    XMVECTOR Conjugate = XMQuaternionConjugate(Q);
-
-    XMVECTOR Control = XMVectorLessOrEqual(L, g_XMEpsilon.v);
-
-    XMVECTOR Result = XMVectorDivide(Conjugate, L);
-
-    Result = XMVectorSelect(Result, g_XMZero, Control);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionLn(FXMVECTOR Q) noexcept
-{
-    static const XMVECTORF32 OneMinusEpsilon = { { { 1.0f - 0.00001f, 1.0f - 0.00001f, 1.0f - 0.00001f, 1.0f - 0.00001f } } };
-
-    XMVECTOR QW = XMVectorSplatW(Q);
-    XMVECTOR Q0 = XMVectorSelect(g_XMSelect1110.v, Q, g_XMSelect1110.v);
-
-    XMVECTOR ControlW = XMVectorInBounds(QW, OneMinusEpsilon.v);
-
-    XMVECTOR Theta = XMVectorACos(QW);
-    XMVECTOR SinTheta = XMVectorSin(Theta);
-
-    XMVECTOR S = XMVectorDivide(Theta, SinTheta);
-
-    XMVECTOR Result = XMVectorMultiply(Q0, S);
-    Result = XMVectorSelect(Q0, Result, ControlW);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionExp(FXMVECTOR Q) noexcept
-{
-    XMVECTOR Theta = XMVector3Length(Q);
-
-    XMVECTOR SinTheta, CosTheta;
-    XMVectorSinCos(&SinTheta, &CosTheta, Theta);
-
-    XMVECTOR S = XMVectorDivide(SinTheta, Theta);
-
-    XMVECTOR Result = XMVectorMultiply(Q, S);
-
-    const XMVECTOR Zero = XMVectorZero();
-    XMVECTOR Control = XMVectorNearEqual(Theta, Zero, g_XMEpsilon.v);
-    Result = XMVectorSelect(Result, Q, Control);
-
-    Result = XMVectorSelect(CosTheta, Result, g_XMSelect1110.v);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionSlerp
-        (
-                FXMVECTOR Q0,
-                FXMVECTOR Q1,
-                float    t
-        ) noexcept
-{
-    XMVECTOR T = XMVectorReplicate(t);
-    return XMQuaternionSlerpV(Q0, Q1, T);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionSlerpV
-        (
-                FXMVECTOR Q0,
-                FXMVECTOR Q1,
-                FXMVECTOR T
-        ) noexcept
-{
-    assert((XMVectorGetY(T) == XMVectorGetX(T)) && (XMVectorGetZ(T) == XMVectorGetX(T)) && (XMVectorGetW(T) == XMVectorGetX(T)));
-
-    // Result = Q0 * sin((1.0 - t) * Omega) / sin(Omega) + Q1 * sin(t * Omega) / sin(Omega)
-
-#if defined(_XM_NO_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-
-    const XMVECTORF32 OneMinusEpsilon = { { { 1.0f - 0.00001f, 1.0f - 0.00001f, 1.0f - 0.00001f, 1.0f - 0.00001f } } };
-
-    XMVECTOR CosOmega = XMQuaternionDot(Q0, Q1);
-
-    const XMVECTOR Zero = XMVectorZero();
-    XMVECTOR Control = XMVectorLess(CosOmega, Zero);
-    XMVECTOR Sign = XMVectorSelect(g_XMOne.v, g_XMNegativeOne.v, Control);
-
-    CosOmega = XMVectorMultiply(CosOmega, Sign);
-
-    Control = XMVectorLess(CosOmega, OneMinusEpsilon);
-
-    XMVECTOR SinOmega = XMVectorNegativeMultiplySubtract(CosOmega, CosOmega, g_XMOne.v);
-    SinOmega = XMVectorSqrt(SinOmega);
-
-    XMVECTOR Omega = XMVectorATan2(SinOmega, CosOmega);
-
-    XMVECTOR SignMask = XMVectorSplatSignMask();
-    XMVECTOR V01 = XMVectorShiftLeft(T, Zero, 2);
-    SignMask = XMVectorShiftLeft(SignMask, Zero, 3);
-    V01 = XMVectorXorInt(V01, SignMask);
-    V01 = XMVectorAdd(g_XMIdentityR0.v, V01);
-
-    XMVECTOR InvSinOmega = XMVectorReciprocal(SinOmega);
-
-    XMVECTOR S0 = XMVectorMultiply(V01, Omega);
-    S0 = XMVectorSin(S0);
-    S0 = XMVectorMultiply(S0, InvSinOmega);
-
-    S0 = XMVectorSelect(V01, S0, Control);
-
-    XMVECTOR S1 = XMVectorSplatY(S0);
-    S0 = XMVectorSplatX(S0);
-
-    S1 = XMVectorMultiply(S1, Sign);
-
-    XMVECTOR Result = XMVectorMultiply(Q0, S0);
-    Result = XMVectorMultiplyAdd(Q1, S1, Result);
-
-    return Result;
-
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 OneMinusEpsilon = { { { 1.0f - 0.00001f, 1.0f - 0.00001f, 1.0f - 0.00001f, 1.0f - 0.00001f } } };
-    static const XMVECTORU32 SignMask2 = { { { 0x80000000, 0x00000000, 0x00000000, 0x00000000 } } };
-
-    XMVECTOR CosOmega = XMQuaternionDot(Q0, Q1);
-
-    const XMVECTOR Zero = XMVectorZero();
-    XMVECTOR Control = XMVectorLess(CosOmega, Zero);
-    XMVECTOR Sign = XMVectorSelect(g_XMOne, g_XMNegativeOne, Control);
-
-    CosOmega = _mm_mul_ps(CosOmega, Sign);
-
-    Control = XMVectorLess(CosOmega, OneMinusEpsilon);
-
-    XMVECTOR SinOmega = _mm_mul_ps(CosOmega, CosOmega);
-    SinOmega = _mm_sub_ps(g_XMOne, SinOmega);
-    SinOmega = _mm_sqrt_ps(SinOmega);
-
-    XMVECTOR Omega = XMVectorATan2(SinOmega, CosOmega);
-
-    XMVECTOR V01 = XM_PERMUTE_PS(T, _MM_SHUFFLE(2, 3, 0, 1));
-    V01 = _mm_and_ps(V01, g_XMMaskXY);
-    V01 = _mm_xor_ps(V01, SignMask2);
-    V01 = _mm_add_ps(g_XMIdentityR0, V01);
-
-    XMVECTOR S0 = _mm_mul_ps(V01, Omega);
-    S0 = XMVectorSin(S0);
-    S0 = _mm_div_ps(S0, SinOmega);
-
-    S0 = XMVectorSelect(V01, S0, Control);
-
-    XMVECTOR S1 = XMVectorSplatY(S0);
-    S0 = XMVectorSplatX(S0);
-
-    S1 = _mm_mul_ps(S1, Sign);
-    XMVECTOR Result = _mm_mul_ps(Q0, S0);
-    S1 = _mm_mul_ps(S1, Q1);
-    Result = _mm_add_ps(Result, S1);
-    return Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionSquad
-        (
-                FXMVECTOR Q0,
-                FXMVECTOR Q1,
-                FXMVECTOR Q2,
-                GXMVECTOR Q3,
-                float    t
-        ) noexcept
-{
-    XMVECTOR T = XMVectorReplicate(t);
-    return XMQuaternionSquadV(Q0, Q1, Q2, Q3, T);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionSquadV
-        (
-                FXMVECTOR Q0,
-                FXMVECTOR Q1,
-                FXMVECTOR Q2,
-                GXMVECTOR Q3,
-                HXMVECTOR T
-        ) noexcept
-{
-    assert((XMVectorGetY(T) == XMVectorGetX(T)) && (XMVectorGetZ(T) == XMVectorGetX(T)) && (XMVectorGetW(T) == XMVectorGetX(T)));
-
-    XMVECTOR TP = T;
-    const XMVECTOR Two = XMVectorSplatConstant(2, 0);
-
-    XMVECTOR Q03 = XMQuaternionSlerpV(Q0, Q3, T);
-    XMVECTOR Q12 = XMQuaternionSlerpV(Q1, Q2, T);
-
-    TP = XMVectorNegativeMultiplySubtract(TP, TP, TP);
-    TP = XMVectorMultiply(TP, Two);
-
-    XMVECTOR Result = XMQuaternionSlerpV(Q03, Q12, TP);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMQuaternionSquadSetup
-        (
-                XMVECTOR* pA,
-                XMVECTOR* pB,
-                XMVECTOR* pC,
-                FXMVECTOR  Q0,
-                FXMVECTOR  Q1,
-                FXMVECTOR  Q2,
-                GXMVECTOR  Q3
-        ) noexcept
-{
-    assert(pA);
-    assert(pB);
-    assert(pC);
-
-    XMVECTOR LS12 = XMQuaternionLengthSq(XMVectorAdd(Q1, Q2));
-    XMVECTOR LD12 = XMQuaternionLengthSq(XMVectorSubtract(Q1, Q2));
-    XMVECTOR SQ2 = XMVectorNegate(Q2);
-
-    XMVECTOR Control1 = XMVectorLess(LS12, LD12);
-    SQ2 = XMVectorSelect(Q2, SQ2, Control1);
-
-    XMVECTOR LS01 = XMQuaternionLengthSq(XMVectorAdd(Q0, Q1));
-    XMVECTOR LD01 = XMQuaternionLengthSq(XMVectorSubtract(Q0, Q1));
-    XMVECTOR SQ0 = XMVectorNegate(Q0);
-
-    XMVECTOR LS23 = XMQuaternionLengthSq(XMVectorAdd(SQ2, Q3));
-    XMVECTOR LD23 = XMQuaternionLengthSq(XMVectorSubtract(SQ2, Q3));
-    XMVECTOR SQ3 = XMVectorNegate(Q3);
-
-    XMVECTOR Control0 = XMVectorLess(LS01, LD01);
-    XMVECTOR Control2 = XMVectorLess(LS23, LD23);
-
-    SQ0 = XMVectorSelect(Q0, SQ0, Control0);
-    SQ3 = XMVectorSelect(Q3, SQ3, Control2);
-
-    XMVECTOR InvQ1 = XMQuaternionInverse(Q1);
-    XMVECTOR InvQ2 = XMQuaternionInverse(SQ2);
-
-    XMVECTOR LnQ0 = XMQuaternionLn(XMQuaternionMultiply(InvQ1, SQ0));
-    XMVECTOR LnQ2 = XMQuaternionLn(XMQuaternionMultiply(InvQ1, SQ2));
-    XMVECTOR LnQ1 = XMQuaternionLn(XMQuaternionMultiply(InvQ2, Q1));
-    XMVECTOR LnQ3 = XMQuaternionLn(XMQuaternionMultiply(InvQ2, SQ3));
-
-    const XMVECTOR NegativeOneQuarter = XMVectorSplatConstant(-1, 2);
-
-    XMVECTOR ExpQ02 = XMVectorMultiply(XMVectorAdd(LnQ0, LnQ2), NegativeOneQuarter);
-    XMVECTOR ExpQ13 = XMVectorMultiply(XMVectorAdd(LnQ1, LnQ3), NegativeOneQuarter);
-    ExpQ02 = XMQuaternionExp(ExpQ02);
-    ExpQ13 = XMQuaternionExp(ExpQ13);
-
-    *pA = XMQuaternionMultiply(Q1, ExpQ02);
-    *pB = XMQuaternionMultiply(SQ2, ExpQ13);
-    *pC = SQ2;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionBaryCentric
-        (
-                FXMVECTOR Q0,
-                FXMVECTOR Q1,
-                FXMVECTOR Q2,
-                float    f,
-                float    g
-        ) noexcept
-{
-    float s = f + g;
-
-    XMVECTOR Result;
-    if ((s < 0.00001f) && (s > -0.00001f))
-    {
-        Result = Q0;
-    }
-    else
-    {
-        XMVECTOR Q01 = XMQuaternionSlerp(Q0, Q1, s);
-        XMVECTOR Q02 = XMQuaternionSlerp(Q0, Q2, s);
-
-        Result = XMQuaternionSlerp(Q01, Q02, g / s);
-    }
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionBaryCentricV
-        (
-                FXMVECTOR Q0,
-                FXMVECTOR Q1,
-                FXMVECTOR Q2,
-                GXMVECTOR F,
-                HXMVECTOR G
-        ) noexcept
-{
-    assert((XMVectorGetY(F) == XMVectorGetX(F)) && (XMVectorGetZ(F) == XMVectorGetX(F)) && (XMVectorGetW(F) == XMVectorGetX(F)));
-    assert((XMVectorGetY(G) == XMVectorGetX(G)) && (XMVectorGetZ(G) == XMVectorGetX(G)) && (XMVectorGetW(G) == XMVectorGetX(G)));
-
-    const XMVECTOR Epsilon = XMVectorSplatConstant(1, 16);
-
-    XMVECTOR S = XMVectorAdd(F, G);
-
-    XMVECTOR Result;
-    if (XMVector4InBounds(S, Epsilon))
-    {
-        Result = Q0;
-    }
-    else
-    {
-        XMVECTOR Q01 = XMQuaternionSlerpV(Q0, Q1, S);
-        XMVECTOR Q02 = XMQuaternionSlerpV(Q0, Q2, S);
-        XMVECTOR GS = XMVectorReciprocal(S);
-        GS = XMVectorMultiply(G, GS);
-
-        Result = XMQuaternionSlerpV(Q01, Q02, GS);
-    }
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-// Transformation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionIdentity() noexcept
-{
-    return g_XMIdentityR3.v;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionRotationRollPitchYaw
-        (
-                float Pitch,
-                float Yaw,
-                float Roll
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    const float halfpitch = Pitch * 0.5f;
-    float cp = cosf(halfpitch);
-    float sp = sinf(halfpitch);
-
-    const float halfyaw = Yaw * 0.5f;
-    float cy = cosf(halfyaw);
-    float sy = sinf(halfyaw);
-
-    const float halfroll = Roll * 0.5f;
-    float cr = cosf(halfroll);
-    float sr = sinf(halfroll);
-
-    XMVECTORF32 vResult = { { {
-            cr * sp * cy + sr * cp * sy,
-            cr * cp * sy - sr * sp * cy,
-            sr * cp * cy - cr * sp * sy,
-            cr * cp * cy + sr * sp * sy
-        } } };
-    return vResult;
-#else
-    XMVECTOR Angles = XMVectorSet(Pitch, Yaw, Roll, 0.0f);
-    return XMQuaternionRotationRollPitchYawFromVector(Angles);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionRotationRollPitchYawFromVector
-        (
-                FXMVECTOR Angles // <Pitch, Yaw, Roll, 0>
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    const float halfpitch = Angles.vector4_f32[0] * 0.5f;
-    float cp = cosf(halfpitch);
-    float sp = sinf(halfpitch);
-
-    const float halfyaw = Angles.vector4_f32[1] * 0.5f;
-    float cy = cosf(halfyaw);
-    float sy = sinf(halfyaw);
-
-    const float halfroll = Angles.vector4_f32[2] * 0.5f;
-    float cr = cosf(halfroll);
-    float sr = sinf(halfroll);
-
-    XMVECTORF32 vResult = { { {
-            cr * sp * cy + sr * cp * sy,
-            cr * cp * sy - sr * sp * cy,
-            sr * cp * cy - cr * sp * sy,
-            cr * cp * cy + sr * sp * sy
-        } } };
-    return vResult;
-#else
-    static const XMVECTORF32  Sign = { { { 1.0f, -1.0f, -1.0f, 1.0f } } };
-
-    XMVECTOR HalfAngles = XMVectorMultiply(Angles, g_XMOneHalf.v);
-
-    XMVECTOR SinAngles, CosAngles;
-    XMVectorSinCos(&SinAngles, &CosAngles, HalfAngles);
-
-    XMVECTOR P0 = XMVectorPermute<XM_PERMUTE_0X, XM_PERMUTE_1X, XM_PERMUTE_1X, XM_PERMUTE_1X>(SinAngles, CosAngles);
-    XMVECTOR Y0 = XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0Y, XM_PERMUTE_1Y, XM_PERMUTE_1Y>(SinAngles, CosAngles);
-    XMVECTOR R0 = XMVectorPermute<XM_PERMUTE_1Z, XM_PERMUTE_1Z, XM_PERMUTE_0Z, XM_PERMUTE_1Z>(SinAngles, CosAngles);
-    XMVECTOR P1 = XMVectorPermute<XM_PERMUTE_0X, XM_PERMUTE_1X, XM_PERMUTE_1X, XM_PERMUTE_1X>(CosAngles, SinAngles);
-    XMVECTOR Y1 = XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0Y, XM_PERMUTE_1Y, XM_PERMUTE_1Y>(CosAngles, SinAngles);
-    XMVECTOR R1 = XMVectorPermute<XM_PERMUTE_1Z, XM_PERMUTE_1Z, XM_PERMUTE_0Z, XM_PERMUTE_1Z>(CosAngles, SinAngles);
-
-    XMVECTOR Q1 = XMVectorMultiply(P1, Sign.v);
-    XMVECTOR Q0 = XMVectorMultiply(P0, Y0);
-    Q1 = XMVectorMultiply(Q1, Y1);
-    Q0 = XMVectorMultiply(Q0, R0);
-    XMVECTOR Q = XMVectorMultiplyAdd(Q1, R1, Q0);
-
-    return Q;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionRotationNormal
-        (
-                FXMVECTOR NormalAxis,
-                float    Angle
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-
-    XMVECTOR N = XMVectorSelect(g_XMOne.v, NormalAxis, g_XMSelect1110.v);
-
-    float SinV, CosV;
-    XMScalarSinCos(&SinV, &CosV, 0.5f * Angle);
-
-    XMVECTOR Scale = XMVectorSet(SinV, SinV, SinV, CosV);
-    return XMVectorMultiply(N, Scale);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR N = _mm_and_ps(NormalAxis, g_XMMask3);
-    N = _mm_or_ps(N, g_XMIdentityR3);
-    XMVECTOR Scale = _mm_set_ps1(0.5f * Angle);
-    XMVECTOR vSine;
-    XMVECTOR vCosine;
-    XMVectorSinCos(&vSine, &vCosine, Scale);
-    Scale = _mm_and_ps(vSine, g_XMMask3);
-    vCosine = _mm_and_ps(vCosine, g_XMMaskW);
-    Scale = _mm_or_ps(Scale, vCosine);
-    N = _mm_mul_ps(N, Scale);
-    return N;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionRotationAxis
-        (
-                FXMVECTOR Axis,
-                float    Angle
-        ) noexcept
-{
-    assert(!XMVector3Equal(Axis, XMVectorZero()));
-    assert(!XMVector3IsInfinite(Axis));
-
-    XMVECTOR Normal = XMVector3Normalize(Axis);
-    XMVECTOR Q = XMQuaternionRotationNormal(Normal, Angle);
-    return Q;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMQuaternionRotationMatrix(FXMMATRIX M) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 q;
-    float r22 = M.m[2][2];
-    if (r22 <= 0.f)  // x^2 + y^2 >= z^2 + w^2
-    {
-        float dif10 = M.m[1][1] - M.m[0][0];
-        float omr22 = 1.f - r22;
-        if (dif10 <= 0.f)  // x^2 >= y^2
-        {
-            float fourXSqr = omr22 - dif10;
-            float inv4x = 0.5f / sqrtf(fourXSqr);
-            q.f[0] = fourXSqr * inv4x;
-            q.f[1] = (M.m[0][1] + M.m[1][0]) * inv4x;
-            q.f[2] = (M.m[0][2] + M.m[2][0]) * inv4x;
-            q.f[3] = (M.m[1][2] - M.m[2][1]) * inv4x;
-        }
-        else  // y^2 >= x^2
-        {
-            float fourYSqr = omr22 + dif10;
-            float inv4y = 0.5f / sqrtf(fourYSqr);
-            q.f[0] = (M.m[0][1] + M.m[1][0]) * inv4y;
-            q.f[1] = fourYSqr * inv4y;
-            q.f[2] = (M.m[1][2] + M.m[2][1]) * inv4y;
-            q.f[3] = (M.m[2][0] - M.m[0][2]) * inv4y;
-        }
-    }
-    else  // z^2 + w^2 >= x^2 + y^2
-    {
-        float sum10 = M.m[1][1] + M.m[0][0];
-        float opr22 = 1.f + r22;
-        if (sum10 <= 0.f)  // z^2 >= w^2
-        {
-            float fourZSqr = opr22 - sum10;
-            float inv4z = 0.5f / sqrtf(fourZSqr);
-            q.f[0] = (M.m[0][2] + M.m[2][0]) * inv4z;
-            q.f[1] = (M.m[1][2] + M.m[2][1]) * inv4z;
-            q.f[2] = fourZSqr * inv4z;
-            q.f[3] = (M.m[0][1] - M.m[1][0]) * inv4z;
-        }
-        else  // w^2 >= z^2
-        {
-            float fourWSqr = opr22 + sum10;
-            float inv4w = 0.5f / sqrtf(fourWSqr);
-            q.f[0] = (M.m[1][2] - M.m[2][1]) * inv4w;
-            q.f[1] = (M.m[2][0] - M.m[0][2]) * inv4w;
-            q.f[2] = (M.m[0][1] - M.m[1][0]) * inv4w;
-            q.f[3] = fourWSqr * inv4w;
-        }
-    }
-    return q.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 XMPMMP = { { { +1.0f, -1.0f, -1.0f, +1.0f } } };
-    static const XMVECTORF32 XMMPMP = { { { -1.0f, +1.0f, -1.0f, +1.0f } } };
-    static const XMVECTORF32 XMMMPP = { { { -1.0f, -1.0f, +1.0f, +1.0f } } };
-    static const XMVECTORU32 Select0110 = { { { XM_SELECT_0, XM_SELECT_1, XM_SELECT_1, XM_SELECT_0 } } };
-    static const XMVECTORU32 Select0010 = { { { XM_SELECT_0, XM_SELECT_0, XM_SELECT_1, XM_SELECT_0 } } };
-
-    float32x4_t r0 = M.r[0];
-    float32x4_t r1 = M.r[1];
-    float32x4_t r2 = M.r[2];
-
-    float32x4_t r00 = vdupq_lane_f32(vget_low_f32(r0), 0);
-    float32x4_t r11 = vdupq_lane_f32(vget_low_f32(r1), 1);
-    float32x4_t r22 = vdupq_lane_f32(vget_high_f32(r2), 0);
-
-    // x^2 >= y^2 equivalent to r11 - r00 <= 0
-    float32x4_t r11mr00 = vsubq_f32(r11, r00);
-    uint32x4_t x2gey2 = vcleq_f32(r11mr00, g_XMZero);
-
-    // z^2 >= w^2 equivalent to r11 + r00 <= 0
-    float32x4_t r11pr00 = vaddq_f32(r11, r00);
-    uint32x4_t z2gew2 = vcleq_f32(r11pr00, g_XMZero);
-
-    // x^2 + y^2 >= z^2 + w^2 equivalent to r22 <= 0
-    uint32x4_t x2py2gez2pw2 = vcleq_f32(r22, g_XMZero);
-
-    // (4*x^2, 4*y^2, 4*z^2, 4*w^2)
-    float32x4_t t0 = vmulq_f32(XMPMMP, r00);
-    float32x4_t x2y2z2w2 = vmlaq_f32(t0, XMMPMP, r11);
-    x2y2z2w2 = vmlaq_f32(x2y2z2w2, XMMMPP, r22);
-    x2y2z2w2 = vaddq_f32(x2y2z2w2, g_XMOne);
-
-    // (r01, r02, r12, r11)
-    t0 = vextq_f32(r0, r0, 1);
-    float32x4_t t1 = vextq_f32(r1, r1, 1);
-    t0 = vcombine_f32(vget_low_f32(t0), vrev64_f32(vget_low_f32(t1)));
-
-    // (r10, r20, r21, r10)
-    t1 = vextq_f32(r2, r2, 3);
-    float32x4_t r10 = vdupq_lane_f32(vget_low_f32(r1), 0);
-    t1 = vbslq_f32(Select0110, t1, r10);
-
-    // (4*x*y, 4*x*z, 4*y*z, unused)
-    float32x4_t xyxzyz = vaddq_f32(t0, t1);
-
-    // (r21, r20, r10, r10)
-    t0 = vcombine_f32(vrev64_f32(vget_low_f32(r2)), vget_low_f32(r10));
-
-    // (r12, r02, r01, r12)
-    float32x4_t t2 = vcombine_f32(vrev64_f32(vget_high_f32(r0)), vrev64_f32(vget_low_f32(r0)));
-    float32x4_t t3 = vdupq_lane_f32(vget_high_f32(r1), 0);
-    t1 = vbslq_f32(Select0110, t2, t3);
-
-    // (4*x*w, 4*y*w, 4*z*w, unused)
-    float32x4_t xwywzw = vsubq_f32(t0, t1);
-    xwywzw = vmulq_f32(XMMPMP, xwywzw);
-
-    // (4*x*x, 4*x*y, 4*x*z, 4*x*w)
-    t0 = vextq_f32(xyxzyz, xyxzyz, 3);
-    t1 = vbslq_f32(Select0110, t0, x2y2z2w2);
-    t2 = vdupq_lane_f32(vget_low_f32(xwywzw), 0);
-    float32x4_t tensor0 = vbslq_f32(g_XMSelect1110, t1, t2);
-
-    // (4*y*x, 4*y*y, 4*y*z, 4*y*w)
-    t0 = vbslq_f32(g_XMSelect1011, xyxzyz, x2y2z2w2);
-    t1 = vdupq_lane_f32(vget_low_f32(xwywzw), 1);
-    float32x4_t tensor1 = vbslq_f32(g_XMSelect1110, t0, t1);
-
-    // (4*z*x, 4*z*y, 4*z*z, 4*z*w)
-    t0 = vextq_f32(xyxzyz, xyxzyz, 1);
-    t1 = vcombine_f32(vget_low_f32(t0), vrev64_f32(vget_high_f32(xwywzw)));
-    float32x4_t tensor2 = vbslq_f32(Select0010, x2y2z2w2, t1);
-
-    // (4*w*x, 4*w*y, 4*w*z, 4*w*w)
-    float32x4_t tensor3 = vbslq_f32(g_XMSelect1110, xwywzw, x2y2z2w2);
-
-    // Select the row of the tensor-product matrix that has the largest
-    // magnitude.
-    t0 = vbslq_f32(x2gey2, tensor0, tensor1);
-    t1 = vbslq_f32(z2gew2, tensor2, tensor3);
-    t2 = vbslq_f32(x2py2gez2pw2, t0, t1);
-
-    // Normalize the row.  No division by zero is possible because the
-    // quaternion is unit-length (and the row is a nonzero multiple of
-    // the quaternion).
-    t0 = XMVector4Length(t2);
-    return XMVectorDivide(t2, t0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 XMPMMP = { { { +1.0f, -1.0f, -1.0f, +1.0f } } };
-    static const XMVECTORF32 XMMPMP = { { { -1.0f, +1.0f, -1.0f, +1.0f } } };
-    static const XMVECTORF32 XMMMPP = { { { -1.0f, -1.0f, +1.0f, +1.0f } } };
-
-    XMVECTOR r0 = M.r[0];  // (r00, r01, r02, 0)
-    XMVECTOR r1 = M.r[1];  // (r10, r11, r12, 0)
-    XMVECTOR r2 = M.r[2];  // (r20, r21, r22, 0)
-
-    // (r00, r00, r00, r00)
-    XMVECTOR r00 = XM_PERMUTE_PS(r0, _MM_SHUFFLE(0, 0, 0, 0));
-    // (r11, r11, r11, r11)
-    XMVECTOR r11 = XM_PERMUTE_PS(r1, _MM_SHUFFLE(1, 1, 1, 1));
-    // (r22, r22, r22, r22)
-    XMVECTOR r22 = XM_PERMUTE_PS(r2, _MM_SHUFFLE(2, 2, 2, 2));
-
-    // x^2 >= y^2 equivalent to r11 - r00 <= 0
-    // (r11 - r00, r11 - r00, r11 - r00, r11 - r00)
-    XMVECTOR r11mr00 = _mm_sub_ps(r11, r00);
-    XMVECTOR x2gey2 = _mm_cmple_ps(r11mr00, g_XMZero);
-
-    // z^2 >= w^2 equivalent to r11 + r00 <= 0
-    // (r11 + r00, r11 + r00, r11 + r00, r11 + r00)
-    XMVECTOR r11pr00 = _mm_add_ps(r11, r00);
-    XMVECTOR z2gew2 = _mm_cmple_ps(r11pr00, g_XMZero);
-
-    // x^2 + y^2 >= z^2 + w^2 equivalent to r22 <= 0
-    XMVECTOR x2py2gez2pw2 = _mm_cmple_ps(r22, g_XMZero);
-
-    // (4*x^2, 4*y^2, 4*z^2, 4*w^2)
-    XMVECTOR t0 = XM_FMADD_PS(XMPMMP, r00, g_XMOne);
-    XMVECTOR t1 = _mm_mul_ps(XMMPMP, r11);
-    XMVECTOR t2 = XM_FMADD_PS(XMMMPP, r22, t0);
-    XMVECTOR x2y2z2w2 = _mm_add_ps(t1, t2);
-
-    // (r01, r02, r12, r11)
-    t0 = _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(1, 2, 2, 1));
-    // (r10, r10, r20, r21)
-    t1 = _mm_shuffle_ps(r1, r2, _MM_SHUFFLE(1, 0, 0, 0));
-    // (r10, r20, r21, r10)
-    t1 = XM_PERMUTE_PS(t1, _MM_SHUFFLE(1, 3, 2, 0));
-    // (4*x*y, 4*x*z, 4*y*z, unused)
-    XMVECTOR xyxzyz = _mm_add_ps(t0, t1);
-
-    // (r21, r20, r10, r10)
-    t0 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(0, 0, 0, 1));
-    // (r12, r12, r02, r01)
-    t1 = _mm_shuffle_ps(r1, r0, _MM_SHUFFLE(1, 2, 2, 2));
-    // (r12, r02, r01, r12)
-    t1 = XM_PERMUTE_PS(t1, _MM_SHUFFLE(1, 3, 2, 0));
-    // (4*x*w, 4*y*w, 4*z*w, unused)
-    XMVECTOR xwywzw = _mm_sub_ps(t0, t1);
-    xwywzw = _mm_mul_ps(XMMPMP, xwywzw);
-
-    // (4*x^2, 4*y^2, 4*x*y, unused)
-    t0 = _mm_shuffle_ps(x2y2z2w2, xyxzyz, _MM_SHUFFLE(0, 0, 1, 0));
-    // (4*z^2, 4*w^2, 4*z*w, unused)
-    t1 = _mm_shuffle_ps(x2y2z2w2, xwywzw, _MM_SHUFFLE(0, 2, 3, 2));
-    // (4*x*z, 4*y*z, 4*x*w, 4*y*w)
-    t2 = _mm_shuffle_ps(xyxzyz, xwywzw, _MM_SHUFFLE(1, 0, 2, 1));
-
-    // (4*x*x, 4*x*y, 4*x*z, 4*x*w)
-    XMVECTOR tensor0 = _mm_shuffle_ps(t0, t2, _MM_SHUFFLE(2, 0, 2, 0));
-    // (4*y*x, 4*y*y, 4*y*z, 4*y*w)
-    XMVECTOR tensor1 = _mm_shuffle_ps(t0, t2, _MM_SHUFFLE(3, 1, 1, 2));
-    // (4*z*x, 4*z*y, 4*z*z, 4*z*w)
-    XMVECTOR tensor2 = _mm_shuffle_ps(t2, t1, _MM_SHUFFLE(2, 0, 1, 0));
-    // (4*w*x, 4*w*y, 4*w*z, 4*w*w)
-    XMVECTOR tensor3 = _mm_shuffle_ps(t2, t1, _MM_SHUFFLE(1, 2, 3, 2));
-
-    // Select the row of the tensor-product matrix that has the largest
-    // magnitude.
-    t0 = _mm_and_ps(x2gey2, tensor0);
-    t1 = _mm_andnot_ps(x2gey2, tensor1);
-    t0 = _mm_or_ps(t0, t1);
-    t1 = _mm_and_ps(z2gew2, tensor2);
-    t2 = _mm_andnot_ps(z2gew2, tensor3);
-    t1 = _mm_or_ps(t1, t2);
-    t0 = _mm_and_ps(x2py2gez2pw2, t0);
-    t1 = _mm_andnot_ps(x2py2gez2pw2, t1);
-    t2 = _mm_or_ps(t0, t1);
-
-    // Normalize the row.  No division by zero is possible because the
-    // quaternion is unit-length (and the row is a nonzero multiple of
-    // the quaternion).
-    t0 = XMVector4Length(t2);
-    return _mm_div_ps(t2, t0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Conversion operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMQuaternionToAxisAngle
-        (
-                XMVECTOR* pAxis,
-                float* pAngle,
-                FXMVECTOR  Q
-        ) noexcept
-{
-    assert(pAxis);
-    assert(pAngle);
-
-    *pAxis = Q;
-
-    *pAngle = 2.0f * XMScalarACos(XMVectorGetW(Q));
-}
-
-/****************************************************************************
- *
- * Plane
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-// Comparison operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMPlaneEqual
-        (
-                FXMVECTOR P1,
-                FXMVECTOR P2
-        ) noexcept
-{
-    return XMVector4Equal(P1, P2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMPlaneNearEqual
-        (
-                FXMVECTOR P1,
-                FXMVECTOR P2,
-                FXMVECTOR Epsilon
-        ) noexcept
-{
-    XMVECTOR NP1 = XMPlaneNormalize(P1);
-    XMVECTOR NP2 = XMPlaneNormalize(P2);
-    return XMVector4NearEqual(NP1, NP2, Epsilon);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMPlaneNotEqual
-        (
-                FXMVECTOR P1,
-                FXMVECTOR P2
-        ) noexcept
-{
-    return XMVector4NotEqual(P1, P2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMPlaneIsNaN(FXMVECTOR P) noexcept
-{
-    return XMVector4IsNaN(P);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMPlaneIsInfinite(FXMVECTOR P) noexcept
-{
-    return XMVector4IsInfinite(P);
-}
-
-//------------------------------------------------------------------------------
-// Computation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMPlaneDot
-        (
-                FXMVECTOR P,
-                FXMVECTOR V
-        ) noexcept
-{
-    return XMVector4Dot(P, V);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMPlaneDotCoord
-        (
-                FXMVECTOR P,
-                FXMVECTOR V
-        ) noexcept
-{
-    // Result = P[0] * V[0] + P[1] * V[1] + P[2] * V[2] + P[3]
-
-    XMVECTOR V3 = XMVectorSelect(g_XMOne.v, V, g_XMSelect1110.v);
-    XMVECTOR Result = XMVector4Dot(P, V3);
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMPlaneDotNormal
-        (
-                FXMVECTOR P,
-                FXMVECTOR V
-        ) noexcept
-{
-    return XMVector3Dot(P, V);
-}
-
-//------------------------------------------------------------------------------
-// XMPlaneNormalizeEst uses a reciprocal estimate and
-// returns QNaN on zero and infinite vectors.
-
-inline XMVECTOR XM_CALLCONV XMPlaneNormalizeEst(FXMVECTOR P) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-
-    XMVECTOR Result = XMVector3ReciprocalLengthEst(P);
-    return XMVectorMultiply(P, Result);
-
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(P, P, 0x7f);
-    XMVECTOR vResult = _mm_rsqrt_ps(vTemp);
-    return _mm_mul_ps(vResult, P);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product
-    XMVECTOR vDot = _mm_mul_ps(P, P);
-    // x=Dot.y, y=Dot.z
-    XMVECTOR vTemp = XM_PERMUTE_PS(vDot, _MM_SHUFFLE(2, 1, 2, 1));
-    // Result.x = x+y
-    vDot = _mm_add_ss(vDot, vTemp);
-    // x=Dot.z
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(1, 1, 1, 1));
-    // Result.x = (x+y)+z
-    vDot = _mm_add_ss(vDot, vTemp);
-    // Splat x
-    vDot = XM_PERMUTE_PS(vDot, _MM_SHUFFLE(0, 0, 0, 0));
-    // Get the reciprocal
-    vDot = _mm_rsqrt_ps(vDot);
-    // Get the reciprocal
-    vDot = _mm_mul_ps(vDot, P);
-    return vDot;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMPlaneNormalize(FXMVECTOR P) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float fLengthSq = sqrtf((P.vector4_f32[0] * P.vector4_f32[0]) + (P.vector4_f32[1] * P.vector4_f32[1]) + (P.vector4_f32[2] * P.vector4_f32[2]));
-    // Prevent divide by zero
-    if (fLengthSq > 0)
-    {
-        fLengthSq = 1.0f / fLengthSq;
-    }
-    XMVECTORF32 vResult = { { {
-            P.vector4_f32[0] * fLengthSq,
-            P.vector4_f32[1] * fLengthSq,
-            P.vector4_f32[2] * fLengthSq,
-            P.vector4_f32[3] * fLengthSq
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR vLength = XMVector3ReciprocalLength(P);
-    return XMVectorMultiply(P, vLength);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_dp_ps(P, P, 0x7f);
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Reciprocal mul to perform the normalization
-    vResult = _mm_div_ps(P, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vLengthSq);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y and z only
-    XMVECTOR vLengthSq = _mm_mul_ps(P, P);
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(2, 1, 2, 1));
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(1, 1, 1, 1));
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Reciprocal mul to perform the normalization
-    vResult = _mm_div_ps(P, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vLengthSq);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMPlaneIntersectLine
-        (
-                FXMVECTOR P,
-                FXMVECTOR LinePoint1,
-                FXMVECTOR LinePoint2
-        ) noexcept
-{
-    XMVECTOR V1 = XMVector3Dot(P, LinePoint1);
-    XMVECTOR V2 = XMVector3Dot(P, LinePoint2);
-    XMVECTOR D = XMVectorSubtract(V1, V2);
-
-    XMVECTOR VT = XMPlaneDotCoord(P, LinePoint1);
-    VT = XMVectorDivide(VT, D);
-
-    XMVECTOR Point = XMVectorSubtract(LinePoint2, LinePoint1);
-    Point = XMVectorMultiplyAdd(Point, VT, LinePoint1);
-
-    const XMVECTOR Zero = XMVectorZero();
-    XMVECTOR Control = XMVectorNearEqual(D, Zero, g_XMEpsilon.v);
-
-    return XMVectorSelect(Point, g_XMQNaN.v, Control);
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMPlaneIntersectPlane
-        (
-                XMVECTOR* pLinePoint1,
-                XMVECTOR* pLinePoint2,
-                FXMVECTOR  P1,
-                FXMVECTOR  P2
-        ) noexcept
-{
-    assert(pLinePoint1);
-    assert(pLinePoint2);
-
-    XMVECTOR V1 = XMVector3Cross(P2, P1);
-
-    XMVECTOR LengthSq = XMVector3LengthSq(V1);
-
-    XMVECTOR V2 = XMVector3Cross(P2, V1);
-
-    XMVECTOR P1W = XMVectorSplatW(P1);
-    XMVECTOR Point = XMVectorMultiply(V2, P1W);
-
-    XMVECTOR V3 = XMVector3Cross(V1, P1);
-
-    XMVECTOR P2W = XMVectorSplatW(P2);
-    Point = XMVectorMultiplyAdd(V3, P2W, Point);
-
-    XMVECTOR LinePoint1 = XMVectorDivide(Point, LengthSq);
-
-    XMVECTOR LinePoint2 = XMVectorAdd(LinePoint1, V1);
-
-    XMVECTOR Control = XMVectorLessOrEqual(LengthSq, g_XMEpsilon.v);
-    *pLinePoint1 = XMVectorSelect(LinePoint1, g_XMQNaN.v, Control);
-    *pLinePoint2 = XMVectorSelect(LinePoint2, g_XMQNaN.v, Control);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMPlaneTransform
-        (
-                FXMVECTOR P,
-                FXMMATRIX ITM
-        ) noexcept
-{
-    XMVECTOR W = XMVectorSplatW(P);
-    XMVECTOR Z = XMVectorSplatZ(P);
-    XMVECTOR Y = XMVectorSplatY(P);
-    XMVECTOR X = XMVectorSplatX(P);
-
-    XMVECTOR Result = XMVectorMultiply(W, ITM.r[3]);
-    Result = XMVectorMultiplyAdd(Z, ITM.r[2], Result);
-    Result = XMVectorMultiplyAdd(Y, ITM.r[1], Result);
-    Result = XMVectorMultiplyAdd(X, ITM.r[0], Result);
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMFLOAT4* XM_CALLCONV XMPlaneTransformStream
-        (
-                XMFLOAT4*       pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT4* pInputStream,
-                size_t          InputStride,
-                size_t          PlaneCount,
-                FXMMATRIX       ITM
-        ) noexcept
-{
-    return XMVector4TransformStream(pOutputStream,
-                                    OutputStride,
-                                    pInputStream,
-                                    InputStride,
-                                    PlaneCount,
-                                    ITM);
-}
-
-//------------------------------------------------------------------------------
-// Conversion operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMPlaneFromPointNormal
-        (
-                FXMVECTOR Point,
-                FXMVECTOR Normal
-        ) noexcept
-{
-    XMVECTOR W = XMVector3Dot(Point, Normal);
-    W = XMVectorNegate(W);
-    return XMVectorSelect(W, Normal, g_XMSelect1110.v);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMPlaneFromPoints
-        (
-                FXMVECTOR Point1,
-                FXMVECTOR Point2,
-                FXMVECTOR Point3
-        ) noexcept
-{
-    XMVECTOR V21 = XMVectorSubtract(Point1, Point2);
-    XMVECTOR V31 = XMVectorSubtract(Point1, Point3);
-
-    XMVECTOR N = XMVector3Cross(V21, V31);
-    N = XMVector3Normalize(N);
-
-    XMVECTOR D = XMPlaneDotNormal(N, Point1);
-    D = XMVectorNegate(D);
-
-    XMVECTOR Result = XMVectorSelect(D, N, g_XMSelect1110.v);
-
-    return Result;
-}
-
-/****************************************************************************
- *
- * Color
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-// Comparison operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMColorEqual
-        (
-                FXMVECTOR C1,
-                FXMVECTOR C2
-        ) noexcept
-{
-    return XMVector4Equal(C1, C2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMColorNotEqual
-        (
-                FXMVECTOR C1,
-                FXMVECTOR C2
-        ) noexcept
-{
-    return XMVector4NotEqual(C1, C2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMColorGreater
-        (
-                FXMVECTOR C1,
-                FXMVECTOR C2
-        ) noexcept
-{
-    return XMVector4Greater(C1, C2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMColorGreaterOrEqual
-        (
-                FXMVECTOR C1,
-                FXMVECTOR C2
-        ) noexcept
-{
-    return XMVector4GreaterOrEqual(C1, C2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMColorLess
-        (
-                FXMVECTOR C1,
-                FXMVECTOR C2
-        ) noexcept
-{
-    return XMVector4Less(C1, C2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMColorLessOrEqual
-        (
-                FXMVECTOR C1,
-                FXMVECTOR C2
-        ) noexcept
-{
-    return XMVector4LessOrEqual(C1, C2);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMColorIsNaN(FXMVECTOR C) noexcept
-{
-    return XMVector4IsNaN(C);
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMColorIsInfinite(FXMVECTOR C) noexcept
-{
-    return XMVector4IsInfinite(C);
-}
-
-//------------------------------------------------------------------------------
-// Computation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorNegative(FXMVECTOR vColor) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            1.0f - vColor.vector4_f32[0],
-            1.0f - vColor.vector4_f32[1],
-            1.0f - vColor.vector4_f32[2],
-            vColor.vector4_f32[3]
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vTemp = veorq_u32(vreinterpretq_u32_f32(vColor), g_XMNegate3);
-    return vaddq_f32(vreinterpretq_f32_u32(vTemp), g_XMOne3);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Negate only x,y and z.
-    XMVECTOR vTemp = _mm_xor_ps(vColor, g_XMNegate3);
-    // Add 1,1,1,0 to -x,-y,-z,w
-    return _mm_add_ps(vTemp, g_XMOne3);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorModulate
-        (
-                FXMVECTOR C1,
-                FXMVECTOR C2
-        ) noexcept
-{
-    return XMVectorMultiply(C1, C2);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorAdjustSaturation
-        (
-                FXMVECTOR vColor,
-                float    fSaturation
-        ) noexcept
-{
-    // Luminance = 0.2125f * C[0] + 0.7154f * C[1] + 0.0721f * C[2];
-    // Result = (C - Luminance) * Saturation + Luminance;
-
-    const XMVECTORF32 gvLuminance = { { { 0.2125f, 0.7154f, 0.0721f, 0.0f } } };
-#if defined(_XM_NO_INTRINSICS_)
-    float fLuminance = (vColor.vector4_f32[0] * gvLuminance.f[0]) + (vColor.vector4_f32[1] * gvLuminance.f[1]) + (vColor.vector4_f32[2] * gvLuminance.f[2]);
-    XMVECTOR vResult;
-    vResult.vector4_f32[0] = ((vColor.vector4_f32[0] - fLuminance) * fSaturation) + fLuminance;
-    vResult.vector4_f32[1] = ((vColor.vector4_f32[1] - fLuminance) * fSaturation) + fLuminance;
-    vResult.vector4_f32[2] = ((vColor.vector4_f32[2] - fLuminance) * fSaturation) + fLuminance;
-    vResult.vector4_f32[3] = vColor.vector4_f32[3];
-    return vResult;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR vLuminance = XMVector3Dot(vColor, gvLuminance);
-    XMVECTOR vResult = vsubq_f32(vColor, vLuminance);
-    vResult = vmlaq_n_f32(vLuminance, vResult, fSaturation);
-    return vbslq_f32(g_XMSelect1110, vResult, vColor);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vLuminance = XMVector3Dot(vColor, gvLuminance);
-    // Splat fSaturation
-    XMVECTOR vSaturation = _mm_set_ps1(fSaturation);
-    // vResult = ((vColor-vLuminance)*vSaturation)+vLuminance;
-    XMVECTOR vResult = _mm_sub_ps(vColor, vLuminance);
-    vResult = XM_FMADD_PS(vResult, vSaturation, vLuminance);
-    // Retain w from the source color
-    vLuminance = _mm_shuffle_ps(vResult, vColor, _MM_SHUFFLE(3, 2, 2, 2));   // x = vResult.z,y = vResult.z,z = vColor.z,w=vColor.w
-    vResult = _mm_shuffle_ps(vResult, vLuminance, _MM_SHUFFLE(3, 0, 1, 0));  // x = vResult.x,y = vResult.y,z = vResult.z,w=vColor.w
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorAdjustContrast
-        (
-                FXMVECTOR vColor,
-                float    fContrast
-        ) noexcept
-{
-    // Result = (vColor - 0.5f) * fContrast + 0.5f;
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            ((vColor.vector4_f32[0] - 0.5f) * fContrast) + 0.5f,
-            ((vColor.vector4_f32[1] - 0.5f) * fContrast) + 0.5f,
-            ((vColor.vector4_f32[2] - 0.5f) * fContrast) + 0.5f,
-            vColor.vector4_f32[3]        // Leave W untouched
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR vResult = vsubq_f32(vColor, g_XMOneHalf.v);
-    vResult = vmlaq_n_f32(g_XMOneHalf.v, vResult, fContrast);
-    return vbslq_f32(g_XMSelect1110, vResult, vColor);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vScale = _mm_set_ps1(fContrast);           // Splat the scale
-    XMVECTOR vResult = _mm_sub_ps(vColor, g_XMOneHalf);  // Subtract 0.5f from the source (Saving source)
-    vResult = XM_FMADD_PS(vResult, vScale, g_XMOneHalf);
-// Retain w from the source color
-    vScale = _mm_shuffle_ps(vResult, vColor, _MM_SHUFFLE(3, 2, 2, 2));   // x = vResult.z,y = vResult.z,z = vColor.z,w=vColor.w
-    vResult = _mm_shuffle_ps(vResult, vScale, _MM_SHUFFLE(3, 0, 1, 0));  // x = vResult.x,y = vResult.y,z = vResult.z,w=vColor.w
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorRGBToHSL(FXMVECTOR rgb) noexcept
-{
-    XMVECTOR r = XMVectorSplatX(rgb);
-    XMVECTOR g = XMVectorSplatY(rgb);
-    XMVECTOR b = XMVectorSplatZ(rgb);
-
-    XMVECTOR min = XMVectorMin(r, XMVectorMin(g, b));
-    XMVECTOR max = XMVectorMax(r, XMVectorMax(g, b));
-
-    XMVECTOR l = XMVectorMultiply(XMVectorAdd(min, max), g_XMOneHalf);
-
-    XMVECTOR d = XMVectorSubtract(max, min);
-
-    XMVECTOR la = XMVectorSelect(rgb, l, g_XMSelect1110);
-
-    if (XMVector3Less(d, g_XMEpsilon))
-    {
-        // Achromatic, assume H and S of 0
-        return XMVectorSelect(la, g_XMZero, g_XMSelect1100);
-    }
-    else
-    {
-        XMVECTOR s, h;
-
-        XMVECTOR d2 = XMVectorAdd(min, max);
-
-        if (XMVector3Greater(l, g_XMOneHalf))
-        {
-            // d / (2-max-min)
-            s = XMVectorDivide(d, XMVectorSubtract(g_XMTwo, d2));
-        }
-        else
-        {
-            // d / (max+min)
-            s = XMVectorDivide(d, d2);
-        }
-
-        if (XMVector3Equal(r, max))
-        {
-            // Red is max
-            h = XMVectorDivide(XMVectorSubtract(g, b), d);
-        }
-        else if (XMVector3Equal(g, max))
-        {
-            // Green is max
-            h = XMVectorDivide(XMVectorSubtract(b, r), d);
-            h = XMVectorAdd(h, g_XMTwo);
-        }
-        else
-        {
-            // Blue is max
-            h = XMVectorDivide(XMVectorSubtract(r, g), d);
-            h = XMVectorAdd(h, g_XMFour);
-        }
-
-        h = XMVectorDivide(h, g_XMSix);
-
-        if (XMVector3Less(h, g_XMZero))
-            h = XMVectorAdd(h, g_XMOne);
-
-        XMVECTOR lha = XMVectorSelect(la, h, g_XMSelect1100);
-        return XMVectorSelect(s, lha, g_XMSelect1011);
-    }
-}
-
-//------------------------------------------------------------------------------
-
-namespace Internal
-{
-
-    inline XMVECTOR XM_CALLCONV XMColorHue2Clr(FXMVECTOR p, FXMVECTOR q, FXMVECTOR h) noexcept
-    {
-        static const XMVECTORF32 oneSixth = { { { 1.0f / 6.0f, 1.0f / 6.0f, 1.0f / 6.0f, 1.0f / 6.0f } } };
-        static const XMVECTORF32 twoThirds = { { { 2.0f / 3.0f, 2.0f / 3.0f, 2.0f / 3.0f, 2.0f / 3.0f } } };
-
-        XMVECTOR t = h;
-
-        if (XMVector3Less(t, g_XMZero))
-            t = XMVectorAdd(t, g_XMOne);
-
-        if (XMVector3Greater(t, g_XMOne))
-            t = XMVectorSubtract(t, g_XMOne);
-
-        if (XMVector3Less(t, oneSixth))
-        {
-            // p + (q - p) * 6 * t
-            XMVECTOR t1 = XMVectorSubtract(q, p);
-            XMVECTOR t2 = XMVectorMultiply(g_XMSix, t);
-            return XMVectorMultiplyAdd(t1, t2, p);
-        }
-
-        if (XMVector3Less(t, g_XMOneHalf))
-            return q;
-
-        if (XMVector3Less(t, twoThirds))
-        {
-            // p + (q - p) * 6 * (2/3 - t)
-            XMVECTOR t1 = XMVectorSubtract(q, p);
-            XMVECTOR t2 = XMVectorMultiply(g_XMSix, XMVectorSubtract(twoThirds, t));
-            return XMVectorMultiplyAdd(t1, t2, p);
-        }
-
-        return p;
-    }
-
-} // namespace Internal
-
-inline XMVECTOR XM_CALLCONV XMColorHSLToRGB(FXMVECTOR hsl) noexcept
-{
-    static const XMVECTORF32 oneThird = { { { 1.0f / 3.0f, 1.0f / 3.0f, 1.0f / 3.0f, 1.0f / 3.0f } } };
-
-    XMVECTOR s = XMVectorSplatY(hsl);
-    XMVECTOR l = XMVectorSplatZ(hsl);
-
-    if (XMVector3NearEqual(s, g_XMZero, g_XMEpsilon))
-    {
-        // Achromatic
-        return XMVectorSelect(hsl, l, g_XMSelect1110);
-    }
-    else
-    {
-        XMVECTOR h = XMVectorSplatX(hsl);
-
-        XMVECTOR q;
-        if (XMVector3Less(l, g_XMOneHalf))
-        {
-            q = XMVectorMultiply(l, XMVectorAdd(g_XMOne, s));
-        }
-        else
-        {
-            q = XMVectorSubtract(XMVectorAdd(l, s), XMVectorMultiply(l, s));
-        }
-
-        XMVECTOR p = XMVectorSubtract(XMVectorMultiply(g_XMTwo, l), q);
-
-        XMVECTOR r = DirectX::Internal::XMColorHue2Clr(p, q, XMVectorAdd(h, oneThird));
-        XMVECTOR g = DirectX::Internal::XMColorHue2Clr(p, q, h);
-        XMVECTOR b = DirectX::Internal::XMColorHue2Clr(p, q, XMVectorSubtract(h, oneThird));
-
-        XMVECTOR rg = XMVectorSelect(g, r, g_XMSelect1000);
-        XMVECTOR ba = XMVectorSelect(hsl, b, g_XMSelect1110);
-
-        return XMVectorSelect(ba, rg, g_XMSelect1100);
-    }
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorRGBToHSV(FXMVECTOR rgb) noexcept
-{
-    XMVECTOR r = XMVectorSplatX(rgb);
-    XMVECTOR g = XMVectorSplatY(rgb);
-    XMVECTOR b = XMVectorSplatZ(rgb);
-
-    XMVECTOR min = XMVectorMin(r, XMVectorMin(g, b));
-    XMVECTOR v = XMVectorMax(r, XMVectorMax(g, b));
-
-    XMVECTOR d = XMVectorSubtract(v, min);
-
-    XMVECTOR s = (XMVector3NearEqual(v, g_XMZero, g_XMEpsilon)) ? g_XMZero : XMVectorDivide(d, v);
-
-    if (XMVector3Less(d, g_XMEpsilon))
-    {
-        // Achromatic, assume H of 0
-        XMVECTOR hv = XMVectorSelect(v, g_XMZero, g_XMSelect1000);
-        XMVECTOR hva = XMVectorSelect(rgb, hv, g_XMSelect1110);
-        return XMVectorSelect(s, hva, g_XMSelect1011);
-    }
-    else
-    {
-        XMVECTOR h;
-
-        if (XMVector3Equal(r, v))
-        {
-            // Red is max
-            h = XMVectorDivide(XMVectorSubtract(g, b), d);
-
-            if (XMVector3Less(g, b))
-                h = XMVectorAdd(h, g_XMSix);
-        }
-        else if (XMVector3Equal(g, v))
-        {
-            // Green is max
-            h = XMVectorDivide(XMVectorSubtract(b, r), d);
-            h = XMVectorAdd(h, g_XMTwo);
-        }
-        else
-        {
-            // Blue is max
-            h = XMVectorDivide(XMVectorSubtract(r, g), d);
-            h = XMVectorAdd(h, g_XMFour);
-        }
-
-        h = XMVectorDivide(h, g_XMSix);
-
-        XMVECTOR hv = XMVectorSelect(v, h, g_XMSelect1000);
-        XMVECTOR hva = XMVectorSelect(rgb, hv, g_XMSelect1110);
-        return XMVectorSelect(s, hva, g_XMSelect1011);
-    }
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorHSVToRGB(FXMVECTOR hsv) noexcept
-{
-    XMVECTOR h = XMVectorSplatX(hsv);
-    XMVECTOR s = XMVectorSplatY(hsv);
-    XMVECTOR v = XMVectorSplatZ(hsv);
-
-    XMVECTOR h6 = XMVectorMultiply(h, g_XMSix);
-
-    XMVECTOR i = XMVectorFloor(h6);
-    XMVECTOR f = XMVectorSubtract(h6, i);
-
-    // p = v* (1-s)
-    XMVECTOR p = XMVectorMultiply(v, XMVectorSubtract(g_XMOne, s));
-
-    // q = v*(1-f*s)
-    XMVECTOR q = XMVectorMultiply(v, XMVectorSubtract(g_XMOne, XMVectorMultiply(f, s)));
-
-    // t = v*(1 - (1-f)*s)
-    XMVECTOR t = XMVectorMultiply(v, XMVectorSubtract(g_XMOne, XMVectorMultiply(XMVectorSubtract(g_XMOne, f), s)));
-
-    auto ii = static_cast<int>(XMVectorGetX(XMVectorMod(i, g_XMSix)));
-
-    XMVECTOR _rgb;
-
-    switch (ii)
-    {
-        case 0: // rgb = vtp
-        {
-            XMVECTOR vt = XMVectorSelect(t, v, g_XMSelect1000);
-            _rgb = XMVectorSelect(p, vt, g_XMSelect1100);
-        }
-            break;
-        case 1: // rgb = qvp
-        {
-            XMVECTOR qv = XMVectorSelect(v, q, g_XMSelect1000);
-            _rgb = XMVectorSelect(p, qv, g_XMSelect1100);
-        }
-            break;
-        case 2: // rgb = pvt
-        {
-            XMVECTOR pv = XMVectorSelect(v, p, g_XMSelect1000);
-            _rgb = XMVectorSelect(t, pv, g_XMSelect1100);
-        }
-            break;
-        case 3: // rgb = pqv
-        {
-            XMVECTOR pq = XMVectorSelect(q, p, g_XMSelect1000);
-            _rgb = XMVectorSelect(v, pq, g_XMSelect1100);
-        }
-            break;
-        case 4: // rgb = tpv
-        {
-            XMVECTOR tp = XMVectorSelect(p, t, g_XMSelect1000);
-            _rgb = XMVectorSelect(v, tp, g_XMSelect1100);
-        }
-            break;
-        default: // rgb = vpq
-        {
-            XMVECTOR vp = XMVectorSelect(p, v, g_XMSelect1000);
-            _rgb = XMVectorSelect(q, vp, g_XMSelect1100);
-        }
-            break;
-    }
-
-    return XMVectorSelect(hsv, _rgb, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorRGBToYUV(FXMVECTOR rgb) noexcept
-{
-    static const XMVECTORF32 Scale0 = { { { 0.299f, -0.147f, 0.615f, 0.0f } } };
-    static const XMVECTORF32 Scale1 = { { { 0.587f, -0.289f, -0.515f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { 0.114f, 0.436f, -0.100f, 0.0f } } };
-
-    XMMATRIX M(Scale0, Scale1, Scale2, g_XMZero);
-    XMVECTOR clr = XMVector3Transform(rgb, M);
-
-    return XMVectorSelect(rgb, clr, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorYUVToRGB(FXMVECTOR yuv) noexcept
-{
-    static const XMVECTORF32 Scale1 = { { { 0.0f, -0.395f, 2.032f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { 1.140f, -0.581f, 0.0f, 0.0f } } };
-
-    XMMATRIX M(g_XMOne, Scale1, Scale2, g_XMZero);
-    XMVECTOR clr = XMVector3Transform(yuv, M);
-
-    return XMVectorSelect(yuv, clr, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorRGBToYUV_HD(FXMVECTOR rgb) noexcept
-{
-    static const XMVECTORF32 Scale0 = { { { 0.2126f, -0.0997f, 0.6150f, 0.0f } } };
-    static const XMVECTORF32 Scale1 = { { { 0.7152f, -0.3354f, -0.5586f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { 0.0722f, 0.4351f, -0.0564f, 0.0f } } };
-
-    XMMATRIX M(Scale0, Scale1, Scale2, g_XMZero);
-    XMVECTOR clr = XMVector3Transform(rgb, M);
-
-    return XMVectorSelect(rgb, clr, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorYUVToRGB_HD(FXMVECTOR yuv) noexcept
-{
-    static const XMVECTORF32 Scale1 = { { { 0.0f, -0.2153f, 2.1324f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { 1.2803f, -0.3806f, 0.0f, 0.0f } } };
-
-    XMMATRIX M(g_XMOne, Scale1, Scale2, g_XMZero);
-    XMVECTOR clr = XMVector3Transform(yuv, M);
-
-    return XMVectorSelect(yuv, clr, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorRGBToYUV_UHD(FXMVECTOR rgb) noexcept
-{
-    static const XMVECTORF32 Scale0 = { { { 0.2627f, -0.1215f,  0.6150f, 0.0f } } };
-    static const XMVECTORF32 Scale1 = { { { 0.6780f, -0.3136f, -0.5655f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { 0.0593f,  0.4351f, -0.0495f, 0.0f } } };
-
-    XMMATRIX M(Scale0, Scale1, Scale2, g_XMZero);
-    XMVECTOR clr = XMVector3Transform(rgb, M);
-
-    return XMVectorSelect(rgb, clr, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorYUVToRGB_UHD(FXMVECTOR yuv) noexcept
-{
-    static const XMVECTORF32 Scale1 = { { {    0.0f, -0.1891f, 2.1620f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { 1.1989f, -0.4645f,    0.0f, 0.0f } } };
-
-    XMMATRIX M(g_XMOne, Scale1, Scale2, g_XMZero);
-    XMVECTOR clr = XMVector3Transform(yuv, M);
-
-    return XMVectorSelect(yuv, clr, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorRGBToXYZ(FXMVECTOR rgb) noexcept
-{
-    static const XMVECTORF32 Scale0 = { { { 0.4887180f, 0.1762044f, 0.0000000f, 0.0f } } };
-    static const XMVECTORF32 Scale1 = { { { 0.3106803f, 0.8129847f, 0.0102048f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { 0.2006017f, 0.0108109f, 0.9897952f, 0.0f } } };
-    static const XMVECTORF32 Scale = { { { 1.f / 0.17697f, 1.f / 0.17697f, 1.f / 0.17697f, 0.0f } } };
-
-    XMMATRIX M(Scale0, Scale1, Scale2, g_XMZero);
-    XMVECTOR clr = XMVectorMultiply(XMVector3Transform(rgb, M), Scale);
-
-    return XMVectorSelect(rgb, clr, g_XMSelect1110);
-}
-
-inline XMVECTOR XM_CALLCONV XMColorXYZToRGB(FXMVECTOR xyz) noexcept
-{
-    static const XMVECTORF32 Scale0 = { { { 2.3706743f, -0.5138850f, 0.0052982f, 0.0f } } };
-    static const XMVECTORF32 Scale1 = { { { -0.9000405f, 1.4253036f, -0.0146949f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { -0.4706338f, 0.0885814f, 1.0093968f, 0.0f } } };
-    static const XMVECTORF32 Scale = { { { 0.17697f, 0.17697f, 0.17697f, 0.0f } } };
-
-    XMMATRIX M(Scale0, Scale1, Scale2, g_XMZero);
-    XMVECTOR clr = XMVector3Transform(XMVectorMultiply(xyz, Scale), M);
-
-    return XMVectorSelect(xyz, clr, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorXYZToSRGB(FXMVECTOR xyz) noexcept
-{
-    static const XMVECTORF32 Scale0 = { { { 3.2406f, -0.9689f, 0.0557f, 0.0f } } };
-    static const XMVECTORF32 Scale1 = { { { -1.5372f, 1.8758f, -0.2040f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { -0.4986f, 0.0415f, 1.0570f, 0.0f } } };
-    static const XMVECTORF32 Cutoff = { { { 0.0031308f, 0.0031308f, 0.0031308f, 0.0f } } };
-    static const XMVECTORF32 Exp = { { { 1.0f / 2.4f, 1.0f / 2.4f, 1.0f / 2.4f, 1.0f } } };
-
-    XMMATRIX M(Scale0, Scale1, Scale2, g_XMZero);
-    XMVECTOR lclr = XMVector3Transform(xyz, M);
-
-    XMVECTOR sel = XMVectorGreater(lclr, Cutoff);
-
-    // clr = 12.92 * lclr for lclr <= 0.0031308f
-    XMVECTOR smallC = XMVectorMultiply(lclr, g_XMsrgbScale);
-
-    // clr = (1+a)*pow(lclr, 1/2.4) - a for lclr > 0.0031308 (where a = 0.055)
-    XMVECTOR largeC = XMVectorSubtract(XMVectorMultiply(g_XMsrgbA1, XMVectorPow(lclr, Exp)), g_XMsrgbA);
-
-    XMVECTOR clr = XMVectorSelect(smallC, largeC, sel);
-
-    return XMVectorSelect(xyz, clr, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorSRGBToXYZ(FXMVECTOR srgb) noexcept
-{
-    static const XMVECTORF32 Scale0 = { { { 0.4124f, 0.2126f, 0.0193f, 0.0f } } };
-    static const XMVECTORF32 Scale1 = { { { 0.3576f, 0.7152f, 0.1192f, 0.0f } } };
-    static const XMVECTORF32 Scale2 = { { { 0.1805f, 0.0722f, 0.9505f, 0.0f } } };
-    static const XMVECTORF32 Cutoff = { { { 0.04045f, 0.04045f, 0.04045f, 0.0f } } };
-    static const XMVECTORF32 Exp = { { { 2.4f, 2.4f, 2.4f, 1.0f } } };
-
-    XMVECTOR sel = XMVectorGreater(srgb, Cutoff);
-
-    // lclr = clr / 12.92
-    XMVECTOR smallC = XMVectorDivide(srgb, g_XMsrgbScale);
-
-    // lclr = pow( (clr + a) / (1+a), 2.4 )
-    XMVECTOR largeC = XMVectorPow(XMVectorDivide(XMVectorAdd(srgb, g_XMsrgbA), g_XMsrgbA1), Exp);
-
-    XMVECTOR lclr = XMVectorSelect(smallC, largeC, sel);
-
-    XMMATRIX M(Scale0, Scale1, Scale2, g_XMZero);
-    XMVECTOR clr = XMVector3Transform(lclr, M);
-
-    return XMVectorSelect(srgb, clr, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorRGBToSRGB(FXMVECTOR rgb) noexcept
-{
-    static const XMVECTORF32 Cutoff = { { { 0.0031308f, 0.0031308f, 0.0031308f, 1.f } } };
-    static const XMVECTORF32 Linear = { { { 12.92f, 12.92f, 12.92f, 1.f } } };
-    static const XMVECTORF32 Scale = { { { 1.055f, 1.055f, 1.055f, 1.f } } };
-    static const XMVECTORF32 Bias = { { { 0.055f, 0.055f, 0.055f, 0.f } } };
-    static const XMVECTORF32 InvGamma = { { { 1.0f / 2.4f, 1.0f / 2.4f, 1.0f / 2.4f, 1.f } } };
-
-    XMVECTOR V = XMVectorSaturate(rgb);
-    XMVECTOR V0 = XMVectorMultiply(V, Linear);
-    XMVECTOR V1 = XMVectorSubtract(XMVectorMultiply(Scale, XMVectorPow(V, InvGamma)), Bias);
-    XMVECTOR select = XMVectorLess(V, Cutoff);
-    V = XMVectorSelect(V1, V0, select);
-    return XMVectorSelect(rgb, V, g_XMSelect1110);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMColorSRGBToRGB(FXMVECTOR srgb) noexcept
-{
-    static const XMVECTORF32 Cutoff = { { { 0.04045f, 0.04045f, 0.04045f, 1.f } } };
-    static const XMVECTORF32 ILinear = { { { 1.f / 12.92f, 1.f / 12.92f, 1.f / 12.92f, 1.f } } };
-    static const XMVECTORF32 Scale = { { { 1.f / 1.055f, 1.f / 1.055f, 1.f / 1.055f, 1.f } } };
-    static const XMVECTORF32 Bias = { { { 0.055f, 0.055f, 0.055f, 0.f } } };
-    static const XMVECTORF32 Gamma = { { { 2.4f, 2.4f, 2.4f, 1.f } } };
-
-    XMVECTOR V = XMVectorSaturate(srgb);
-    XMVECTOR V0 = XMVectorMultiply(V, ILinear);
-    XMVECTOR V1 = XMVectorPow(XMVectorMultiply(XMVectorAdd(V, Bias), Scale), Gamma);
-    XMVECTOR select = XMVectorGreater(V, Cutoff);
-    V = XMVectorSelect(V0, V1, select);
-    return XMVectorSelect(srgb, V, g_XMSelect1110);
-}
-
-/****************************************************************************
- *
- * Miscellaneous
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline bool XMVerifyCPUSupport() noexcept
-{
-#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    int CPUInfo[4] = { -1 };
-#if defined(__clang__) || defined(__GNUC__)
-    __cpuid(0, CPUInfo[0], CPUInfo[1], CPUInfo[2], CPUInfo[3]);
-#else
-    __cpuid(CPUInfo, 0);
-#endif
-
-#ifdef __AVX2__
-    if (CPUInfo[0] < 7)
-        return false;
-#else
-    if (CPUInfo[0] < 1)
-        return false;
-#endif
-
-#if defined(__clang__) || defined(__GNUC__)
-    __cpuid(1, CPUInfo[0], CPUInfo[1], CPUInfo[2], CPUInfo[3]);
-#else
-    __cpuid(CPUInfo, 1);
-#endif
-
-#if defined(__AVX2__) || defined(_XM_AVX2_INTRINSICS_)
-    // The compiler can emit FMA3 instructions even without explicit intrinsics use
-    if ((CPUInfo[2] & 0x38081001) != 0x38081001)
-        return false; // No F16C/AVX/OSXSAVE/SSE4.1/FMA3/SSE3 support
-#elif defined(_XM_FMA3_INTRINSICS_) && defined(_XM_F16C_INTRINSICS_)
-    if ((CPUInfo[2] & 0x38081001) != 0x38081001)
-        return false; // No F16C/AVX/OSXSAVE/SSE4.1/FMA3/SSE3 support
-#elif defined(_XM_FMA3_INTRINSICS_)
-    if ((CPUInfo[2] & 0x18081001) != 0x18081001)
-        return false; // No AVX/OSXSAVE/SSE4.1/FMA3/SSE3 support
-#elif defined(_XM_F16C_INTRINSICS_)
-    if ((CPUInfo[2] & 0x38080001) != 0x38080001)
-        return false; // No F16C/AVX/OSXSAVE/SSE4.1/SSE3 support
-#elif defined(__AVX__) || defined(_XM_AVX_INTRINSICS_)
-    if ((CPUInfo[2] & 0x18080001) != 0x18080001)
-        return false; // No AVX/OSXSAVE/SSE4.1/SSE3 support
-#elif defined(_XM_SSE4_INTRINSICS_)
-    if ((CPUInfo[2] & 0x80001) != 0x80001)
-        return false; // No SSE3/SSE4.1 support
-#elif defined(_XM_SSE3_INTRINSICS_)
-    if (!(CPUInfo[2] & 0x1))
-        return false; // No SSE3 support
-#endif
-
-    // The x64 processor model requires SSE2 support, but no harm in checking
-    if ((CPUInfo[3] & 0x6000000) != 0x6000000)
-        return false; // No SSE2/SSE support
-
-#if defined(__AVX2__) || defined(_XM_AVX2_INTRINSICS_)
-    #if defined(__clang__) || defined(__GNUC__)
-    __cpuid_count(7, 0, CPUInfo[0], CPUInfo[1], CPUInfo[2], CPUInfo[3]);
-#else
-    __cpuidex(CPUInfo, 7, 0);
-#endif
-    if (!(CPUInfo[1] & 0x20))
-        return false; // No AVX2 support
-#endif
-
-    return true;
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    // ARM-NEON support is required for the Windows on ARM platform
-    return true;
-#else
-    // No intrinsics path always supported
-    return true;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMFresnelTerm
-        (
-                FXMVECTOR CosIncidentAngle,
-                FXMVECTOR RefractionIndex
-        ) noexcept
-{
-    assert(!XMVector4IsInfinite(CosIncidentAngle));
-
-    // Result = 0.5f * (g - c)^2 / (g + c)^2 * ((c * (g + c) - 1)^2 / (c * (g - c) + 1)^2 + 1) where
-    // c = CosIncidentAngle
-    // g = sqrt(c^2 + RefractionIndex^2 - 1)
-
-#if defined(_XM_NO_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-
-    XMVECTOR G = XMVectorMultiplyAdd(RefractionIndex, RefractionIndex, g_XMNegativeOne.v);
-    G = XMVectorMultiplyAdd(CosIncidentAngle, CosIncidentAngle, G);
-    G = XMVectorAbs(G);
-    G = XMVectorSqrt(G);
-
-    XMVECTOR S = XMVectorAdd(G, CosIncidentAngle);
-    XMVECTOR D = XMVectorSubtract(G, CosIncidentAngle);
-
-    XMVECTOR V0 = XMVectorMultiply(D, D);
-    XMVECTOR V1 = XMVectorMultiply(S, S);
-    V1 = XMVectorReciprocal(V1);
-    V0 = XMVectorMultiply(g_XMOneHalf.v, V0);
-    V0 = XMVectorMultiply(V0, V1);
-
-    XMVECTOR V2 = XMVectorMultiplyAdd(CosIncidentAngle, S, g_XMNegativeOne.v);
-    XMVECTOR V3 = XMVectorMultiplyAdd(CosIncidentAngle, D, g_XMOne.v);
-    V2 = XMVectorMultiply(V2, V2);
-    V3 = XMVectorMultiply(V3, V3);
-    V3 = XMVectorReciprocal(V3);
-    V2 = XMVectorMultiplyAdd(V2, V3, g_XMOne.v);
-
-    XMVECTOR Result = XMVectorMultiply(V0, V2);
-
-    Result = XMVectorSaturate(Result);
-
-    return Result;
-
-#elif defined(_XM_SSE_INTRINSICS_)
-    // G = sqrt(abs((RefractionIndex^2-1) + CosIncidentAngle^2))
-    XMVECTOR G = _mm_mul_ps(RefractionIndex, RefractionIndex);
-    XMVECTOR vTemp = _mm_mul_ps(CosIncidentAngle, CosIncidentAngle);
-    G = _mm_sub_ps(G, g_XMOne);
-    vTemp = _mm_add_ps(vTemp, G);
-    // max((0-vTemp),vTemp) == abs(vTemp)
-    // The abs is needed to deal with refraction and cosine being zero
-    G = _mm_setzero_ps();
-    G = _mm_sub_ps(G, vTemp);
-    G = _mm_max_ps(G, vTemp);
-    // Last operation, the sqrt()
-    G = _mm_sqrt_ps(G);
-
-    // Calc G-C and G+C
-    XMVECTOR GAddC = _mm_add_ps(G, CosIncidentAngle);
-    XMVECTOR GSubC = _mm_sub_ps(G, CosIncidentAngle);
-    // Perform the term (0.5f *(g - c)^2) / (g + c)^2
-    XMVECTOR vResult = _mm_mul_ps(GSubC, GSubC);
-    vTemp = _mm_mul_ps(GAddC, GAddC);
-    vResult = _mm_mul_ps(vResult, g_XMOneHalf);
-    vResult = _mm_div_ps(vResult, vTemp);
-    // Perform the term ((c * (g + c) - 1)^2 / (c * (g - c) + 1)^2 + 1)
-    GAddC = _mm_mul_ps(GAddC, CosIncidentAngle);
-    GSubC = _mm_mul_ps(GSubC, CosIncidentAngle);
-    GAddC = _mm_sub_ps(GAddC, g_XMOne);
-    GSubC = _mm_add_ps(GSubC, g_XMOne);
-    GAddC = _mm_mul_ps(GAddC, GAddC);
-    GSubC = _mm_mul_ps(GSubC, GSubC);
-    GAddC = _mm_div_ps(GAddC, GSubC);
-    GAddC = _mm_add_ps(GAddC, g_XMOne);
-    // Multiply the two term parts
-    vResult = _mm_mul_ps(vResult, GAddC);
-    // Clamp to 0.0 - 1.0f
-    vResult = _mm_max_ps(vResult, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XMScalarNearEqual
-        (
-                float S1,
-                float S2,
-                float Epsilon
-        ) noexcept
-{
-    float Delta = S1 - S2;
-    return (fabsf(Delta) <= Epsilon);
-}
-
-//------------------------------------------------------------------------------
-// Modulo the range of the given angle such that -XM_PI <= Angle < XM_PI
-inline float XMScalarModAngle(float Angle) noexcept
-{
-    // Note: The modulo is performed with unsigned math only to work
-    // around a precision error on numbers that are close to PI
-
-    // Normalize the range from 0.0f to XM_2PI
-    Angle = Angle + XM_PI;
-    // Perform the modulo, unsigned
-    float fTemp = fabsf(Angle);
-    fTemp = fTemp - (XM_2PI * static_cast<float>(static_cast<int32_t>(fTemp / XM_2PI)));
-    // Restore the number to the range of -XM_PI to XM_PI-epsilon
-    fTemp = fTemp - XM_PI;
-    // If the modulo'd value was negative, restore negation
-    if (Angle < 0.0f)
-    {
-        fTemp = -fTemp;
-    }
-    return fTemp;
-}
-
-//------------------------------------------------------------------------------
-
-inline float XMScalarSin(float Value) noexcept
-{
-    // Map Value to y in [-pi,pi], x = 2*pi*quotient + remainder.
-    float quotient = XM_1DIV2PI * Value;
-    if (Value >= 0.0f)
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
-    }
-    else
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
-    }
-    float y = Value - XM_2PI * quotient;
-
-    // Map y to [-pi/2,pi/2] with sin(y) = sin(Value).
-    if (y > XM_PIDIV2)
-    {
-        y = XM_PI - y;
-    }
-    else if (y < -XM_PIDIV2)
-    {
-        y = -XM_PI - y;
-    }
-
-    // 11-degree minimax approximation
-    float y2 = y * y;
-    return (((((-2.3889859e-08f * y2 + 2.7525562e-06f) * y2 - 0.00019840874f) * y2 + 0.0083333310f) * y2 - 0.16666667f) * y2 + 1.0f) * y;
-}
-
-//------------------------------------------------------------------------------
-
-inline float XMScalarSinEst(float Value) noexcept
-{
-    // Map Value to y in [-pi,pi], x = 2*pi*quotient + remainder.
-    float quotient = XM_1DIV2PI * Value;
-    if (Value >= 0.0f)
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
-    }
-    else
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
-    }
-    float y = Value - XM_2PI * quotient;
-
-    // Map y to [-pi/2,pi/2] with sin(y) = sin(Value).
-    if (y > XM_PIDIV2)
-    {
-        y = XM_PI - y;
-    }
-    else if (y < -XM_PIDIV2)
-    {
-        y = -XM_PI - y;
-    }
-
-    // 7-degree minimax approximation
-    float y2 = y * y;
-    return (((-0.00018524670f * y2 + 0.0083139502f) * y2 - 0.16665852f) * y2 + 1.0f) * y;
-}
-
-//------------------------------------------------------------------------------
-
-inline float XMScalarCos(float Value) noexcept
-{
-    // Map Value to y in [-pi,pi], x = 2*pi*quotient + remainder.
-    float quotient = XM_1DIV2PI * Value;
-    if (Value >= 0.0f)
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
-    }
-    else
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
-    }
-    float y = Value - XM_2PI * quotient;
-
-    // Map y to [-pi/2,pi/2] with cos(y) = sign*cos(x).
-    float sign;
-    if (y > XM_PIDIV2)
-    {
-        y = XM_PI - y;
-        sign = -1.0f;
-    }
-    else if (y < -XM_PIDIV2)
-    {
-        y = -XM_PI - y;
-        sign = -1.0f;
-    }
-    else
-    {
-        sign = +1.0f;
-    }
-
-    // 10-degree minimax approximation
-    float y2 = y * y;
-    float p = ((((-2.6051615e-07f * y2 + 2.4760495e-05f) * y2 - 0.0013888378f) * y2 + 0.041666638f) * y2 - 0.5f) * y2 + 1.0f;
-    return sign * p;
-}
-
-//------------------------------------------------------------------------------
-
-inline float XMScalarCosEst(float Value) noexcept
-{
-    // Map Value to y in [-pi,pi], x = 2*pi*quotient + remainder.
-    float quotient = XM_1DIV2PI * Value;
-    if (Value >= 0.0f)
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
-    }
-    else
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
-    }
-    float y = Value - XM_2PI * quotient;
-
-    // Map y to [-pi/2,pi/2] with cos(y) = sign*cos(x).
-    float sign;
-    if (y > XM_PIDIV2)
-    {
-        y = XM_PI - y;
-        sign = -1.0f;
-    }
-    else if (y < -XM_PIDIV2)
-    {
-        y = -XM_PI - y;
-        sign = -1.0f;
-    }
-    else
-    {
-        sign = +1.0f;
-    }
-
-    // 6-degree minimax approximation
-    float y2 = y * y;
-    float p = ((-0.0012712436f * y2 + 0.041493919f) * y2 - 0.49992746f) * y2 + 1.0f;
-    return sign * p;
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline void XMScalarSinCos
-        (
-                float* pSin,
-                float* pCos,
-                float  Value
-        ) noexcept
-{
-    assert(pSin);
-    assert(pCos);
-
-    // Map Value to y in [-pi,pi], x = 2*pi*quotient + remainder.
-    float quotient = XM_1DIV2PI * Value;
-    if (Value >= 0.0f)
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
-    }
-    else
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
-    }
-    float y = Value - XM_2PI * quotient;
-
-    // Map y to [-pi/2,pi/2] with sin(y) = sin(Value).
-    float sign;
-    if (y > XM_PIDIV2)
-    {
-        y = XM_PI - y;
-        sign = -1.0f;
-    }
-    else if (y < -XM_PIDIV2)
-    {
-        y = -XM_PI - y;
-        sign = -1.0f;
-    }
-    else
-    {
-        sign = +1.0f;
-    }
-
-    float y2 = y * y;
-
-    // 11-degree minimax approximation
-    *pSin = (((((-2.3889859e-08f * y2 + 2.7525562e-06f) * y2 - 0.00019840874f) * y2 + 0.0083333310f) * y2 - 0.16666667f) * y2 + 1.0f) * y;
-
-    // 10-degree minimax approximation
-    float p = ((((-2.6051615e-07f * y2 + 2.4760495e-05f) * y2 - 0.0013888378f) * y2 + 0.041666638f) * y2 - 0.5f) * y2 + 1.0f;
-    *pCos = sign * p;
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline void XMScalarSinCosEst
-        (
-                float* pSin,
-                float* pCos,
-                float  Value
-        ) noexcept
-{
-    assert(pSin);
-    assert(pCos);
-
-    // Map Value to y in [-pi,pi], x = 2*pi*quotient + remainder.
-    float quotient = XM_1DIV2PI * Value;
-    if (Value >= 0.0f)
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
-    }
-    else
-    {
-        quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
-    }
-    float y = Value - XM_2PI * quotient;
-
-    // Map y to [-pi/2,pi/2] with sin(y) = sin(Value).
-    float sign;
-    if (y > XM_PIDIV2)
-    {
-        y = XM_PI - y;
-        sign = -1.0f;
-    }
-    else if (y < -XM_PIDIV2)
-    {
-        y = -XM_PI - y;
-        sign = -1.0f;
-    }
-    else
-    {
-        sign = +1.0f;
-    }
-
-    float y2 = y * y;
-
-    // 7-degree minimax approximation
-    *pSin = (((-0.00018524670f * y2 + 0.0083139502f) * y2 - 0.16665852f) * y2 + 1.0f) * y;
-
-    // 6-degree minimax approximation
-    float p = ((-0.0012712436f * y2 + 0.041493919f) * y2 - 0.49992746f) * y2 + 1.0f;
-    *pCos = sign * p;
-}
-
-//------------------------------------------------------------------------------
-
-inline float XMScalarASin(float Value) noexcept
-{
-    // Clamp input to [-1,1].
-    bool nonnegative = (Value >= 0.0f);
-    float x = fabsf(Value);
-    float omx = 1.0f - x;
-    if (omx < 0.0f)
-    {
-        omx = 0.0f;
-    }
-    float root = sqrtf(omx);
-
-    // 7-degree minimax approximation
-    float result = ((((((-0.0012624911f * x + 0.0066700901f) * x - 0.0170881256f) * x + 0.0308918810f) * x - 0.0501743046f) * x + 0.0889789874f) * x - 0.2145988016f) * x + 1.5707963050f;
-    result *= root;  // acos(|x|)
-
-    // acos(x) = pi - acos(-x) when x < 0, asin(x) = pi/2 - acos(x)
-    return (nonnegative ? XM_PIDIV2 - result : result - XM_PIDIV2);
-}
-
-//------------------------------------------------------------------------------
-
-inline float XMScalarASinEst(float Value) noexcept
-{
-    // Clamp input to [-1,1].
-    bool nonnegative = (Value >= 0.0f);
-    float x = fabsf(Value);
-    float omx = 1.0f - x;
-    if (omx < 0.0f)
-    {
-        omx = 0.0f;
-    }
-    float root = sqrtf(omx);
-
-    // 3-degree minimax approximation
-    float result = ((-0.0187293f * x + 0.0742610f) * x - 0.2121144f) * x + 1.5707288f;
-    result *= root;  // acos(|x|)
-
-    // acos(x) = pi - acos(-x) when x < 0, asin(x) = pi/2 - acos(x)
-    return (nonnegative ? XM_PIDIV2 - result : result - XM_PIDIV2);
-}
-
-//------------------------------------------------------------------------------
-
-inline float XMScalarACos(float Value) noexcept
-{
-    // Clamp input to [-1,1].
-    bool nonnegative = (Value >= 0.0f);
-    float x = fabsf(Value);
-    float omx = 1.0f - x;
-    if (omx < 0.0f)
-    {
-        omx = 0.0f;
-    }
-    float root = sqrtf(omx);
-
-    // 7-degree minimax approximation
-    float result = ((((((-0.0012624911f * x + 0.0066700901f) * x - 0.0170881256f) * x + 0.0308918810f) * x - 0.0501743046f) * x + 0.0889789874f) * x - 0.2145988016f) * x + 1.5707963050f;
-    result *= root;
-
-    // acos(x) = pi - acos(-x) when x < 0
-    return (nonnegative ? result : XM_PI - result);
-}
-
-//------------------------------------------------------------------------------
-
-inline float XMScalarACosEst(float Value) noexcept
-{
-    // Clamp input to [-1,1].
-    bool nonnegative = (Value >= 0.0f);
-    float x = fabsf(Value);
-    float omx = 1.0f - x;
-    if (omx < 0.0f)
-    {
-        omx = 0.0f;
-    }
-    float root = sqrtf(omx);
-
-    // 3-degree minimax approximation
-    float result = ((-0.0187293f * x + 0.0742610f) * x - 0.2121144f) * x + 1.5707288f;
-    result *= root;
-
-    // acos(x) = pi - acos(-x) when x < 0
-    return (nonnegative ? result : XM_PI - result);
-}
-
diff --git a/thirdparty/directxmath/DirectXMathVector.inl b/thirdparty/directxmath/DirectXMathVector.inl
deleted file mode 100644
index 0035c81..0000000
--- a/thirdparty/directxmath/DirectXMathVector.inl
+++ /dev/null
@@ -1,14819 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXMathVector.inl -- SIMD C++ Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-#if defined(_XM_NO_INTRINSICS_)
-#define XMISNAN(x)  isnan(x)
-#define XMISINF(x)  isinf(x)
-#endif
-
-#if defined(_XM_SSE_INTRINSICS_)
-
-#define XM3UNPACK3INTO4(l1, l2, l3) \
-    XMVECTOR V3 = _mm_shuffle_ps(l2, l3, _MM_SHUFFLE(0, 0, 3, 2));\
-    XMVECTOR V2 = _mm_shuffle_ps(l2, l1, _MM_SHUFFLE(3, 3, 1, 0));\
-    V2 = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 0, 2));\
-    XMVECTOR V4 = _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(L3), 32 / 8))
-
-#define XM3PACK4INTO3(v2x) \
-    v2x = _mm_shuffle_ps(V2, V3, _MM_SHUFFLE(1, 0, 2, 1));\
-    V2 = _mm_shuffle_ps(V2, V1, _MM_SHUFFLE(2, 2, 0, 0));\
-    V1 = _mm_shuffle_ps(V1, V2, _MM_SHUFFLE(0, 2, 1, 0));\
-    V3 = _mm_shuffle_ps(V3, V4, _MM_SHUFFLE(0, 0, 2, 2));\
-    V3 = _mm_shuffle_ps(V3, V4, _MM_SHUFFLE(2, 1, 2, 0))
-
-#endif
-
-/****************************************************************************
- *
- * General Vector
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-// Assignment operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-// Return a vector with all elements equaling zero
-inline XMVECTOR XM_CALLCONV XMVectorZero() noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { { 0.0f, 0.0f, 0.0f, 0.0f } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vdupq_n_f32(0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_setzero_ps();
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Initialize a vector with four floating point values
-inline XMVECTOR XM_CALLCONV XMVectorSet
-        (
-                float x,
-                float y,
-                float z,
-                float w
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { { x, y, z, w } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t V0 = vcreate_f32(
-        static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&x))
-        | (static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&y)) << 32));
-    float32x2_t V1 = vcreate_f32(
-        static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&z))
-        | (static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&w)) << 32));
-    return vcombine_f32(V0, V1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_set_ps(w, z, y, x);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Initialize a vector with four integer values
-inline XMVECTOR XM_CALLCONV XMVectorSetInt
-        (
-                uint32_t x,
-                uint32_t y,
-                uint32_t z,
-                uint32_t w
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 vResult = { { { x, y, z, w } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t V0 = vcreate_u32(static_cast<uint64_t>(x) | (static_cast<uint64_t>(y) << 32));
-    uint32x2_t V1 = vcreate_u32(static_cast<uint64_t>(z) | (static_cast<uint64_t>(w) << 32));
-    return vreinterpretq_f32_u32(vcombine_u32(V0, V1));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_set_epi32(static_cast<int>(w), static_cast<int>(z), static_cast<int>(y), static_cast<int>(x));
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Initialize a vector with a replicated floating point value
-inline XMVECTOR XM_CALLCONV XMVectorReplicate(float Value) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult;
-    vResult.f[0] =
-        vResult.f[1] =
-        vResult.f[2] =
-        vResult.f[3] = Value;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vdupq_n_f32(Value);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_set_ps1(Value);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Initialize a vector with a replicated floating point value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorReplicatePtr(const float* pValue) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float Value = pValue[0];
-    XMVECTORF32 vResult;
-    vResult.f[0] =
-        vResult.f[1] =
-        vResult.f[2] =
-        vResult.f[3] = Value;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vld1q_dup_f32(pValue);
-#elif defined(_XM_AVX_INTRINSICS_)
-    return _mm_broadcast_ss(pValue);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_load_ps1(pValue);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Initialize a vector with a replicated integer value
-inline XMVECTOR XM_CALLCONV XMVectorReplicateInt(uint32_t Value) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 vResult;
-    vResult.u[0] =
-        vResult.u[1] =
-        vResult.u[2] =
-        vResult.u[3] = Value;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vdupq_n_u32(Value));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_set1_epi32(static_cast<int>(Value));
-    return _mm_castsi128_ps(vTemp);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Initialize a vector with a replicated integer value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorReplicateIntPtr(const uint32_t* pValue) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    uint32_t Value = pValue[0];
-    XMVECTORU32 vResult;
-    vResult.u[0] =
-        vResult.u[1] =
-        vResult.u[2] =
-        vResult.u[3] = Value;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vld1q_dup_u32(pValue));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_load_ps1(reinterpret_cast<const float*>(pValue));
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Initialize a vector with all bits set (true mask)
-inline XMVECTOR XM_CALLCONV XMVectorTrueInt() noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 vResult = { { { 0xFFFFFFFFU, 0xFFFFFFFFU, 0xFFFFFFFFU, 0xFFFFFFFFU } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_s32(vdupq_n_s32(-1));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_set1_epi32(-1);
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Initialize a vector with all bits clear (false mask)
-inline XMVECTOR XM_CALLCONV XMVectorFalseInt() noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { { 0.0f, 0.0f, 0.0f, 0.0f } } };
-    return vResult;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vdupq_n_u32(0));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_setzero_ps();
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Replicate the x component of the vector
-inline XMVECTOR XM_CALLCONV XMVectorSplatX(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult;
-    vResult.f[0] =
-        vResult.f[1] =
-        vResult.f[2] =
-        vResult.f[3] = V.vector4_f32[0];
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vdupq_lane_f32(vget_low_f32(V), 0);
-#elif defined(_XM_AVX2_INTRINSICS_) && defined(_XM_FAVOR_INTEL_)
-    return _mm_broadcastss_ps(V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Replicate the y component of the vector
-inline XMVECTOR XM_CALLCONV XMVectorSplatY(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult;
-    vResult.f[0] =
-        vResult.f[1] =
-        vResult.f[2] =
-        vResult.f[3] = V.vector4_f32[1];
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vdupq_lane_f32(vget_low_f32(V), 1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Replicate the z component of the vector
-inline XMVECTOR XM_CALLCONV XMVectorSplatZ(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult;
-    vResult.f[0] =
-        vResult.f[1] =
-        vResult.f[2] =
-        vResult.f[3] = V.vector4_f32[2];
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vdupq_lane_f32(vget_high_f32(V), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Replicate the w component of the vector
-inline XMVECTOR XM_CALLCONV XMVectorSplatW(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult;
-    vResult.f[0] =
-        vResult.f[1] =
-        vResult.f[2] =
-        vResult.f[3] = V.vector4_f32[3];
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vdupq_lane_f32(vget_high_f32(V), 1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Return a vector of 1.0f,1.0f,1.0f,1.0f
-inline XMVECTOR XM_CALLCONV XMVectorSplatOne() noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult;
-    vResult.f[0] =
-        vResult.f[1] =
-        vResult.f[2] =
-        vResult.f[3] = 1.0f;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vdupq_n_f32(1.0f);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return g_XMOne;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Return a vector of INF,INF,INF,INF
-inline XMVECTOR XM_CALLCONV XMVectorSplatInfinity() noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 vResult;
-    vResult.u[0] =
-        vResult.u[1] =
-        vResult.u[2] =
-        vResult.u[3] = 0x7F800000;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vdupq_n_u32(0x7F800000));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return g_XMInfinity;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Return a vector of Q_NAN,Q_NAN,Q_NAN,Q_NAN
-inline XMVECTOR XM_CALLCONV XMVectorSplatQNaN() noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 vResult;
-    vResult.u[0] =
-        vResult.u[1] =
-        vResult.u[2] =
-        vResult.u[3] = 0x7FC00000;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vdupq_n_u32(0x7FC00000));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return g_XMQNaN;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Return a vector of 1.192092896e-7f,1.192092896e-7f,1.192092896e-7f,1.192092896e-7f
-inline XMVECTOR XM_CALLCONV XMVectorSplatEpsilon() noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 vResult;
-    vResult.u[0] =
-        vResult.u[1] =
-        vResult.u[2] =
-        vResult.u[3] = 0x34000000;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vdupq_n_u32(0x34000000));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return g_XMEpsilon;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Return a vector of -0.0f (0x80000000),-0.0f,-0.0f,-0.0f
-inline XMVECTOR XM_CALLCONV XMVectorSplatSignMask() noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 vResult;
-    vResult.u[0] =
-        vResult.u[1] =
-        vResult.u[2] =
-        vResult.u[3] = 0x80000000U;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vdupq_n_u32(0x80000000U));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_set1_epi32(static_cast<int>(0x80000000));
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Return a floating point value via an index. This is not a recommended
-// function to use due to performance loss.
-inline float XM_CALLCONV XMVectorGetByIndex(FXMVECTOR V, size_t i) noexcept
-{
-    assert(i < 4);
-    _Analysis_assume_(i < 4);
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_f32[i];
-#else
-    XMVECTORF32 U;
-    U.v = V;
-    return U.f[i];
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Return the X component in an FPU register.
-inline float XM_CALLCONV XMVectorGetX(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_f32[0];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vgetq_lane_f32(V, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_cvtss_f32(V);
-#endif
-}
-
-// Return the Y component in an FPU register.
-inline float XM_CALLCONV XMVectorGetY(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_f32[1];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vgetq_lane_f32(V, 1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-    return _mm_cvtss_f32(vTemp);
-#endif
-}
-
-// Return the Z component in an FPU register.
-inline float XM_CALLCONV XMVectorGetZ(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_f32[2];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vgetq_lane_f32(V, 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-    return _mm_cvtss_f32(vTemp);
-#endif
-}
-
-// Return the W component in an FPU register.
-inline float XM_CALLCONV XMVectorGetW(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_f32[3];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vgetq_lane_f32(V, 3);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-    return _mm_cvtss_f32(vTemp);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Store a component indexed by i into a 32 bit float location in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetByIndexPtr(float* f, FXMVECTOR V, size_t i) noexcept
-{
-    assert(f != nullptr);
-    assert(i < 4);
-    _Analysis_assume_(i < 4);
-#if defined(_XM_NO_INTRINSICS_)
-    *f = V.vector4_f32[i];
-#else
-    XMVECTORF32 U;
-    U.v = V;
-    *f = U.f[i];
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Store the X component into a 32 bit float location in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetXPtr(float* x, FXMVECTOR V) noexcept
-{
-    assert(x != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    *x = V.vector4_f32[0];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_f32(x, V, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_ss(x, V);
-#endif
-}
-
-// Store the Y component into a 32 bit float location in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetYPtr(float* y, FXMVECTOR V) noexcept
-{
-    assert(y != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    *y = V.vector4_f32[1];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_f32(y, V, 1);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    * (reinterpret_cast<int*>(y)) = _mm_extract_ps(V, 1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-    _mm_store_ss(y, vResult);
-#endif
-}
-
-// Store the Z component into a 32 bit float location in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetZPtr(float* z, FXMVECTOR V) noexcept
-{
-    assert(z != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    *z = V.vector4_f32[2];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_f32(z, V, 2);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    * (reinterpret_cast<int*>(z)) = _mm_extract_ps(V, 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-    _mm_store_ss(z, vResult);
-#endif
-}
-
-// Store the W component into a 32 bit float location in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetWPtr(float* w, FXMVECTOR V) noexcept
-{
-    assert(w != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    *w = V.vector4_f32[3];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_f32(w, V, 3);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    * (reinterpret_cast<int*>(w)) = _mm_extract_ps(V, 3);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-    _mm_store_ss(w, vResult);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Return an integer value via an index. This is not a recommended
-// function to use due to performance loss.
-inline uint32_t XM_CALLCONV XMVectorGetIntByIndex(FXMVECTOR V, size_t i) noexcept
-{
-    assert(i < 4);
-    _Analysis_assume_(i < 4);
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_u32[i];
-#else
-    XMVECTORU32 U;
-    U.v = V;
-    return U.u[i];
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Return the X component in an integer register.
-inline uint32_t XM_CALLCONV XMVectorGetIntX(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_u32[0];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vgetq_lane_u32(vreinterpretq_u32_f32(V), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return static_cast<uint32_t>(_mm_cvtsi128_si32(_mm_castps_si128(V)));
-#endif
-}
-
-// Return the Y component in an integer register.
-inline uint32_t XM_CALLCONV XMVectorGetIntY(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_u32[1];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vgetq_lane_u32(vreinterpretq_u32_f32(V), 1);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128i V1 = _mm_castps_si128(V);
-    return static_cast<uint32_t>(_mm_extract_epi32(V1, 1));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vResulti = _mm_shuffle_epi32(_mm_castps_si128(V), _MM_SHUFFLE(1, 1, 1, 1));
-    return static_cast<uint32_t>(_mm_cvtsi128_si32(vResulti));
-#endif
-}
-
-// Return the Z component in an integer register.
-inline uint32_t XM_CALLCONV XMVectorGetIntZ(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_u32[2];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vgetq_lane_u32(vreinterpretq_u32_f32(V), 2);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128i V1 = _mm_castps_si128(V);
-    return static_cast<uint32_t>(_mm_extract_epi32(V1, 2));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vResulti = _mm_shuffle_epi32(_mm_castps_si128(V), _MM_SHUFFLE(2, 2, 2, 2));
-    return static_cast<uint32_t>(_mm_cvtsi128_si32(vResulti));
-#endif
-}
-
-// Return the W component in an integer register.
-inline uint32_t XM_CALLCONV XMVectorGetIntW(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return V.vector4_u32[3];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vgetq_lane_u32(vreinterpretq_u32_f32(V), 3);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128i V1 = _mm_castps_si128(V);
-    return static_cast<uint32_t>(_mm_extract_epi32(V1, 3));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vResulti = _mm_shuffle_epi32(_mm_castps_si128(V), _MM_SHUFFLE(3, 3, 3, 3));
-    return static_cast<uint32_t>(_mm_cvtsi128_si32(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Store a component indexed by i into a 32 bit integer location in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetIntByIndexPtr(uint32_t* x, FXMVECTOR V, size_t i) noexcept
-{
-    assert(x != nullptr);
-    assert(i < 4);
-    _Analysis_assume_(i < 4);
-#if defined(_XM_NO_INTRINSICS_)
-    *x = V.vector4_u32[i];
-#else
-    XMVECTORU32 U;
-    U.v = V;
-    *x = U.u[i];
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Store the X component into a 32 bit integer location in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetIntXPtr(uint32_t* x, FXMVECTOR V) noexcept
-{
-    assert(x != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    *x = V.vector4_u32[0];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_u32(x, *reinterpret_cast<const uint32x4_t*>(&V), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    _mm_store_ss(reinterpret_cast<float*>(x), V);
-#endif
-}
-
-// Store the Y component into a 32 bit integer location in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetIntYPtr(uint32_t* y, FXMVECTOR V) noexcept
-{
-    assert(y != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    *y = V.vector4_u32[1];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_u32(y, *reinterpret_cast<const uint32x4_t*>(&V), 1);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128i V1 = _mm_castps_si128(V);
-    *y = static_cast<uint32_t>(_mm_extract_epi32(V1, 1));
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-    _mm_store_ss(reinterpret_cast<float*>(y), vResult);
-#endif
-}
-
-// Store the Z component into a 32 bit integer locaCantion in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetIntZPtr(uint32_t* z, FXMVECTOR V) noexcept
-{
-    assert(z != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    *z = V.vector4_u32[2];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_u32(z, *reinterpret_cast<const uint32x4_t*>(&V), 2);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128i V1 = _mm_castps_si128(V);
-    *z = static_cast<uint32_t>(_mm_extract_epi32(V1, 2));
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-    _mm_store_ss(reinterpret_cast<float*>(z), vResult);
-#endif
-}
-
-// Store the W component into a 32 bit integer location in memory.
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorGetIntWPtr(uint32_t* w, FXMVECTOR V) noexcept
-{
-    assert(w != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    *w = V.vector4_u32[3];
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    vst1q_lane_u32(w, *reinterpret_cast<const uint32x4_t*>(&V), 3);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128i V1 = _mm_castps_si128(V);
-    *w = static_cast<uint32_t>(_mm_extract_epi32(V1, 3));
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-    _mm_store_ss(reinterpret_cast<float*>(w), vResult);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Set a single indexed floating point component
-inline XMVECTOR XM_CALLCONV XMVectorSetByIndex(FXMVECTOR V, float f, size_t i) noexcept
-{
-    assert(i < 4);
-    _Analysis_assume_(i < 4);
-    XMVECTORF32 U;
-    U.v = V;
-    U.f[i] = f;
-    return U.v;
-}
-
-//------------------------------------------------------------------------------
-
-// Sets the X component of a vector to a passed floating point value
-inline XMVECTOR XM_CALLCONV XMVectorSetX(FXMVECTOR V, float x) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 U = { { {
-            x,
-            V.vector4_f32[1],
-            V.vector4_f32[2],
-            V.vector4_f32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vsetq_lane_f32(x, V, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = _mm_set_ss(x);
-    vResult = _mm_move_ss(V, vResult);
-    return vResult;
-#endif
-}
-
-// Sets the Y component of a vector to a passed floating point value
-inline XMVECTOR XM_CALLCONV XMVectorSetY(FXMVECTOR V, float y) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 U = { { {
-            V.vector4_f32[0],
-            y,
-            V.vector4_f32[2],
-            V.vector4_f32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vsetq_lane_f32(y, V, 1);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vResult = _mm_set_ss(y);
-    vResult = _mm_insert_ps(V, vResult, 0x10);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap y and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 2, 0, 1));
-    // Convert input to vector
-    XMVECTOR vTemp = _mm_set_ss(y);
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, vTemp);
-    // Swap y and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 2, 0, 1));
-    return vResult;
-#endif
-}
-// Sets the Z component of a vector to a passed floating point value
-inline XMVECTOR XM_CALLCONV XMVectorSetZ(FXMVECTOR V, float z) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 U = { { {
-            V.vector4_f32[0],
-            V.vector4_f32[1],
-            z,
-            V.vector4_f32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vsetq_lane_f32(z, V, 2);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vResult = _mm_set_ss(z);
-    vResult = _mm_insert_ps(V, vResult, 0x20);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap z and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 0, 1, 2));
-    // Convert input to vector
-    XMVECTOR vTemp = _mm_set_ss(z);
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, vTemp);
-    // Swap z and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 0, 1, 2));
-    return vResult;
-#endif
-}
-
-// Sets the W component of a vector to a passed floating point value
-inline XMVECTOR XM_CALLCONV XMVectorSetW(FXMVECTOR V, float w) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 U = { { {
-            V.vector4_f32[0],
-            V.vector4_f32[1],
-            V.vector4_f32[2],
-            w
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vsetq_lane_f32(w, V, 3);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vResult = _mm_set_ss(w);
-    vResult = _mm_insert_ps(V, vResult, 0x30);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap w and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 2, 1, 3));
-    // Convert input to vector
-    XMVECTOR vTemp = _mm_set_ss(w);
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, vTemp);
-    // Swap w and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(0, 2, 1, 3));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Sets a component of a vector to a floating point value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetByIndexPtr(FXMVECTOR V, const float* f, size_t i) noexcept
-{
-    assert(f != nullptr);
-    assert(i < 4);
-    _Analysis_assume_(i < 4);
-    XMVECTORF32 U;
-    U.v = V;
-    U.f[i] = *f;
-    return U.v;
-}
-
-//------------------------------------------------------------------------------
-
-// Sets the X component of a vector to a floating point value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetXPtr(FXMVECTOR V, const float* x) noexcept
-{
-    assert(x != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 U = { { {
-            *x,
-            V.vector4_f32[1],
-            V.vector4_f32[2],
-            V.vector4_f32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vld1q_lane_f32(x, V, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = _mm_load_ss(x);
-    vResult = _mm_move_ss(V, vResult);
-    return vResult;
-#endif
-}
-
-// Sets the Y component of a vector to a floating point value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetYPtr(FXMVECTOR V, const float* y) noexcept
-{
-    assert(y != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 U = { { {
-            V.vector4_f32[0],
-            *y,
-            V.vector4_f32[2],
-            V.vector4_f32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vld1q_lane_f32(y, V, 1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap y and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 2, 0, 1));
-    // Convert input to vector
-    XMVECTOR vTemp = _mm_load_ss(y);
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, vTemp);
-    // Swap y and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 2, 0, 1));
-    return vResult;
-#endif
-}
-
-// Sets the Z component of a vector to a floating point value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetZPtr(FXMVECTOR V, const float* z) noexcept
-{
-    assert(z != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 U = { { {
-            V.vector4_f32[0],
-            V.vector4_f32[1],
-            *z,
-            V.vector4_f32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vld1q_lane_f32(z, V, 2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap z and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 0, 1, 2));
-    // Convert input to vector
-    XMVECTOR vTemp = _mm_load_ss(z);
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, vTemp);
-    // Swap z and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 0, 1, 2));
-    return vResult;
-#endif
-}
-
-// Sets the W component of a vector to a floating point value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetWPtr(FXMVECTOR V, const float* w) noexcept
-{
-    assert(w != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 U = { { {
-            V.vector4_f32[0],
-            V.vector4_f32[1],
-            V.vector4_f32[2],
-            *w
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vld1q_lane_f32(w, V, 3);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap w and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 2, 1, 3));
-    // Convert input to vector
-    XMVECTOR vTemp = _mm_load_ss(w);
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, vTemp);
-    // Swap w and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(0, 2, 1, 3));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Sets a component of a vector to an integer passed by value
-inline XMVECTOR XM_CALLCONV XMVectorSetIntByIndex(FXMVECTOR V, uint32_t x, size_t i) noexcept
-{
-    assert(i < 4);
-    _Analysis_assume_(i < 4);
-    XMVECTORU32 tmp;
-    tmp.v = V;
-    tmp.u[i] = x;
-    return tmp;
-}
-
-//------------------------------------------------------------------------------
-
-// Sets the X component of a vector to an integer passed by value
-inline XMVECTOR XM_CALLCONV XMVectorSetIntX(FXMVECTOR V, uint32_t x) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 U = { { {
-            x,
-            V.vector4_u32[1],
-            V.vector4_u32[2],
-            V.vector4_u32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vsetq_lane_u32(x, vreinterpretq_u32_f32(V), 0));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cvtsi32_si128(static_cast<int>(x));
-    XMVECTOR vResult = _mm_move_ss(V, _mm_castsi128_ps(vTemp));
-    return vResult;
-#endif
-}
-
-// Sets the Y component of a vector to an integer passed by value
-inline XMVECTOR XM_CALLCONV XMVectorSetIntY(FXMVECTOR V, uint32_t y) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 U = { { {
-            V.vector4_u32[0],
-            y,
-            V.vector4_u32[2],
-            V.vector4_u32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vsetq_lane_u32(y, vreinterpretq_u32_f32(V), 1));
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128i vResult = _mm_castps_si128(V);
-    vResult = _mm_insert_epi32(vResult, static_cast<int>(y), 1);
-    return _mm_castsi128_ps(vResult);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap y and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 2, 0, 1));
-    // Convert input to vector
-    __m128i vTemp = _mm_cvtsi32_si128(static_cast<int>(y));
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, _mm_castsi128_ps(vTemp));
-    // Swap y and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 2, 0, 1));
-    return vResult;
-#endif
-}
-
-// Sets the Z component of a vector to an integer passed by value
-inline XMVECTOR XM_CALLCONV XMVectorSetIntZ(FXMVECTOR V, uint32_t z) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 U = { { {
-            V.vector4_u32[0],
-            V.vector4_u32[1],
-            z,
-            V.vector4_u32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vsetq_lane_u32(z, vreinterpretq_u32_f32(V), 2));
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128i vResult = _mm_castps_si128(V);
-    vResult = _mm_insert_epi32(vResult, static_cast<int>(z), 2);
-    return _mm_castsi128_ps(vResult);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap z and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 0, 1, 2));
-    // Convert input to vector
-    __m128i vTemp = _mm_cvtsi32_si128(static_cast<int>(z));
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, _mm_castsi128_ps(vTemp));
-    // Swap z and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 0, 1, 2));
-    return vResult;
-#endif
-}
-
-// Sets the W component of a vector to an integer passed by value
-inline XMVECTOR XM_CALLCONV XMVectorSetIntW(FXMVECTOR V, uint32_t w) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 U = { { {
-            V.vector4_u32[0],
-            V.vector4_u32[1],
-            V.vector4_u32[2],
-            w
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vsetq_lane_u32(w, vreinterpretq_u32_f32(V), 3));
-#elif defined(_XM_SSE4_INTRINSICS_)
-    __m128i vResult = _mm_castps_si128(V);
-    vResult = _mm_insert_epi32(vResult, static_cast<int>(w), 3);
-    return _mm_castsi128_ps(vResult);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap w and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 2, 1, 3));
-    // Convert input to vector
-    __m128i vTemp = _mm_cvtsi32_si128(static_cast<int>(w));
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, _mm_castsi128_ps(vTemp));
-    // Swap w and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(0, 2, 1, 3));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// Sets a component of a vector to an integer value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetIntByIndexPtr(FXMVECTOR V, const uint32_t* x, size_t i) noexcept
-{
-    assert(x != nullptr);
-    assert(i < 4);
-    _Analysis_assume_(i < 4);
-    XMVECTORU32 tmp;
-    tmp.v = V;
-    tmp.u[i] = *x;
-    return tmp;
-}
-
-//------------------------------------------------------------------------------
-
-// Sets the X component of a vector to an integer value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetIntXPtr(FXMVECTOR V, const uint32_t* x) noexcept
-{
-    assert(x != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 U = { { {
-            *x,
-            V.vector4_u32[1],
-            V.vector4_u32[2],
-            V.vector4_u32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vld1q_lane_u32(x, *reinterpret_cast<const uint32x4_t*>(&V), 0));
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_load_ss(reinterpret_cast<const float*>(x));
-    XMVECTOR vResult = _mm_move_ss(V, vTemp);
-    return vResult;
-#endif
-}
-
-// Sets the Y component of a vector to an integer value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetIntYPtr(FXMVECTOR V, const uint32_t* y) noexcept
-{
-    assert(y != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 U = { { {
-            V.vector4_u32[0],
-            *y,
-            V.vector4_u32[2],
-            V.vector4_u32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vld1q_lane_u32(y, *reinterpret_cast<const uint32x4_t*>(&V), 1));
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap y and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 2, 0, 1));
-    // Convert input to vector
-    XMVECTOR vTemp = _mm_load_ss(reinterpret_cast<const float*>(y));
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, vTemp);
-    // Swap y and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 2, 0, 1));
-    return vResult;
-#endif
-}
-
-// Sets the Z component of a vector to an integer value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetIntZPtr(FXMVECTOR V, const uint32_t* z) noexcept
-{
-    assert(z != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 U = { { {
-            V.vector4_u32[0],
-            V.vector4_u32[1],
-            *z,
-            V.vector4_u32[3]
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vld1q_lane_u32(z, *reinterpret_cast<const uint32x4_t*>(&V), 2));
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap z and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 0, 1, 2));
-    // Convert input to vector
-    XMVECTOR vTemp = _mm_load_ss(reinterpret_cast<const float*>(z));
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, vTemp);
-    // Swap z and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 0, 1, 2));
-    return vResult;
-#endif
-}
-
-// Sets the W component of a vector to an integer value passed by pointer
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorSetIntWPtr(FXMVECTOR V, const uint32_t* w) noexcept
-{
-    assert(w != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORU32 U = { { {
-            V.vector4_u32[0],
-            V.vector4_u32[1],
-            V.vector4_u32[2],
-            *w
-        } } };
-    return U.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vld1q_lane_u32(w, *reinterpret_cast<const uint32x4_t*>(&V), 3));
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap w and x
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 2, 1, 3));
-    // Convert input to vector
-    XMVECTOR vTemp = _mm_load_ss(reinterpret_cast<const float*>(w));
-    // Replace the x component
-    vResult = _mm_move_ss(vResult, vTemp);
-    // Swap w and x again
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(0, 2, 1, 3));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSwizzle
-        (
-                FXMVECTOR V,
-                uint32_t E0,
-                uint32_t E1,
-                uint32_t E2,
-                uint32_t E3
-        ) noexcept
-{
-    assert((E0 < 4) && (E1 < 4) && (E2 < 4) && (E3 < 4));
-    _Analysis_assume_((E0 < 4) && (E1 < 4) && (E2 < 4) && (E3 < 4));
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            V.vector4_f32[E0],
-            V.vector4_f32[E1],
-            V.vector4_f32[E2],
-            V.vector4_f32[E3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const uint32_t ControlElement[4] =
-    {
-        0x03020100, // XM_SWIZZLE_X
-        0x07060504, // XM_SWIZZLE_Y
-        0x0B0A0908, // XM_SWIZZLE_Z
-        0x0F0E0D0C, // XM_SWIZZLE_W
-    };
-
-    uint8x8x2_t tbl;
-    tbl.val[0] = vreinterpret_u8_f32(vget_low_f32(V));
-    tbl.val[1] = vreinterpret_u8_f32(vget_high_f32(V));
-
-    uint32x2_t idx = vcreate_u32(static_cast<uint64_t>(ControlElement[E0]) | (static_cast<uint64_t>(ControlElement[E1]) << 32));
-    const uint8x8_t rL = vtbl2_u8(tbl, vreinterpret_u8_u32(idx));
-
-    idx = vcreate_u32(static_cast<uint64_t>(ControlElement[E2]) | (static_cast<uint64_t>(ControlElement[E3]) << 32));
-    const uint8x8_t rH = vtbl2_u8(tbl, vreinterpret_u8_u32(idx));
-
-    return vcombine_f32(vreinterpret_f32_u8(rL), vreinterpret_f32_u8(rH));
-#elif defined(_XM_AVX_INTRINSICS_)
-    unsigned int elem[4] = { E0, E1, E2, E3 };
-    __m128i vControl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&elem[0]));
-    return _mm_permutevar_ps(V, vControl);
-#else
-    auto aPtr = reinterpret_cast<const uint32_t*>(&V);
-
-    XMVECTOR Result;
-    auto pWork = reinterpret_cast<uint32_t*>(&Result);
-
-    pWork[0] = aPtr[E0];
-    pWork[1] = aPtr[E1];
-    pWork[2] = aPtr[E2];
-    pWork[3] = aPtr[E3];
-
-    return Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-inline XMVECTOR XM_CALLCONV XMVectorPermute
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2,
-                uint32_t PermuteX,
-                uint32_t PermuteY,
-                uint32_t PermuteZ,
-                uint32_t PermuteW
-        ) noexcept
-{
-    assert(PermuteX <= 7 && PermuteY <= 7 && PermuteZ <= 7 && PermuteW <= 7);
-    _Analysis_assume_(PermuteX <= 7 && PermuteY <= 7 && PermuteZ <= 7 && PermuteW <= 7);
-
-#if defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    static const uint32_t ControlElement[8] =
-    {
-        0x03020100, // XM_PERMUTE_0X
-        0x07060504, // XM_PERMUTE_0Y
-        0x0B0A0908, // XM_PERMUTE_0Z
-        0x0F0E0D0C, // XM_PERMUTE_0W
-        0x13121110, // XM_PERMUTE_1X
-        0x17161514, // XM_PERMUTE_1Y
-        0x1B1A1918, // XM_PERMUTE_1Z
-        0x1F1E1D1C, // XM_PERMUTE_1W
-    };
-
-    uint8x8x4_t tbl;
-    tbl.val[0] = vreinterpret_u8_f32(vget_low_f32(V1));
-    tbl.val[1] = vreinterpret_u8_f32(vget_high_f32(V1));
-    tbl.val[2] = vreinterpret_u8_f32(vget_low_f32(V2));
-    tbl.val[3] = vreinterpret_u8_f32(vget_high_f32(V2));
-
-    uint32x2_t idx = vcreate_u32(static_cast<uint64_t>(ControlElement[PermuteX]) | (static_cast<uint64_t>(ControlElement[PermuteY]) << 32));
-    const uint8x8_t rL = vtbl4_u8(tbl, vreinterpret_u8_u32(idx));
-
-    idx = vcreate_u32(static_cast<uint64_t>(ControlElement[PermuteZ]) | (static_cast<uint64_t>(ControlElement[PermuteW]) << 32));
-    const uint8x8_t rH = vtbl4_u8(tbl, vreinterpret_u8_u32(idx));
-
-    return vcombine_f32(vreinterpret_f32_u8(rL), vreinterpret_f32_u8(rH));
-#elif defined(_XM_AVX_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    static const XMVECTORU32 three = { { { 3, 3, 3, 3 } } };
-
-    XM_ALIGNED_DATA(16) unsigned int elem[4] = { PermuteX, PermuteY, PermuteZ, PermuteW };
-    __m128i vControl = _mm_load_si128(reinterpret_cast<const __m128i*>(&elem[0]));
-
-    __m128i vSelect = _mm_cmpgt_epi32(vControl, three);
-    vControl = _mm_castps_si128(_mm_and_ps(_mm_castsi128_ps(vControl), three));
-
-    __m128 shuffled1 = _mm_permutevar_ps(V1, vControl);
-    __m128 shuffled2 = _mm_permutevar_ps(V2, vControl);
-
-    __m128 masked1 = _mm_andnot_ps(_mm_castsi128_ps(vSelect), shuffled1);
-    __m128 masked2 = _mm_and_ps(_mm_castsi128_ps(vSelect), shuffled2);
-
-    return _mm_or_ps(masked1, masked2);
-#else
-
-    const uint32_t* aPtr[2];
-    aPtr[0] = reinterpret_cast<const uint32_t*>(&V1);
-    aPtr[1] = reinterpret_cast<const uint32_t*>(&V2);
-
-    XMVECTOR Result;
-    auto pWork = reinterpret_cast<uint32_t*>(&Result);
-
-    const uint32_t i0 = PermuteX & 3;
-    const uint32_t vi0 = PermuteX >> 2;
-    pWork[0] = aPtr[vi0][i0];
-
-    const uint32_t i1 = PermuteY & 3;
-    const uint32_t vi1 = PermuteY >> 2;
-    pWork[1] = aPtr[vi1][i1];
-
-    const uint32_t i2 = PermuteZ & 3;
-    const uint32_t vi2 = PermuteZ >> 2;
-    pWork[2] = aPtr[vi2][i2];
-
-    const uint32_t i3 = PermuteW & 3;
-    const uint32_t vi3 = PermuteW >> 2;
-    pWork[3] = aPtr[vi3][i3];
-
-    return Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Define a control vector to be used in XMVectorSelect
-// operations.  The four integers specified in XMVectorSelectControl
-// serve as indices to select between components in two vectors.
-// The first index controls selection for the first component of
-// the vectors involved in a select operation, the second index
-// controls selection for the second component etc.  A value of
-// zero for an index causes the corresponding component from the first
-// vector to be selected whereas a one causes the component from the
-// second vector to be selected instead.
-
-inline XMVECTOR XM_CALLCONV XMVectorSelectControl
-        (
-                uint32_t VectorIndex0,
-                uint32_t VectorIndex1,
-                uint32_t VectorIndex2,
-                uint32_t VectorIndex3
-        ) noexcept
-{
-#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    // x=Index0,y=Index1,z=Index2,w=Index3
-    __m128i vTemp = _mm_set_epi32(static_cast<int>(VectorIndex3), static_cast<int>(VectorIndex2), static_cast<int>(VectorIndex1), static_cast<int>(VectorIndex0));
-    // Any non-zero entries become 0xFFFFFFFF else 0
-    vTemp = _mm_cmpgt_epi32(vTemp, g_XMZero);
-    return _mm_castsi128_ps(vTemp);
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    int32x2_t V0 = vcreate_s32(static_cast<uint64_t>(VectorIndex0) | (static_cast<uint64_t>(VectorIndex1) << 32));
-    int32x2_t V1 = vcreate_s32(static_cast<uint64_t>(VectorIndex2) | (static_cast<uint64_t>(VectorIndex3) << 32));
-    int32x4_t vTemp = vcombine_s32(V0, V1);
-    // Any non-zero entries become 0xFFFFFFFF else 0
-    return vreinterpretq_f32_u32(vcgtq_s32(vTemp, g_XMZero));
-#else
-    XMVECTOR    ControlVector;
-    const uint32_t  ControlElement[] =
-    {
-        XM_SELECT_0,
-        XM_SELECT_1
-    };
-
-    assert(VectorIndex0 < 2);
-    assert(VectorIndex1 < 2);
-    assert(VectorIndex2 < 2);
-    assert(VectorIndex3 < 2);
-    _Analysis_assume_(VectorIndex0 < 2);
-    _Analysis_assume_(VectorIndex1 < 2);
-    _Analysis_assume_(VectorIndex2 < 2);
-    _Analysis_assume_(VectorIndex3 < 2);
-
-    ControlVector.vector4_u32[0] = ControlElement[VectorIndex0];
-    ControlVector.vector4_u32[1] = ControlElement[VectorIndex1];
-    ControlVector.vector4_u32[2] = ControlElement[VectorIndex2];
-    ControlVector.vector4_u32[3] = ControlElement[VectorIndex3];
-
-    return ControlVector;
-
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSelect
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2,
-                FXMVECTOR Control
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Result = { { {
-            (V1.vector4_u32[0] & ~Control.vector4_u32[0]) | (V2.vector4_u32[0] & Control.vector4_u32[0]),
-            (V1.vector4_u32[1] & ~Control.vector4_u32[1]) | (V2.vector4_u32[1] & Control.vector4_u32[1]),
-            (V1.vector4_u32[2] & ~Control.vector4_u32[2]) | (V2.vector4_u32[2] & Control.vector4_u32[2]),
-            (V1.vector4_u32[3] & ~Control.vector4_u32[3]) | (V2.vector4_u32[3] & Control.vector4_u32[3]),
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vbslq_f32(vreinterpretq_u32_f32(Control), V2, V1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp1 = _mm_andnot_ps(Control, V1);
-    XMVECTOR vTemp2 = _mm_and_ps(V2, Control);
-    return _mm_or_ps(vTemp1, vTemp2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorMergeXY
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Result = { { {
-            V1.vector4_u32[0],
-            V2.vector4_u32[0],
-            V1.vector4_u32[1],
-            V2.vector4_u32[1],
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vzipq_f32(V1, V2).val[0];
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_unpacklo_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorMergeZW
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Result = { { {
-            V1.vector4_u32[2],
-            V2.vector4_u32[2],
-            V1.vector4_u32[3],
-            V2.vector4_u32[3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vzipq_f32(V1, V2).val[1];
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_unpackhi_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorShiftLeft(FXMVECTOR V1, FXMVECTOR V2, uint32_t Elements) noexcept
-{
-    assert(Elements < 4);
-    _Analysis_assume_(Elements < 4);
-    return XMVectorPermute(V1, V2, Elements, ((Elements)+1), ((Elements)+2), ((Elements)+3));
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorRotateLeft(FXMVECTOR V, uint32_t Elements) noexcept
-{
-    assert(Elements < 4);
-    _Analysis_assume_(Elements < 4);
-    return XMVectorSwizzle(V, Elements & 3, (Elements + 1) & 3, (Elements + 2) & 3, (Elements + 3) & 3);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorRotateRight(FXMVECTOR V, uint32_t Elements) noexcept
-{
-    assert(Elements < 4);
-    _Analysis_assume_(Elements < 4);
-    return XMVectorSwizzle(V, (4 - (Elements)) & 3, (5 - (Elements)) & 3, (6 - (Elements)) & 3, (7 - (Elements)) & 3);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorInsert(
-        FXMVECTOR VD, FXMVECTOR VS,
-        uint32_t VSLeftRotateElements,
-        uint32_t Select0, uint32_t Select1, uint32_t Select2, uint32_t Select3) noexcept
-{
-    XMVECTOR Control = XMVectorSelectControl(Select0 & 1, Select1 & 1, Select2 & 1, Select3 & 1);
-    return XMVectorSelect(VD, XMVectorRotateLeft(VS, VSLeftRotateElements), Control);
-}
-
-//------------------------------------------------------------------------------
-// Comparison operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            (V1.vector4_f32[0] == V2.vector4_f32[0]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[1] == V2.vector4_f32[1]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[2] == V2.vector4_f32[2]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[3] == V2.vector4_f32[3]) ? 0xFFFFFFFF : 0,
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vceqq_f32(V1, V2));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_cmpeq_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorEqualR
-        (
-                uint32_t* pCR,
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    assert(pCR != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-    uint32_t ux = (V1.vector4_f32[0] == V2.vector4_f32[0]) ? 0xFFFFFFFFU : 0;
-    uint32_t uy = (V1.vector4_f32[1] == V2.vector4_f32[1]) ? 0xFFFFFFFFU : 0;
-    uint32_t uz = (V1.vector4_f32[2] == V2.vector4_f32[2]) ? 0xFFFFFFFFU : 0;
-    uint32_t uw = (V1.vector4_f32[3] == V2.vector4_f32[3]) ? 0xFFFFFFFFU : 0;
-    uint32_t CR = 0;
-    if (ux & uy & uz & uw)
-    {
-        // All elements are greater
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!(ux | uy | uz | uw))
-    {
-        // All elements are not greater
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-
-    XMVECTORU32 Control = { { { ux, uy, uz, uw } } };
-    return Control;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vreinterpret_u8_u32(vget_low_u32(vResult)), vreinterpret_u8_u32(vget_high_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFU)
-    {
-        // All elements are equal
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        // All elements are not equal
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-    return vreinterpretq_f32_u32(vResult);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpeq_ps(V1, V2);
-    uint32_t CR = 0;
-    int iTest = _mm_movemask_ps(vTemp);
-    if (iTest == 0xf)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        // All elements are not greater
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Treat the components of the vectors as unsigned integers and
-// compare individual bits between the two.  This is useful for
-// comparing control vectors and result vectors returned from
-// other comparison operations.
-
-inline XMVECTOR XM_CALLCONV XMVectorEqualInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            (V1.vector4_u32[0] == V2.vector4_u32[0]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_u32[1] == V2.vector4_u32[1]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_u32[2] == V2.vector4_u32[2]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_u32[3] == V2.vector4_u32[3]) ? 0xFFFFFFFF : 0,
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vceqq_s32(vreinterpretq_s32_f32(V1), vreinterpretq_s32_f32(V2)));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorEqualIntR
-        (
-                uint32_t* pCR,
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    assert(pCR != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Control = XMVectorEqualInt(V1, V2);
-
-    *pCR = 0;
-    if (XMVector4EqualInt(Control, XMVectorTrueInt()))
-    {
-        // All elements are equal
-        *pCR |= XM_CRMASK_CR6TRUE;
-    }
-    else if (XMVector4EqualInt(Control, XMVectorFalseInt()))
-    {
-        // All elements are not equal
-        *pCR |= XM_CRMASK_CR6FALSE;
-    }
-    return Control;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2));
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFU)
-    {
-        // All elements are equal
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        // All elements are not equal
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-    return vreinterpretq_f32_u32(vResult);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    int iTemp = _mm_movemask_ps(_mm_castsi128_ps(V));
-    uint32_t CR = 0;
-    if (iTemp == 0x0F)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTemp)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorNearEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2,
-                FXMVECTOR Epsilon
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    float fDeltax = V1.vector4_f32[0] - V2.vector4_f32[0];
-    float fDeltay = V1.vector4_f32[1] - V2.vector4_f32[1];
-    float fDeltaz = V1.vector4_f32[2] - V2.vector4_f32[2];
-    float fDeltaw = V1.vector4_f32[3] - V2.vector4_f32[3];
-
-    fDeltax = fabsf(fDeltax);
-    fDeltay = fabsf(fDeltay);
-    fDeltaz = fabsf(fDeltaz);
-    fDeltaw = fabsf(fDeltaw);
-
-    XMVECTORU32 Control = { { {
-            (fDeltax <= Epsilon.vector4_f32[0]) ? 0xFFFFFFFFU : 0,
-            (fDeltay <= Epsilon.vector4_f32[1]) ? 0xFFFFFFFFU : 0,
-            (fDeltaz <= Epsilon.vector4_f32[2]) ? 0xFFFFFFFFU : 0,
-            (fDeltaw <= Epsilon.vector4_f32[3]) ? 0xFFFFFFFFU : 0,
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t vDelta = vsubq_f32(V1, V2);
-#if defined(_MSC_VER) && !defined(__clang__)
-    return vacleq_f32(vDelta, Epsilon);
-#else
-    return vreinterpretq_f32_u32(vcleq_f32(vabsq_f32(vDelta), Epsilon));
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Get the difference
-    XMVECTOR vDelta = _mm_sub_ps(V1, V2);
-    // Get the absolute value of the difference
-    XMVECTOR vTemp = _mm_setzero_ps();
-    vTemp = _mm_sub_ps(vTemp, vDelta);
-    vTemp = _mm_max_ps(vTemp, vDelta);
-    vTemp = _mm_cmple_ps(vTemp, Epsilon);
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorNotEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            (V1.vector4_f32[0] != V2.vector4_f32[0]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[1] != V2.vector4_f32[1]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[2] != V2.vector4_f32[2]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[3] != V2.vector4_f32[3]) ? 0xFFFFFFFF : 0,
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vmvnq_u32(vceqq_f32(V1, V2)));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_cmpneq_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorNotEqualInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            (V1.vector4_u32[0] != V2.vector4_u32[0]) ? 0xFFFFFFFFU : 0,
-            (V1.vector4_u32[1] != V2.vector4_u32[1]) ? 0xFFFFFFFFU : 0,
-            (V1.vector4_u32[2] != V2.vector4_u32[2]) ? 0xFFFFFFFFU : 0,
-            (V1.vector4_u32[3] != V2.vector4_u32[3]) ? 0xFFFFFFFFU : 0
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vmvnq_u32(
-            vceqq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2))));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return _mm_xor_ps(_mm_castsi128_ps(V), g_XMNegOneMask);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorGreater
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            (V1.vector4_f32[0] > V2.vector4_f32[0]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[1] > V2.vector4_f32[1]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[2] > V2.vector4_f32[2]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[3] > V2.vector4_f32[3]) ? 0xFFFFFFFF : 0
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vcgtq_f32(V1, V2));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_cmpgt_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorGreaterR
-        (
-                uint32_t* pCR,
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    assert(pCR != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t ux = (V1.vector4_f32[0] > V2.vector4_f32[0]) ? 0xFFFFFFFFU : 0;
-    uint32_t uy = (V1.vector4_f32[1] > V2.vector4_f32[1]) ? 0xFFFFFFFFU : 0;
-    uint32_t uz = (V1.vector4_f32[2] > V2.vector4_f32[2]) ? 0xFFFFFFFFU : 0;
-    uint32_t uw = (V1.vector4_f32[3] > V2.vector4_f32[3]) ? 0xFFFFFFFFU : 0;
-    uint32_t CR = 0;
-    if (ux & uy & uz & uw)
-    {
-        // All elements are greater
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!(ux | uy | uz | uw))
-    {
-        // All elements are not greater
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-
-    XMVECTORU32 Control = { { { ux, uy, uz, uw } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgtq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFU)
-    {
-        // All elements are greater
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        // All elements are not greater
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-    return vreinterpretq_f32_u32(vResult);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpgt_ps(V1, V2);
-    uint32_t CR = 0;
-    int iTest = _mm_movemask_ps(vTemp);
-    if (iTest == 0xf)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        // All elements are not greater
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorGreaterOrEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            (V1.vector4_f32[0] >= V2.vector4_f32[0]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[1] >= V2.vector4_f32[1]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[2] >= V2.vector4_f32[2]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[3] >= V2.vector4_f32[3]) ? 0xFFFFFFFF : 0
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vcgeq_f32(V1, V2));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_cmpge_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorGreaterOrEqualR
-        (
-                uint32_t* pCR,
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    assert(pCR != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t ux = (V1.vector4_f32[0] >= V2.vector4_f32[0]) ? 0xFFFFFFFFU : 0;
-    uint32_t uy = (V1.vector4_f32[1] >= V2.vector4_f32[1]) ? 0xFFFFFFFFU : 0;
-    uint32_t uz = (V1.vector4_f32[2] >= V2.vector4_f32[2]) ? 0xFFFFFFFFU : 0;
-    uint32_t uw = (V1.vector4_f32[3] >= V2.vector4_f32[3]) ? 0xFFFFFFFFU : 0;
-    uint32_t CR = 0;
-    if (ux & uy & uz & uw)
-    {
-        // All elements are greater
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!(ux | uy | uz | uw))
-    {
-        // All elements are not greater
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-
-    XMVECTORU32 Control = { { { ux, uy, uz, uw } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgeq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFU)
-    {
-        // All elements are greater or equal
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        // All elements are not greater or equal
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-    return vreinterpretq_f32_u32(vResult);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpge_ps(V1, V2);
-    uint32_t CR = 0;
-    int iTest = _mm_movemask_ps(vTemp);
-    if (iTest == 0xf)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        // All elements are not greater
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    *pCR = CR;
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorLess
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            (V1.vector4_f32[0] < V2.vector4_f32[0]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[1] < V2.vector4_f32[1]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[2] < V2.vector4_f32[2]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[3] < V2.vector4_f32[3]) ? 0xFFFFFFFF : 0
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vcltq_f32(V1, V2));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_cmplt_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorLessOrEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            (V1.vector4_f32[0] <= V2.vector4_f32[0]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[1] <= V2.vector4_f32[1]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[2] <= V2.vector4_f32[2]) ? 0xFFFFFFFF : 0,
-            (V1.vector4_f32[3] <= V2.vector4_f32[3]) ? 0xFFFFFFFF : 0
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vcleq_f32(V1, V2));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_cmple_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorInBounds
-        (
-                FXMVECTOR V,
-                FXMVECTOR Bounds
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            (V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) ? 0xFFFFFFFF : 0,
-            (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1]) ? 0xFFFFFFFF : 0,
-            (V.vector4_f32[2] <= Bounds.vector4_f32[2] && V.vector4_f32[2] >= -Bounds.vector4_f32[2]) ? 0xFFFFFFFF : 0,
-            (V.vector4_f32[3] <= Bounds.vector4_f32[3] && V.vector4_f32[3] >= -Bounds.vector4_f32[3]) ? 0xFFFFFFFF : 0
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Test if less than or equal
-    uint32x4_t vTemp1 = vcleq_f32(V, Bounds);
-    // Negate the bounds
-    uint32x4_t vTemp2 = vreinterpretq_u32_f32(vnegq_f32(Bounds));
-    // Test if greater or equal (Reversed)
-    vTemp2 = vcleq_f32(vreinterpretq_f32_u32(vTemp2), V);
-    // Blend answers
-    vTemp1 = vandq_u32(vTemp1, vTemp2);
-    return vreinterpretq_f32_u32(vTemp1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Test if less than or equal
-    XMVECTOR vTemp1 = _mm_cmple_ps(V, Bounds);
-    // Negate the bounds
-    XMVECTOR vTemp2 = _mm_mul_ps(Bounds, g_XMNegativeOne);
-    // Test if greater or equal (Reversed)
-    vTemp2 = _mm_cmple_ps(vTemp2, V);
-    // Blend answers
-    vTemp1 = _mm_and_ps(vTemp1, vTemp2);
-    return vTemp1;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMVectorInBoundsR
-        (
-                uint32_t* pCR,
-                FXMVECTOR V,
-                FXMVECTOR Bounds
-        ) noexcept
-{
-    assert(pCR != nullptr);
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t ux = (V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) ? 0xFFFFFFFFU : 0;
-    uint32_t uy = (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1]) ? 0xFFFFFFFFU : 0;
-    uint32_t uz = (V.vector4_f32[2] <= Bounds.vector4_f32[2] && V.vector4_f32[2] >= -Bounds.vector4_f32[2]) ? 0xFFFFFFFFU : 0;
-    uint32_t uw = (V.vector4_f32[3] <= Bounds.vector4_f32[3] && V.vector4_f32[3] >= -Bounds.vector4_f32[3]) ? 0xFFFFFFFFU : 0;
-
-    uint32_t CR = 0;
-    if (ux & uy & uz & uw)
-    {
-        // All elements are in bounds
-        CR = XM_CRMASK_CR6BOUNDS;
-    }
-    *pCR = CR;
-
-    XMVECTORU32 Control = { { { ux, uy, uz, uw } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Test if less than or equal
-    uint32x4_t vTemp1 = vcleq_f32(V, Bounds);
-    // Negate the bounds
-    uint32x4_t vTemp2 = vreinterpretq_u32_f32(vnegq_f32(Bounds));
-    // Test if greater or equal (Reversed)
-    vTemp2 = vcleq_f32(vreinterpretq_f32_u32(vTemp2), V);
-    // Blend answers
-    vTemp1 = vandq_u32(vTemp1, vTemp2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vTemp1)), vget_high_u8(vreinterpretq_u8_u32(vTemp1)));
-    uint16x4x2_t vTemp3 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp3.val[1]), 1);
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFU)
-    {
-        // All elements are in bounds
-        CR = XM_CRMASK_CR6BOUNDS;
-    }
-    *pCR = CR;
-    return vreinterpretq_f32_u32(vTemp1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Test if less than or equal
-    XMVECTOR vTemp1 = _mm_cmple_ps(V, Bounds);
-    // Negate the bounds
-    XMVECTOR vTemp2 = _mm_mul_ps(Bounds, g_XMNegativeOne);
-    // Test if greater or equal (Reversed)
-    vTemp2 = _mm_cmple_ps(vTemp2, V);
-    // Blend answers
-    vTemp1 = _mm_and_ps(vTemp1, vTemp2);
-
-    uint32_t CR = 0;
-    if (_mm_movemask_ps(vTemp1) == 0xf)
-    {
-        // All elements are in bounds
-        CR = XM_CRMASK_CR6BOUNDS;
-    }
-    *pCR = CR;
-    return vTemp1;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(push)
-#pragma float_control(precise, on)
-#endif
-
-inline XMVECTOR XM_CALLCONV XMVectorIsNaN(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            XMISNAN(V.vector4_f32[0]) ? 0xFFFFFFFFU : 0,
-            XMISNAN(V.vector4_f32[1]) ? 0xFFFFFFFFU : 0,
-            XMISNAN(V.vector4_f32[2]) ? 0xFFFFFFFFU : 0,
-            XMISNAN(V.vector4_f32[3]) ? 0xFFFFFFFFU : 0
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Test against itself. NaN is always not equal
-    uint32x4_t vTempNan = vceqq_f32(V, V);
-    // Flip results
-    return vreinterpretq_f32_u32(vmvnq_u32(vTempNan));
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Test against itself. NaN is always not equal
-    return _mm_cmpneq_ps(V, V);
-#endif
-}
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorIsInfinite(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Control = { { {
-            XMISINF(V.vector4_f32[0]) ? 0xFFFFFFFFU : 0,
-            XMISINF(V.vector4_f32[1]) ? 0xFFFFFFFFU : 0,
-            XMISINF(V.vector4_f32[2]) ? 0xFFFFFFFFU : 0,
-            XMISINF(V.vector4_f32[3]) ? 0xFFFFFFFFU : 0
-        } } };
-    return Control.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Mask off the sign bit
-    uint32x4_t vTemp = vandq_u32(vreinterpretq_u32_f32(V), g_XMAbsMask);
-    // Compare to infinity
-    vTemp = vceqq_f32(vreinterpretq_f32_u32(vTemp), g_XMInfinity);
-    // If any are infinity, the signs are true.
-    return vreinterpretq_f32_u32(vTemp);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Mask off the sign bit
-    __m128 vTemp = _mm_and_ps(V, g_XMAbsMask);
-    // Compare to infinity
-    vTemp = _mm_cmpeq_ps(vTemp, g_XMInfinity);
-    // If any are infinity, the signs are true.
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Rounding and clamping operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorMin
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            (V1.vector4_f32[0] < V2.vector4_f32[0]) ? V1.vector4_f32[0] : V2.vector4_f32[0],
-            (V1.vector4_f32[1] < V2.vector4_f32[1]) ? V1.vector4_f32[1] : V2.vector4_f32[1],
-            (V1.vector4_f32[2] < V2.vector4_f32[2]) ? V1.vector4_f32[2] : V2.vector4_f32[2],
-            (V1.vector4_f32[3] < V2.vector4_f32[3]) ? V1.vector4_f32[3] : V2.vector4_f32[3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vminq_f32(V1, V2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_min_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorMax
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            (V1.vector4_f32[0] > V2.vector4_f32[0]) ? V1.vector4_f32[0] : V2.vector4_f32[0],
-            (V1.vector4_f32[1] > V2.vector4_f32[1]) ? V1.vector4_f32[1] : V2.vector4_f32[1],
-            (V1.vector4_f32[2] > V2.vector4_f32[2]) ? V1.vector4_f32[2] : V2.vector4_f32[2],
-            (V1.vector4_f32[3] > V2.vector4_f32[3]) ? V1.vector4_f32[3] : V2.vector4_f32[3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vmaxq_f32(V1, V2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_max_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-namespace Internal
-{
-    // Round to nearest (even) a.k.a. banker's rounding
-    inline float round_to_nearest(float x) noexcept
-    {
-        float i = floorf(x);
-        x -= i;
-        if (x < 0.5f)
-            return i;
-        if (x > 0.5f)
-            return i + 1.f;
-
-        float int_part;
-        (void)modff(i / 2.f, &int_part);
-        if ((2.f * int_part) == i)
-        {
-            return i;
-        }
-
-        return i + 1.f;
-    }
-}
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(push)
-#pragma float_control(precise, on)
-#endif
-
-inline XMVECTOR XM_CALLCONV XMVectorRound(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            Internal::round_to_nearest(V.vector4_f32[0]),
-            Internal::round_to_nearest(V.vector4_f32[1]),
-            Internal::round_to_nearest(V.vector4_f32[2]),
-            Internal::round_to_nearest(V.vector4_f32[3])
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    return vrndnq_f32(V);
-#else
-    uint32x4_t sign = vandq_u32(vreinterpretq_u32_f32(V), g_XMNegativeZero);
-    float32x4_t sMagic = vreinterpretq_f32_u32(vorrq_u32(g_XMNoFraction, sign));
-    float32x4_t R1 = vaddq_f32(V, sMagic);
-    R1 = vsubq_f32(R1, sMagic);
-    float32x4_t R2 = vabsq_f32(V);
-    uint32x4_t mask = vcleq_f32(R2, g_XMNoFraction);
-    return vbslq_f32(mask, R1, V);
-#endif
-#elif defined(_XM_SSE4_INTRINSICS_)
-    return _mm_round_ps(V, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 sign = _mm_and_ps(V, g_XMNegativeZero);
-    __m128 sMagic = _mm_or_ps(g_XMNoFraction, sign);
-    __m128 R1 = _mm_add_ps(V, sMagic);
-    R1 = _mm_sub_ps(R1, sMagic);
-    __m128 R2 = _mm_and_ps(V, g_XMAbsMask);
-    __m128 mask = _mm_cmple_ps(R2, g_XMNoFraction);
-    R2 = _mm_andnot_ps(mask, V);
-    R1 = _mm_and_ps(R1, mask);
-    XMVECTOR vResult = _mm_xor_ps(R1, R2);
-    return vResult;
-#endif
-}
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorTruncate(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTOR Result;
-    uint32_t     i;
-
-    // Avoid C4701
-    Result.vector4_f32[0] = 0.0f;
-
-    for (i = 0; i < 4; i++)
-    {
-        if (XMISNAN(V.vector4_f32[i]))
-        {
-            Result.vector4_u32[i] = 0x7FC00000;
-        }
-        else if (fabsf(V.vector4_f32[i]) < 8388608.0f)
-        {
-            Result.vector4_f32[i] = static_cast<float>(static_cast<int32_t>(V.vector4_f32[i]));
-        }
-        else
-        {
-            Result.vector4_f32[i] = V.vector4_f32[i];
-        }
-    }
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    return vrndq_f32(V);
-#else
-    float32x4_t vTest = vabsq_f32(V);
-    vTest = vreinterpretq_f32_u32(vcltq_f32(vTest, g_XMNoFraction));
-
-    int32x4_t vInt = vcvtq_s32_f32(V);
-    float32x4_t vResult = vcvtq_f32_s32(vInt);
-
-    // All numbers less than 8388608 will use the round to int
-    // All others, use the ORIGINAL value
-    return vbslq_f32(vreinterpretq_u32_f32(vTest), vResult, V);
-#endif
-#elif defined(_XM_SSE4_INTRINSICS_)
-    return _mm_round_ps(V, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // To handle NAN, INF and numbers greater than 8388608, use masking
-    // Get the abs value
-    __m128i vTest = _mm_and_si128(_mm_castps_si128(V), g_XMAbsMask);
-    // Test for greater than 8388608 (All floats with NO fractionals, NAN and INF
-    vTest = _mm_cmplt_epi32(vTest, g_XMNoFraction);
-    // Convert to int and back to float for rounding with truncation
-    __m128i vInt = _mm_cvttps_epi32(V);
-    // Convert back to floats
-    XMVECTOR vResult = _mm_cvtepi32_ps(vInt);
-    // All numbers less than 8388608 will use the round to int
-    vResult = _mm_and_ps(vResult, _mm_castsi128_ps(vTest));
-    // All others, use the ORIGINAL value
-    vTest = _mm_andnot_si128(vTest, _mm_castps_si128(V));
-    vResult = _mm_or_ps(vResult, _mm_castsi128_ps(vTest));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorFloor(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            floorf(V.vector4_f32[0]),
-            floorf(V.vector4_f32[1]),
-            floorf(V.vector4_f32[2]),
-            floorf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    return vrndmq_f32(V);
-#else
-    float32x4_t vTest = vabsq_f32(V);
-    vTest = vreinterpretq_f32_u32(vcltq_f32(vTest, g_XMNoFraction));
-    // Truncate
-    int32x4_t vInt = vcvtq_s32_f32(V);
-    float32x4_t vResult = vcvtq_f32_s32(vInt);
-    uint32x4_t vLargerMask = vcgtq_f32(vResult, V);
-    // 0 -> 0, 0xffffffff -> -1.0f
-    float32x4_t vLarger = vcvtq_f32_s32(vreinterpretq_s32_u32(vLargerMask));
-    vResult = vaddq_f32(vResult, vLarger);
-    // All numbers less than 8388608 will use the round to int
-    // All others, use the ORIGINAL value
-    return vbslq_f32(vreinterpretq_u32_f32(vTest), vResult, V);
-#endif
-#elif defined(_XM_SSE4_INTRINSICS_)
-    return _mm_floor_ps(V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // To handle NAN, INF and numbers greater than 8388608, use masking
-    __m128i vTest = _mm_and_si128(_mm_castps_si128(V), g_XMAbsMask);
-    vTest = _mm_cmplt_epi32(vTest, g_XMNoFraction);
-    // Truncate
-    __m128i vInt = _mm_cvttps_epi32(V);
-    XMVECTOR vResult = _mm_cvtepi32_ps(vInt);
-    __m128 vLarger = _mm_cmpgt_ps(vResult, V);
-    // 0 -> 0, 0xffffffff -> -1.0f
-    vLarger = _mm_cvtepi32_ps(_mm_castps_si128(vLarger));
-    vResult = _mm_add_ps(vResult, vLarger);
-    // All numbers less than 8388608 will use the round to int
-    vResult = _mm_and_ps(vResult, _mm_castsi128_ps(vTest));
-    // All others, use the ORIGINAL value
-    vTest = _mm_andnot_si128(vTest, _mm_castps_si128(V));
-    vResult = _mm_or_ps(vResult, _mm_castsi128_ps(vTest));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorCeiling(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            ceilf(V.vector4_f32[0]),
-            ceilf(V.vector4_f32[1]),
-            ceilf(V.vector4_f32[2]),
-            ceilf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    return vrndpq_f32(V);
-#else
-    float32x4_t vTest = vabsq_f32(V);
-    vTest = vreinterpretq_f32_u32(vcltq_f32(vTest, g_XMNoFraction));
-    // Truncate
-    int32x4_t vInt = vcvtq_s32_f32(V);
-    float32x4_t vResult = vcvtq_f32_s32(vInt);
-    uint32x4_t vSmallerMask = vcltq_f32(vResult, V);
-    // 0 -> 0, 0xffffffff -> -1.0f
-    float32x4_t vSmaller = vcvtq_f32_s32(vreinterpretq_s32_u32(vSmallerMask));
-    vResult = vsubq_f32(vResult, vSmaller);
-    // All numbers less than 8388608 will use the round to int
-    // All others, use the ORIGINAL value
-    return vbslq_f32(vreinterpretq_u32_f32(vTest), vResult, V);
-#endif
-#elif defined(_XM_SSE4_INTRINSICS_)
-    return _mm_ceil_ps(V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // To handle NAN, INF and numbers greater than 8388608, use masking
-    __m128i vTest = _mm_and_si128(_mm_castps_si128(V), g_XMAbsMask);
-    vTest = _mm_cmplt_epi32(vTest, g_XMNoFraction);
-    // Truncate
-    __m128i vInt = _mm_cvttps_epi32(V);
-    XMVECTOR vResult = _mm_cvtepi32_ps(vInt);
-    __m128 vSmaller = _mm_cmplt_ps(vResult, V);
-    // 0 -> 0, 0xffffffff -> -1.0f
-    vSmaller = _mm_cvtepi32_ps(_mm_castps_si128(vSmaller));
-    vResult = _mm_sub_ps(vResult, vSmaller);
-    // All numbers less than 8388608 will use the round to int
-    vResult = _mm_and_ps(vResult, _mm_castsi128_ps(vTest));
-    // All others, use the ORIGINAL value
-    vTest = _mm_andnot_si128(vTest, _mm_castps_si128(V));
-    vResult = _mm_or_ps(vResult, _mm_castsi128_ps(vTest));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorClamp
-        (
-                FXMVECTOR V,
-                FXMVECTOR Min,
-                FXMVECTOR Max
-        ) noexcept
-{
-    assert(XMVector4LessOrEqual(Min, Max));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-    Result = XMVectorMax(Min, V);
-    Result = XMVectorMin(Max, Result);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t vResult = vmaxq_f32(Min, V);
-    vResult = vminq_f32(Max, vResult);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult;
-    vResult = _mm_max_ps(Min, V);
-    vResult = _mm_min_ps(Max, vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSaturate(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    const XMVECTOR Zero = XMVectorZero();
-
-    return XMVectorClamp(V, Zero, g_XMOne.v);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Set <0 to 0
-    float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(0));
-    // Set>1 to 1
-    return vminq_f32(vResult, vdupq_n_f32(1.0f));
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Set <0 to 0
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    // Set>1 to 1
-    return _mm_min_ps(vResult, g_XMOne);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Bitwise logical operations
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorAndInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Result = { { {
-            V1.vector4_u32[0] & V2.vector4_u32[0],
-            V1.vector4_u32[1] & V2.vector4_u32[1],
-            V1.vector4_u32[2] & V2.vector4_u32[2],
-            V1.vector4_u32[3] & V2.vector4_u32[3]
-        } } };
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2)));
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_and_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorAndCInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Result = { { {
-            V1.vector4_u32[0] & ~V2.vector4_u32[0],
-            V1.vector4_u32[1] & ~V2.vector4_u32[1],
-            V1.vector4_u32[2] & ~V2.vector4_u32[2],
-            V1.vector4_u32[3] & ~V2.vector4_u32[3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2)));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_andnot_si128(_mm_castps_si128(V2), _mm_castps_si128(V1));
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorOrInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Result = { { {
-            V1.vector4_u32[0] | V2.vector4_u32[0],
-            V1.vector4_u32[1] | V2.vector4_u32[1],
-            V1.vector4_u32[2] | V2.vector4_u32[2],
-            V1.vector4_u32[3] | V2.vector4_u32[3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2)));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_or_si128(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorNorInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Result = { { {
-            ~(V1.vector4_u32[0] | V2.vector4_u32[0]),
-            ~(V1.vector4_u32[1] | V2.vector4_u32[1]),
-            ~(V1.vector4_u32[2] | V2.vector4_u32[2]),
-            ~(V1.vector4_u32[3] | V2.vector4_u32[3])
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t Result = vorrq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2));
-    return vreinterpretq_f32_u32(vbicq_u32(g_XMNegOneMask, Result));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i Result;
-    Result = _mm_or_si128(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    Result = _mm_andnot_si128(Result, g_XMNegOneMask);
-    return _mm_castsi128_ps(Result);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorXorInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORU32 Result = { { {
-            V1.vector4_u32[0] ^ V2.vector4_u32[0],
-            V1.vector4_u32[1] ^ V2.vector4_u32[1],
-            V1.vector4_u32[2] ^ V2.vector4_u32[2],
-            V1.vector4_u32[3] ^ V2.vector4_u32[3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2)));
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i V = _mm_xor_si128(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return _mm_castsi128_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Computation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorNegate(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            -V.vector4_f32[0],
-            -V.vector4_f32[1],
-            -V.vector4_f32[2],
-            -V.vector4_f32[3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vnegq_f32(V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR Z;
-
-    Z = _mm_setzero_ps();
-
-    return _mm_sub_ps(Z, V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorAdd
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            V1.vector4_f32[0] + V2.vector4_f32[0],
-            V1.vector4_f32[1] + V2.vector4_f32[1],
-            V1.vector4_f32[2] + V2.vector4_f32[2],
-            V1.vector4_f32[3] + V2.vector4_f32[3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vaddq_f32(V1, V2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_add_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSum(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result;
-    Result.f[0] =
-        Result.f[1] =
-        Result.f[2] =
-        Result.f[3] = V.vector4_f32[0] + V.vector4_f32[1] + V.vector4_f32[2] + V.vector4_f32[3];
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    float32x4_t vTemp = vpaddq_f32(V, V);
-    return vpaddq_f32(vTemp, vTemp);
-#else
-    float32x2_t v1 = vget_low_f32(V);
-    float32x2_t v2 = vget_high_f32(V);
-    v1 = vadd_f32(v1, v2);
-    v1 = vpadd_f32(v1, v1);
-    return vcombine_f32(v1, v1);
-#endif
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vTemp = _mm_hadd_ps(V, V);
-    return _mm_hadd_ps(vTemp, vTemp);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 3, 0, 1));
-    XMVECTOR vTemp2 = _mm_add_ps(V, vTemp);
-    vTemp = XM_PERMUTE_PS(vTemp2, _MM_SHUFFLE(1, 0, 3, 2));
-    return _mm_add_ps(vTemp, vTemp2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorAddAngles
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    const XMVECTOR Zero = XMVectorZero();
-
-    // Add the given angles together.  If the range of V1 is such
-    // that -Pi <= V1 < Pi and the range of V2 is such that
-    // -2Pi <= V2 <= 2Pi, then the range of the resulting angle
-    // will be -Pi <= Result < Pi.
-    XMVECTOR Result = XMVectorAdd(V1, V2);
-
-    XMVECTOR Mask = XMVectorLess(Result, g_XMNegativePi.v);
-    XMVECTOR Offset = XMVectorSelect(Zero, g_XMTwoPi.v, Mask);
-
-    Mask = XMVectorGreaterOrEqual(Result, g_XMPi.v);
-    Offset = XMVectorSelect(Offset, g_XMNegativeTwoPi.v, Mask);
-
-    Result = XMVectorAdd(Result, Offset);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Adjust the angles
-    float32x4_t vResult = vaddq_f32(V1, V2);
-    // Less than Pi?
-    uint32x4_t vOffset = vcltq_f32(vResult, g_XMNegativePi);
-    vOffset = vandq_u32(vOffset, g_XMTwoPi);
-    // Add 2Pi to all entries less than -Pi
-    vResult = vaddq_f32(vResult, vreinterpretq_f32_u32(vOffset));
-    // Greater than or equal to Pi?
-    vOffset = vcgeq_f32(vResult, g_XMPi);
-    vOffset = vandq_u32(vOffset, g_XMTwoPi);
-    // Sub 2Pi to all entries greater than Pi
-    vResult = vsubq_f32(vResult, vreinterpretq_f32_u32(vOffset));
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Adjust the angles
-    XMVECTOR vResult = _mm_add_ps(V1, V2);
-    // Less than Pi?
-    XMVECTOR vOffset = _mm_cmplt_ps(vResult, g_XMNegativePi);
-    vOffset = _mm_and_ps(vOffset, g_XMTwoPi);
-    // Add 2Pi to all entries less than -Pi
-    vResult = _mm_add_ps(vResult, vOffset);
-    // Greater than or equal to Pi?
-    vOffset = _mm_cmpge_ps(vResult, g_XMPi);
-    vOffset = _mm_and_ps(vOffset, g_XMTwoPi);
-    // Sub 2Pi to all entries greater than Pi
-    vResult = _mm_sub_ps(vResult, vOffset);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSubtract
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            V1.vector4_f32[0] - V2.vector4_f32[0],
-            V1.vector4_f32[1] - V2.vector4_f32[1],
-            V1.vector4_f32[2] - V2.vector4_f32[2],
-            V1.vector4_f32[3] - V2.vector4_f32[3]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vsubq_f32(V1, V2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_sub_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSubtractAngles
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    const XMVECTOR Zero = XMVectorZero();
-
-    // Subtract the given angles.  If the range of V1 is such
-    // that -Pi <= V1 < Pi and the range of V2 is such that
-    // -2Pi <= V2 <= 2Pi, then the range of the resulting angle
-    // will be -Pi <= Result < Pi.
-    XMVECTOR Result = XMVectorSubtract(V1, V2);
-
-    XMVECTOR Mask = XMVectorLess(Result, g_XMNegativePi.v);
-    XMVECTOR Offset = XMVectorSelect(Zero, g_XMTwoPi.v, Mask);
-
-    Mask = XMVectorGreaterOrEqual(Result, g_XMPi.v);
-    Offset = XMVectorSelect(Offset, g_XMNegativeTwoPi.v, Mask);
-
-    Result = XMVectorAdd(Result, Offset);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Adjust the angles
-    XMVECTOR vResult = vsubq_f32(V1, V2);
-    // Less than Pi?
-    uint32x4_t vOffset = vcltq_f32(vResult, g_XMNegativePi);
-    vOffset = vandq_u32(vOffset, g_XMTwoPi);
-    // Add 2Pi to all entries less than -Pi
-    vResult = vaddq_f32(vResult, vreinterpretq_f32_u32(vOffset));
-    // Greater than or equal to Pi?
-    vOffset = vcgeq_f32(vResult, g_XMPi);
-    vOffset = vandq_u32(vOffset, g_XMTwoPi);
-    // Sub 2Pi to all entries greater than Pi
-    vResult = vsubq_f32(vResult, vreinterpretq_f32_u32(vOffset));
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Adjust the angles
-    XMVECTOR vResult = _mm_sub_ps(V1, V2);
-    // Less than Pi?
-    XMVECTOR vOffset = _mm_cmplt_ps(vResult, g_XMNegativePi);
-    vOffset = _mm_and_ps(vOffset, g_XMTwoPi);
-    // Add 2Pi to all entries less than -Pi
-    vResult = _mm_add_ps(vResult, vOffset);
-    // Greater than or equal to Pi?
-    vOffset = _mm_cmpge_ps(vResult, g_XMPi);
-    vOffset = _mm_and_ps(vOffset, g_XMTwoPi);
-    // Sub 2Pi to all entries greater than Pi
-    vResult = _mm_sub_ps(vResult, vOffset);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorMultiply
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            V1.vector4_f32[0] * V2.vector4_f32[0],
-            V1.vector4_f32[1] * V2.vector4_f32[1],
-            V1.vector4_f32[2] * V2.vector4_f32[2],
-            V1.vector4_f32[3] * V2.vector4_f32[3]
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vmulq_f32(V1, V2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_mul_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorMultiplyAdd
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2,
-                FXMVECTOR V3
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            V1.vector4_f32[0] * V2.vector4_f32[0] + V3.vector4_f32[0],
-            V1.vector4_f32[1] * V2.vector4_f32[1] + V3.vector4_f32[1],
-            V1.vector4_f32[2] * V2.vector4_f32[2] + V3.vector4_f32[2],
-            V1.vector4_f32[3] * V2.vector4_f32[3] + V3.vector4_f32[3]
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    return vfmaq_f32(V3, V1, V2);
-#else
-    return vmlaq_f32(V3, V1, V2);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    return XM_FMADD_PS(V1, V2, V3);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorDivide
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            V1.vector4_f32[0] / V2.vector4_f32[0],
-            V1.vector4_f32[1] / V2.vector4_f32[1],
-            V1.vector4_f32[2] / V2.vector4_f32[2],
-            V1.vector4_f32[3] / V2.vector4_f32[3]
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    return vdivq_f32(V1, V2);
-#else
-    // 2 iterations of Newton-Raphson refinement of reciprocal
-    float32x4_t Reciprocal = vrecpeq_f32(V2);
-    float32x4_t S = vrecpsq_f32(Reciprocal, V2);
-    Reciprocal = vmulq_f32(S, Reciprocal);
-    S = vrecpsq_f32(Reciprocal, V2);
-    Reciprocal = vmulq_f32(S, Reciprocal);
-    return vmulq_f32(V1, Reciprocal);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_div_ps(V1, V2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorNegativeMultiplySubtract
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2,
-                FXMVECTOR V3
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            V3.vector4_f32[0] - (V1.vector4_f32[0] * V2.vector4_f32[0]),
-            V3.vector4_f32[1] - (V1.vector4_f32[1] * V2.vector4_f32[1]),
-            V3.vector4_f32[2] - (V1.vector4_f32[2] * V2.vector4_f32[2]),
-            V3.vector4_f32[3] - (V1.vector4_f32[3] * V2.vector4_f32[3])
-        } } };
-    return Result;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    return vfmsq_f32(V3, V1, V2);
-#else
-    return vmlsq_f32(V3, V1, V2);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    return XM_FNMADD_PS(V1, V2, V3);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorScale
-        (
-                FXMVECTOR V,
-                float    ScaleFactor
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            V.vector4_f32[0] * ScaleFactor,
-            V.vector4_f32[1] * ScaleFactor,
-            V.vector4_f32[2] * ScaleFactor,
-            V.vector4_f32[3] * ScaleFactor
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vmulq_n_f32(V, ScaleFactor);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = _mm_set_ps1(ScaleFactor);
-    return _mm_mul_ps(vResult, V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorReciprocalEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            1.f / V.vector4_f32[0],
-            1.f / V.vector4_f32[1],
-            1.f / V.vector4_f32[2],
-            1.f / V.vector4_f32[3]
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vrecpeq_f32(V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_rcp_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorReciprocal(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            1.f / V.vector4_f32[0],
-            1.f / V.vector4_f32[1],
-            1.f / V.vector4_f32[2],
-            1.f / V.vector4_f32[3]
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-    float32x4_t one = vdupq_n_f32(1.0f);
-    return vdivq_f32(one, V);
-#else
-    // 2 iterations of Newton-Raphson refinement
-    float32x4_t Reciprocal = vrecpeq_f32(V);
-    float32x4_t S = vrecpsq_f32(Reciprocal, V);
-    Reciprocal = vmulq_f32(S, Reciprocal);
-    S = vrecpsq_f32(Reciprocal, V);
-    return vmulq_f32(S, Reciprocal);
-#endif
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_div_ps(g_XMOne, V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Return an estimated square root
-inline XMVECTOR XM_CALLCONV XMVectorSqrtEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            sqrtf(V.vector4_f32[0]),
-            sqrtf(V.vector4_f32[1]),
-            sqrtf(V.vector4_f32[2]),
-            sqrtf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // 1 iteration of Newton-Raphson refinment of sqrt
-    float32x4_t S0 = vrsqrteq_f32(V);
-    float32x4_t P0 = vmulq_f32(V, S0);
-    float32x4_t R0 = vrsqrtsq_f32(P0, S0);
-    float32x4_t S1 = vmulq_f32(S0, R0);
-
-    XMVECTOR VEqualsInfinity = XMVectorEqualInt(V, g_XMInfinity.v);
-    XMVECTOR VEqualsZero = XMVectorEqual(V, vdupq_n_f32(0));
-    XMVECTOR Result = vmulq_f32(V, S1);
-    XMVECTOR Select = XMVectorEqualInt(VEqualsInfinity, VEqualsZero);
-    return XMVectorSelect(V, Result, Select);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_sqrt_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSqrt(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            sqrtf(V.vector4_f32[0]),
-            sqrtf(V.vector4_f32[1]),
-            sqrtf(V.vector4_f32[2]),
-            sqrtf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // 3 iterations of Newton-Raphson refinment of sqrt
-    float32x4_t S0 = vrsqrteq_f32(V);
-    float32x4_t P0 = vmulq_f32(V, S0);
-    float32x4_t R0 = vrsqrtsq_f32(P0, S0);
-    float32x4_t S1 = vmulq_f32(S0, R0);
-    float32x4_t P1 = vmulq_f32(V, S1);
-    float32x4_t R1 = vrsqrtsq_f32(P1, S1);
-    float32x4_t S2 = vmulq_f32(S1, R1);
-    float32x4_t P2 = vmulq_f32(V, S2);
-    float32x4_t R2 = vrsqrtsq_f32(P2, S2);
-    float32x4_t S3 = vmulq_f32(S2, R2);
-
-    XMVECTOR VEqualsInfinity = XMVectorEqualInt(V, g_XMInfinity.v);
-    XMVECTOR VEqualsZero = XMVectorEqual(V, vdupq_n_f32(0));
-    XMVECTOR Result = vmulq_f32(V, S3);
-    XMVECTOR Select = XMVectorEqualInt(VEqualsInfinity, VEqualsZero);
-    return XMVectorSelect(V, Result, Select);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_sqrt_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorReciprocalSqrtEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            1.f / sqrtf(V.vector4_f32[0]),
-            1.f / sqrtf(V.vector4_f32[1]),
-            1.f / sqrtf(V.vector4_f32[2]),
-            1.f / sqrtf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vrsqrteq_f32(V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    return _mm_rsqrt_ps(V);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorReciprocalSqrt(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            1.f / sqrtf(V.vector4_f32[0]),
-            1.f / sqrtf(V.vector4_f32[1]),
-            1.f / sqrtf(V.vector4_f32[2]),
-            1.f / sqrtf(V.vector4_f32[3])
-        } } };
-    return Result;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // 2 iterations of Newton-Raphson refinement of reciprocal
-    float32x4_t S0 = vrsqrteq_f32(V);
-
-    float32x4_t P0 = vmulq_f32(V, S0);
-    float32x4_t R0 = vrsqrtsq_f32(P0, S0);
-
-    float32x4_t S1 = vmulq_f32(S0, R0);
-    float32x4_t P1 = vmulq_f32(V, S1);
-    float32x4_t R1 = vrsqrtsq_f32(P1, S1);
-
-    return vmulq_f32(S1, R1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = _mm_sqrt_ps(V);
-    vResult = _mm_div_ps(g_XMOne, vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorExp2(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            exp2f(V.vector4_f32[0]),
-            exp2f(V.vector4_f32[1]),
-            exp2f(V.vector4_f32[2]),
-            exp2f(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int32x4_t itrunc = vcvtq_s32_f32(V);
-    float32x4_t ftrunc = vcvtq_f32_s32(itrunc);
-    float32x4_t y = vsubq_f32(V, ftrunc);
-
-    float32x4_t poly = vmlaq_f32(g_XMExpEst6, g_XMExpEst7, y);
-    poly = vmlaq_f32(g_XMExpEst5, poly, y);
-    poly = vmlaq_f32(g_XMExpEst4, poly, y);
-    poly = vmlaq_f32(g_XMExpEst3, poly, y);
-    poly = vmlaq_f32(g_XMExpEst2, poly, y);
-    poly = vmlaq_f32(g_XMExpEst1, poly, y);
-    poly = vmlaq_f32(g_XMOne, poly, y);
-
-    int32x4_t biased = vaddq_s32(itrunc, g_XMExponentBias);
-    biased = vshlq_n_s32(biased, 23);
-    float32x4_t result0 = XMVectorDivide(vreinterpretq_f32_s32(biased), poly);
-
-    biased = vaddq_s32(itrunc, g_XM253);
-    biased = vshlq_n_s32(biased, 23);
-    float32x4_t result1 = XMVectorDivide(vreinterpretq_f32_s32(biased), poly);
-    result1 = vmulq_f32(g_XMMinNormal.v, result1);
-
-    // Use selection to handle the cases
-    //  if (V is NaN) -> QNaN;
-    //  else if (V sign bit set)
-    //      if (V > -150)
-    //         if (V.exponent < -126) -> result1
-    //         else -> result0
-    //      else -> +0
-    //  else
-    //      if (V < 128) -> result0
-    //      else -> +inf
-
-    uint32x4_t comp = vcltq_s32(vreinterpretq_s32_f32(V), g_XMBin128);
-    float32x4_t result2 = vbslq_f32(comp, result0, g_XMInfinity);
-
-    comp = vcltq_s32(itrunc, g_XMSubnormalExponent);
-    float32x4_t result3 = vbslq_f32(comp, result1, result0);
-
-    comp = vcltq_s32(vreinterpretq_s32_f32(V), g_XMBinNeg150);
-    float32x4_t result4 = vbslq_f32(comp, result3, g_XMZero);
-
-    int32x4_t sign = vandq_s32(vreinterpretq_s32_f32(V), g_XMNegativeZero);
-    comp = vceqq_s32(sign, g_XMNegativeZero);
-    float32x4_t result5 = vbslq_f32(comp, result4, result2);
-
-    int32x4_t t0 = vandq_s32(vreinterpretq_s32_f32(V), g_XMQNaNTest);
-    int32x4_t t1 = vandq_s32(vreinterpretq_s32_f32(V), g_XMInfinity);
-    t0 = vreinterpretq_s32_u32(vceqq_s32(t0, g_XMZero));
-    t1 = vreinterpretq_s32_u32(vceqq_s32(t1, g_XMInfinity));
-    int32x4_t isNaN = vbicq_s32(t1, t0);
-
-    float32x4_t vResult = vbslq_f32(vreinterpretq_u32_s32(isNaN), g_XMQNaN, result5);
-    return vResult;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_exp2_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i itrunc = _mm_cvttps_epi32(V);
-    __m128 ftrunc = _mm_cvtepi32_ps(itrunc);
-    __m128 y = _mm_sub_ps(V, ftrunc);
-
-    __m128 poly = XM_FMADD_PS(g_XMExpEst7, y, g_XMExpEst6);
-    poly = XM_FMADD_PS(poly, y, g_XMExpEst5);
-    poly = XM_FMADD_PS(poly, y, g_XMExpEst4);
-    poly = XM_FMADD_PS(poly, y, g_XMExpEst3);
-    poly = XM_FMADD_PS(poly, y, g_XMExpEst2);
-    poly = XM_FMADD_PS(poly, y, g_XMExpEst1);
-    poly = XM_FMADD_PS(poly, y, g_XMOne);
-
-    __m128i biased = _mm_add_epi32(itrunc, g_XMExponentBias);
-    biased = _mm_slli_epi32(biased, 23);
-    __m128 result0 = _mm_div_ps(_mm_castsi128_ps(biased), poly);
-
-    biased = _mm_add_epi32(itrunc, g_XM253);
-    biased = _mm_slli_epi32(biased, 23);
-    __m128 result1 = _mm_div_ps(_mm_castsi128_ps(biased), poly);
-    result1 = _mm_mul_ps(g_XMMinNormal.v, result1);
-
-    // Use selection to handle the cases
-    //  if (V is NaN) -> QNaN;
-    //  else if (V sign bit set)
-    //      if (V > -150)
-    //         if (V.exponent < -126) -> result1
-    //         else -> result0
-    //      else -> +0
-    //  else
-    //      if (V < 128) -> result0
-    //      else -> +inf
-
-    __m128i comp = _mm_cmplt_epi32(_mm_castps_si128(V), g_XMBin128);
-    __m128i select0 = _mm_and_si128(comp, _mm_castps_si128(result0));
-    __m128i select1 = _mm_andnot_si128(comp, g_XMInfinity);
-    __m128i result2 = _mm_or_si128(select0, select1);
-
-    comp = _mm_cmplt_epi32(itrunc, g_XMSubnormalExponent);
-    select1 = _mm_and_si128(comp, _mm_castps_si128(result1));
-    select0 = _mm_andnot_si128(comp, _mm_castps_si128(result0));
-    __m128i result3 = _mm_or_si128(select0, select1);
-
-    comp = _mm_cmplt_epi32(_mm_castps_si128(V), g_XMBinNeg150);
-    select0 = _mm_and_si128(comp, result3);
-    select1 = _mm_andnot_si128(comp, g_XMZero);
-    __m128i result4 = _mm_or_si128(select0, select1);
-
-    __m128i sign = _mm_and_si128(_mm_castps_si128(V), g_XMNegativeZero);
-    comp = _mm_cmpeq_epi32(sign, g_XMNegativeZero);
-    select0 = _mm_and_si128(comp, result4);
-    select1 = _mm_andnot_si128(comp, result2);
-    __m128i result5 = _mm_or_si128(select0, select1);
-
-    __m128i t0 = _mm_and_si128(_mm_castps_si128(V), g_XMQNaNTest);
-    __m128i t1 = _mm_and_si128(_mm_castps_si128(V), g_XMInfinity);
-    t0 = _mm_cmpeq_epi32(t0, g_XMZero);
-    t1 = _mm_cmpeq_epi32(t1, g_XMInfinity);
-    __m128i isNaN = _mm_andnot_si128(t0, t1);
-
-    select0 = _mm_and_si128(isNaN, g_XMQNaN);
-    select1 = _mm_andnot_si128(isNaN, result5);
-    __m128i vResult = _mm_or_si128(select0, select1);
-
-    return _mm_castsi128_ps(vResult);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorExp10(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            powf(10.0f, V.vector4_f32[0]),
-            powf(10.0f, V.vector4_f32[1]),
-            powf(10.0f, V.vector4_f32[2]),
-            powf(10.0f, V.vector4_f32[3])
-        } } };
-    return Result.v;
-
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_exp10_ps(V);
-    return Result;
-#else
-    // exp10(V) = exp2(vin*log2(10))
-    XMVECTOR Vten = XMVectorMultiply(g_XMLg10, V);
-    return XMVectorExp2(Vten);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorExpE(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            expf(V.vector4_f32[0]),
-            expf(V.vector4_f32[1]),
-            expf(V.vector4_f32[2]),
-            expf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_exp_ps(V);
-    return Result;
-#else
-    // expE(V) = exp2(vin*log2(e))
-    XMVECTOR Ve = XMVectorMultiply(g_XMLgE, V);
-    return XMVectorExp2(Ve);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorExp(FXMVECTOR V) noexcept
-{
-    return XMVectorExp2(V);
-}
-
-//------------------------------------------------------------------------------
-
-#if defined(_XM_SSE_INTRINSICS_)
-
-namespace Internal
-{
-    inline __m128i multi_sll_epi32(__m128i value, __m128i count) noexcept
-    {
-        __m128i v = _mm_shuffle_epi32(value, _MM_SHUFFLE(0, 0, 0, 0));
-        __m128i c = _mm_shuffle_epi32(count, _MM_SHUFFLE(0, 0, 0, 0));
-        c = _mm_and_si128(c, g_XMMaskX);
-        __m128i r0 = _mm_sll_epi32(v, c);
-
-        v = _mm_shuffle_epi32(value, _MM_SHUFFLE(1, 1, 1, 1));
-        c = _mm_shuffle_epi32(count, _MM_SHUFFLE(1, 1, 1, 1));
-        c = _mm_and_si128(c, g_XMMaskX);
-        __m128i r1 = _mm_sll_epi32(v, c);
-
-        v = _mm_shuffle_epi32(value, _MM_SHUFFLE(2, 2, 2, 2));
-        c = _mm_shuffle_epi32(count, _MM_SHUFFLE(2, 2, 2, 2));
-        c = _mm_and_si128(c, g_XMMaskX);
-        __m128i r2 = _mm_sll_epi32(v, c);
-
-        v = _mm_shuffle_epi32(value, _MM_SHUFFLE(3, 3, 3, 3));
-        c = _mm_shuffle_epi32(count, _MM_SHUFFLE(3, 3, 3, 3));
-        c = _mm_and_si128(c, g_XMMaskX);
-        __m128i r3 = _mm_sll_epi32(v, c);
-
-        // (r0,r0,r1,r1)
-        __m128 r01 = _mm_shuffle_ps(_mm_castsi128_ps(r0), _mm_castsi128_ps(r1), _MM_SHUFFLE(0, 0, 0, 0));
-        // (r2,r2,r3,r3)
-        __m128 r23 = _mm_shuffle_ps(_mm_castsi128_ps(r2), _mm_castsi128_ps(r3), _MM_SHUFFLE(0, 0, 0, 0));
-        // (r0,r1,r2,r3)
-        __m128 result = _mm_shuffle_ps(r01, r23, _MM_SHUFFLE(2, 0, 2, 0));
-        return _mm_castps_si128(result);
-    }
-
-    inline __m128i multi_srl_epi32(__m128i value, __m128i count) noexcept
-    {
-        __m128i v = _mm_shuffle_epi32(value, _MM_SHUFFLE(0, 0, 0, 0));
-        __m128i c = _mm_shuffle_epi32(count, _MM_SHUFFLE(0, 0, 0, 0));
-        c = _mm_and_si128(c, g_XMMaskX);
-        __m128i r0 = _mm_srl_epi32(v, c);
-
-        v = _mm_shuffle_epi32(value, _MM_SHUFFLE(1, 1, 1, 1));
-        c = _mm_shuffle_epi32(count, _MM_SHUFFLE(1, 1, 1, 1));
-        c = _mm_and_si128(c, g_XMMaskX);
-        __m128i r1 = _mm_srl_epi32(v, c);
-
-        v = _mm_shuffle_epi32(value, _MM_SHUFFLE(2, 2, 2, 2));
-        c = _mm_shuffle_epi32(count, _MM_SHUFFLE(2, 2, 2, 2));
-        c = _mm_and_si128(c, g_XMMaskX);
-        __m128i r2 = _mm_srl_epi32(v, c);
-
-        v = _mm_shuffle_epi32(value, _MM_SHUFFLE(3, 3, 3, 3));
-        c = _mm_shuffle_epi32(count, _MM_SHUFFLE(3, 3, 3, 3));
-        c = _mm_and_si128(c, g_XMMaskX);
-        __m128i r3 = _mm_srl_epi32(v, c);
-
-        // (r0,r0,r1,r1)
-        __m128 r01 = _mm_shuffle_ps(_mm_castsi128_ps(r0), _mm_castsi128_ps(r1), _MM_SHUFFLE(0, 0, 0, 0));
-        // (r2,r2,r3,r3)
-        __m128 r23 = _mm_shuffle_ps(_mm_castsi128_ps(r2), _mm_castsi128_ps(r3), _MM_SHUFFLE(0, 0, 0, 0));
-        // (r0,r1,r2,r3)
-        __m128 result = _mm_shuffle_ps(r01, r23, _MM_SHUFFLE(2, 0, 2, 0));
-        return _mm_castps_si128(result);
-    }
-
-    inline __m128i GetLeadingBit(const __m128i value) noexcept
-    {
-        static const XMVECTORI32 g_XM0000FFFF = { { { 0x0000FFFF, 0x0000FFFF, 0x0000FFFF, 0x0000FFFF } } };
-        static const XMVECTORI32 g_XM000000FF = { { { 0x000000FF, 0x000000FF, 0x000000FF, 0x000000FF } } };
-        static const XMVECTORI32 g_XM0000000F = { { { 0x0000000F, 0x0000000F, 0x0000000F, 0x0000000F } } };
-        static const XMVECTORI32 g_XM00000003 = { { { 0x00000003, 0x00000003, 0x00000003, 0x00000003 } } };
-
-        __m128i v = value, r, c, b, s;
-
-        c = _mm_cmpgt_epi32(v, g_XM0000FFFF);   // c = (v > 0xFFFF)
-        b = _mm_srli_epi32(c, 31);              // b = (c ? 1 : 0)
-        r = _mm_slli_epi32(b, 4);               // r = (b << 4)
-        v = multi_srl_epi32(v, r);              // v = (v >> r)
-
-        c = _mm_cmpgt_epi32(v, g_XM000000FF);   // c = (v > 0xFF)
-        b = _mm_srli_epi32(c, 31);              // b = (c ? 1 : 0)
-        s = _mm_slli_epi32(b, 3);               // s = (b << 3)
-        v = multi_srl_epi32(v, s);              // v = (v >> s)
-        r = _mm_or_si128(r, s);                 // r = (r | s)
-
-        c = _mm_cmpgt_epi32(v, g_XM0000000F);   // c = (v > 0xF)
-        b = _mm_srli_epi32(c, 31);              // b = (c ? 1 : 0)
-        s = _mm_slli_epi32(b, 2);               // s = (b << 2)
-        v = multi_srl_epi32(v, s);              // v = (v >> s)
-        r = _mm_or_si128(r, s);                 // r = (r | s)
-
-        c = _mm_cmpgt_epi32(v, g_XM00000003);   // c = (v > 0x3)
-        b = _mm_srli_epi32(c, 31);              // b = (c ? 1 : 0)
-        s = _mm_slli_epi32(b, 1);               // s = (b << 1)
-        v = multi_srl_epi32(v, s);              // v = (v >> s)
-        r = _mm_or_si128(r, s);                 // r = (r | s)
-
-        s = _mm_srli_epi32(v, 1);
-        r = _mm_or_si128(r, s);
-        return r;
-    }
-} // namespace Internal
-
-#endif // _XM_SSE_INTRINSICS_
-
-#if defined(_XM_ARM_NEON_INTRINSICS_)
-
-namespace Internal
-{
-    inline int32x4_t GetLeadingBit(const int32x4_t value) noexcept
-    {
-        static const XMVECTORI32 g_XM0000FFFF = { { { 0x0000FFFF, 0x0000FFFF, 0x0000FFFF, 0x0000FFFF } } };
-        static const XMVECTORI32 g_XM000000FF = { { { 0x000000FF, 0x000000FF, 0x000000FF, 0x000000FF } } };
-        static const XMVECTORI32 g_XM0000000F = { { { 0x0000000F, 0x0000000F, 0x0000000F, 0x0000000F } } };
-        static const XMVECTORI32 g_XM00000003 = { { { 0x00000003, 0x00000003, 0x00000003, 0x00000003 } } };
-
-        uint32x4_t c = vcgtq_s32(value, g_XM0000FFFF);              // c = (v > 0xFFFF)
-        int32x4_t b = vshrq_n_s32(vreinterpretq_s32_u32(c), 31);    // b = (c ? 1 : 0)
-        int32x4_t r = vshlq_n_s32(b, 4);                            // r = (b << 4)
-        r = vnegq_s32(r);
-        int32x4_t v = vshlq_s32(value, r);                          // v = (v >> r)
-
-        c = vcgtq_s32(v, g_XM000000FF);                             // c = (v > 0xFF)
-        b = vshrq_n_s32(vreinterpretq_s32_u32(c), 31);              // b = (c ? 1 : 0)
-        int32x4_t s = vshlq_n_s32(b, 3);                            // s = (b << 3)
-        s = vnegq_s32(s);
-        v = vshlq_s32(v, s);                                        // v = (v >> s)
-        r = vorrq_s32(r, s);                                        // r = (r | s)
-
-        c = vcgtq_s32(v, g_XM0000000F);                             // c = (v > 0xF)
-        b = vshrq_n_s32(vreinterpretq_s32_u32(c), 31);              // b = (c ? 1 : 0)
-        s = vshlq_n_s32(b, 2);                                      // s = (b << 2)
-        s = vnegq_s32(s);
-        v = vshlq_s32(v, s);                                        // v = (v >> s)
-        r = vorrq_s32(r, s);                                        // r = (r | s)
-
-        c = vcgtq_s32(v, g_XM00000003);                             // c = (v > 0x3)
-        b = vshrq_n_s32(vreinterpretq_s32_u32(c), 31);              // b = (c ? 1 : 0)
-        s = vshlq_n_s32(b, 1);                                      // s = (b << 1)
-        s = vnegq_s32(s);
-        v = vshlq_s32(v, s);                                        // v = (v >> s)
-        r = vorrq_s32(r, s);                                        // r = (r | s)
-
-        s = vshrq_n_s32(v, 1);
-        r = vorrq_s32(r, s);
-        return r;
-    }
-
-} // namespace Internal
-
-#endif
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorLog2(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            log2f(V.vector4_f32[0]),
-            log2f(V.vector4_f32[1]),
-            log2f(V.vector4_f32[2]),
-            log2f(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int32x4_t rawBiased = vandq_s32(vreinterpretq_s32_f32(V), g_XMInfinity);
-    int32x4_t trailing = vandq_s32(vreinterpretq_s32_f32(V), g_XMQNaNTest);
-    uint32x4_t isExponentZero = vceqq_s32(vreinterpretq_s32_f32(g_XMZero), rawBiased);
-
-    // Compute exponent and significand for normals.
-    int32x4_t biased = vshrq_n_s32(rawBiased, 23);
-    int32x4_t exponentNor = vsubq_s32(biased, g_XMExponentBias);
-    int32x4_t trailingNor = trailing;
-
-    // Compute exponent and significand for subnormals.
-    int32x4_t leading = Internal::GetLeadingBit(trailing);
-    int32x4_t shift = vsubq_s32(g_XMNumTrailing, leading);
-    int32x4_t exponentSub = vsubq_s32(g_XMSubnormalExponent, shift);
-    int32x4_t trailingSub = vshlq_s32(trailing, shift);
-    trailingSub = vandq_s32(trailingSub, g_XMQNaNTest);
-    int32x4_t e = vbslq_s32(isExponentZero, exponentSub, exponentNor);
-    int32x4_t t = vbslq_s32(isExponentZero, trailingSub, trailingNor);
-
-    // Compute the approximation.
-    int32x4_t tmp = vorrq_s32(vreinterpretq_s32_f32(g_XMOne), t);
-    float32x4_t y = vsubq_f32(vreinterpretq_f32_s32(tmp), g_XMOne);
-
-    float32x4_t log2 = vmlaq_f32(g_XMLogEst6, g_XMLogEst7, y);
-    log2 = vmlaq_f32(g_XMLogEst5, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst4, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst3, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst2, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst1, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst0, log2, y);
-    log2 = vmlaq_f32(vcvtq_f32_s32(e), log2, y);
-
-    //  if (x is NaN) -> QNaN
-    //  else if (V is positive)
-    //      if (V is infinite) -> +inf
-    //      else -> log2(V)
-    //  else
-    //      if (V is zero) -> -inf
-    //      else -> -QNaN
-
-    uint32x4_t isInfinite = vandq_u32(vreinterpretq_u32_f32(V), g_XMAbsMask);
-    isInfinite = vceqq_u32(isInfinite, g_XMInfinity);
-
-    uint32x4_t isGreaterZero = vcgtq_f32(V, g_XMZero);
-    uint32x4_t isNotFinite = vcgtq_f32(V, g_XMInfinity);
-    uint32x4_t isPositive = vbicq_u32(isGreaterZero, isNotFinite);
-
-    uint32x4_t isZero = vandq_u32(vreinterpretq_u32_f32(V), g_XMAbsMask);
-    isZero = vceqq_u32(isZero, g_XMZero);
-
-    uint32x4_t t0 = vandq_u32(vreinterpretq_u32_f32(V), g_XMQNaNTest);
-    uint32x4_t t1 = vandq_u32(vreinterpretq_u32_f32(V), g_XMInfinity);
-    t0 = vceqq_u32(t0, g_XMZero);
-    t1 = vceqq_u32(t1, g_XMInfinity);
-    uint32x4_t isNaN = vbicq_u32(t1, t0);
-
-    float32x4_t result = vbslq_f32(isInfinite, g_XMInfinity, log2);
-    float32x4_t tmp2 = vbslq_f32(isZero, g_XMNegInfinity, g_XMNegQNaN);
-    result = vbslq_f32(isPositive, result, tmp2);
-    result = vbslq_f32(isNaN, g_XMQNaN, result);
-    return result;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_log2_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i rawBiased = _mm_and_si128(_mm_castps_si128(V), g_XMInfinity);
-    __m128i trailing = _mm_and_si128(_mm_castps_si128(V), g_XMQNaNTest);
-    __m128i isExponentZero = _mm_cmpeq_epi32(g_XMZero, rawBiased);
-
-    // Compute exponent and significand for normals.
-    __m128i biased = _mm_srli_epi32(rawBiased, 23);
-    __m128i exponentNor = _mm_sub_epi32(biased, g_XMExponentBias);
-    __m128i trailingNor = trailing;
-
-    // Compute exponent and significand for subnormals.
-    __m128i leading = Internal::GetLeadingBit(trailing);
-    __m128i shift = _mm_sub_epi32(g_XMNumTrailing, leading);
-    __m128i exponentSub = _mm_sub_epi32(g_XMSubnormalExponent, shift);
-    __m128i trailingSub = Internal::multi_sll_epi32(trailing, shift);
-    trailingSub = _mm_and_si128(trailingSub, g_XMQNaNTest);
-
-    __m128i select0 = _mm_and_si128(isExponentZero, exponentSub);
-    __m128i select1 = _mm_andnot_si128(isExponentZero, exponentNor);
-    __m128i e = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isExponentZero, trailingSub);
-    select1 = _mm_andnot_si128(isExponentZero, trailingNor);
-    __m128i t = _mm_or_si128(select0, select1);
-
-    // Compute the approximation.
-    __m128i tmp = _mm_or_si128(g_XMOne, t);
-    __m128 y = _mm_sub_ps(_mm_castsi128_ps(tmp), g_XMOne);
-
-    __m128 log2 = XM_FMADD_PS(g_XMLogEst7, y, g_XMLogEst6);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst5);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst4);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst3);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst2);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst1);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst0);
-    log2 = XM_FMADD_PS(log2, y, _mm_cvtepi32_ps(e));
-
-    //  if (x is NaN) -> QNaN
-    //  else if (V is positive)
-    //      if (V is infinite) -> +inf
-    //      else -> log2(V)
-    //  else
-    //      if (V is zero) -> -inf
-    //      else -> -QNaN
-
-    __m128i isInfinite = _mm_and_si128(_mm_castps_si128(V), g_XMAbsMask);
-    isInfinite = _mm_cmpeq_epi32(isInfinite, g_XMInfinity);
-
-    __m128i isGreaterZero = _mm_cmpgt_epi32(_mm_castps_si128(V), g_XMZero);
-    __m128i isNotFinite = _mm_cmpgt_epi32(_mm_castps_si128(V), g_XMInfinity);
-    __m128i isPositive = _mm_andnot_si128(isNotFinite, isGreaterZero);
-
-    __m128i isZero = _mm_and_si128(_mm_castps_si128(V), g_XMAbsMask);
-    isZero = _mm_cmpeq_epi32(isZero, g_XMZero);
-
-    __m128i t0 = _mm_and_si128(_mm_castps_si128(V), g_XMQNaNTest);
-    __m128i t1 = _mm_and_si128(_mm_castps_si128(V), g_XMInfinity);
-    t0 = _mm_cmpeq_epi32(t0, g_XMZero);
-    t1 = _mm_cmpeq_epi32(t1, g_XMInfinity);
-    __m128i isNaN = _mm_andnot_si128(t0, t1);
-
-    select0 = _mm_and_si128(isInfinite, g_XMInfinity);
-    select1 = _mm_andnot_si128(isInfinite, _mm_castps_si128(log2));
-    __m128i result = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isZero, g_XMNegInfinity);
-    select1 = _mm_andnot_si128(isZero, g_XMNegQNaN);
-    tmp = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isPositive, result);
-    select1 = _mm_andnot_si128(isPositive, tmp);
-    result = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isNaN, g_XMQNaN);
-    select1 = _mm_andnot_si128(isNaN, result);
-    result = _mm_or_si128(select0, select1);
-
-    return _mm_castsi128_ps(result);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorLog10(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            log10f(V.vector4_f32[0]),
-            log10f(V.vector4_f32[1]),
-            log10f(V.vector4_f32[2]),
-            log10f(V.vector4_f32[3])
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int32x4_t rawBiased = vandq_s32(vreinterpretq_s32_f32(V), g_XMInfinity);
-    int32x4_t trailing = vandq_s32(vreinterpretq_s32_f32(V), g_XMQNaNTest);
-    uint32x4_t isExponentZero = vceqq_s32(g_XMZero, rawBiased);
-
-    // Compute exponent and significand for normals.
-    int32x4_t biased = vshrq_n_s32(rawBiased, 23);
-    int32x4_t exponentNor = vsubq_s32(biased, g_XMExponentBias);
-    int32x4_t trailingNor = trailing;
-
-    // Compute exponent and significand for subnormals.
-    int32x4_t leading = Internal::GetLeadingBit(trailing);
-    int32x4_t shift = vsubq_s32(g_XMNumTrailing, leading);
-    int32x4_t exponentSub = vsubq_s32(g_XMSubnormalExponent, shift);
-    int32x4_t trailingSub = vshlq_s32(trailing, shift);
-    trailingSub = vandq_s32(trailingSub, g_XMQNaNTest);
-    int32x4_t e = vbslq_s32(isExponentZero, exponentSub, exponentNor);
-    int32x4_t t = vbslq_s32(isExponentZero, trailingSub, trailingNor);
-
-    // Compute the approximation.
-    int32x4_t tmp = vorrq_s32(g_XMOne, t);
-    float32x4_t y = vsubq_f32(vreinterpretq_f32_s32(tmp), g_XMOne);
-
-    float32x4_t log2 = vmlaq_f32(g_XMLogEst6, g_XMLogEst7, y);
-    log2 = vmlaq_f32(g_XMLogEst5, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst4, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst3, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst2, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst1, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst0, log2, y);
-    log2 = vmlaq_f32(vcvtq_f32_s32(e), log2, y);
-
-    log2 = vmulq_f32(g_XMInvLg10, log2);
-
-    //  if (x is NaN) -> QNaN
-    //  else if (V is positive)
-    //      if (V is infinite) -> +inf
-    //      else -> log2(V)
-    //  else
-    //      if (V is zero) -> -inf
-    //      else -> -QNaN
-
-    uint32x4_t isInfinite = vandq_u32(vreinterpretq_u32_f32(V), g_XMAbsMask);
-    isInfinite = vceqq_u32(isInfinite, g_XMInfinity);
-
-    uint32x4_t isGreaterZero = vcgtq_s32(vreinterpretq_s32_f32(V), g_XMZero);
-    uint32x4_t isNotFinite = vcgtq_s32(vreinterpretq_s32_f32(V), g_XMInfinity);
-    uint32x4_t isPositive = vbicq_u32(isGreaterZero, isNotFinite);
-
-    uint32x4_t isZero = vandq_u32(vreinterpretq_u32_f32(V), g_XMAbsMask);
-    isZero = vceqq_u32(isZero, g_XMZero);
-
-    uint32x4_t t0 = vandq_u32(vreinterpretq_u32_f32(V), g_XMQNaNTest);
-    uint32x4_t t1 = vandq_u32(vreinterpretq_u32_f32(V), g_XMInfinity);
-    t0 = vceqq_u32(t0, g_XMZero);
-    t1 = vceqq_u32(t1, g_XMInfinity);
-    uint32x4_t isNaN = vbicq_u32(t1, t0);
-
-    float32x4_t result = vbslq_f32(isInfinite, g_XMInfinity, log2);
-    float32x4_t tmp2 = vbslq_f32(isZero, g_XMNegInfinity, g_XMNegQNaN);
-    result = vbslq_f32(isPositive, result, tmp2);
-    result = vbslq_f32(isNaN, g_XMQNaN, result);
-    return result;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_log10_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i rawBiased = _mm_and_si128(_mm_castps_si128(V), g_XMInfinity);
-    __m128i trailing = _mm_and_si128(_mm_castps_si128(V), g_XMQNaNTest);
-    __m128i isExponentZero = _mm_cmpeq_epi32(g_XMZero, rawBiased);
-
-    // Compute exponent and significand for normals.
-    __m128i biased = _mm_srli_epi32(rawBiased, 23);
-    __m128i exponentNor = _mm_sub_epi32(biased, g_XMExponentBias);
-    __m128i trailingNor = trailing;
-
-    // Compute exponent and significand for subnormals.
-    __m128i leading = Internal::GetLeadingBit(trailing);
-    __m128i shift = _mm_sub_epi32(g_XMNumTrailing, leading);
-    __m128i exponentSub = _mm_sub_epi32(g_XMSubnormalExponent, shift);
-    __m128i trailingSub = Internal::multi_sll_epi32(trailing, shift);
-    trailingSub = _mm_and_si128(trailingSub, g_XMQNaNTest);
-
-    __m128i select0 = _mm_and_si128(isExponentZero, exponentSub);
-    __m128i select1 = _mm_andnot_si128(isExponentZero, exponentNor);
-    __m128i e = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isExponentZero, trailingSub);
-    select1 = _mm_andnot_si128(isExponentZero, trailingNor);
-    __m128i t = _mm_or_si128(select0, select1);
-
-    // Compute the approximation.
-    __m128i tmp = _mm_or_si128(g_XMOne, t);
-    __m128 y = _mm_sub_ps(_mm_castsi128_ps(tmp), g_XMOne);
-
-    __m128 log2 = XM_FMADD_PS(g_XMLogEst7, y, g_XMLogEst6);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst5);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst4);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst3);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst2);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst1);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst0);
-    log2 = XM_FMADD_PS(log2, y, _mm_cvtepi32_ps(e));
-
-    log2 = _mm_mul_ps(g_XMInvLg10, log2);
-
-    //  if (x is NaN) -> QNaN
-    //  else if (V is positive)
-    //      if (V is infinite) -> +inf
-    //      else -> log2(V)
-    //  else
-    //      if (V is zero) -> -inf
-    //      else -> -QNaN
-
-    __m128i isInfinite = _mm_and_si128(_mm_castps_si128(V), g_XMAbsMask);
-    isInfinite = _mm_cmpeq_epi32(isInfinite, g_XMInfinity);
-
-    __m128i isGreaterZero = _mm_cmpgt_epi32(_mm_castps_si128(V), g_XMZero);
-    __m128i isNotFinite = _mm_cmpgt_epi32(_mm_castps_si128(V), g_XMInfinity);
-    __m128i isPositive = _mm_andnot_si128(isNotFinite, isGreaterZero);
-
-    __m128i isZero = _mm_and_si128(_mm_castps_si128(V), g_XMAbsMask);
-    isZero = _mm_cmpeq_epi32(isZero, g_XMZero);
-
-    __m128i t0 = _mm_and_si128(_mm_castps_si128(V), g_XMQNaNTest);
-    __m128i t1 = _mm_and_si128(_mm_castps_si128(V), g_XMInfinity);
-    t0 = _mm_cmpeq_epi32(t0, g_XMZero);
-    t1 = _mm_cmpeq_epi32(t1, g_XMInfinity);
-    __m128i isNaN = _mm_andnot_si128(t0, t1);
-
-    select0 = _mm_and_si128(isInfinite, g_XMInfinity);
-    select1 = _mm_andnot_si128(isInfinite, _mm_castps_si128(log2));
-    __m128i result = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isZero, g_XMNegInfinity);
-    select1 = _mm_andnot_si128(isZero, g_XMNegQNaN);
-    tmp = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isPositive, result);
-    select1 = _mm_andnot_si128(isPositive, tmp);
-    result = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isNaN, g_XMQNaN);
-    select1 = _mm_andnot_si128(isNaN, result);
-    result = _mm_or_si128(select0, select1);
-
-    return _mm_castsi128_ps(result);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorLogE(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            logf(V.vector4_f32[0]),
-            logf(V.vector4_f32[1]),
-            logf(V.vector4_f32[2]),
-            logf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int32x4_t rawBiased = vandq_s32(vreinterpretq_s32_f32(V), g_XMInfinity);
-    int32x4_t trailing = vandq_s32(vreinterpretq_s32_f32(V), g_XMQNaNTest);
-    uint32x4_t isExponentZero = vceqq_s32(g_XMZero, rawBiased);
-
-    // Compute exponent and significand for normals.
-    int32x4_t biased = vshrq_n_s32(rawBiased, 23);
-    int32x4_t exponentNor = vsubq_s32(biased, g_XMExponentBias);
-    int32x4_t trailingNor = trailing;
-
-    // Compute exponent and significand for subnormals.
-    int32x4_t leading = Internal::GetLeadingBit(trailing);
-    int32x4_t shift = vsubq_s32(g_XMNumTrailing, leading);
-    int32x4_t exponentSub = vsubq_s32(g_XMSubnormalExponent, shift);
-    int32x4_t trailingSub = vshlq_s32(trailing, shift);
-    trailingSub = vandq_s32(trailingSub, g_XMQNaNTest);
-    int32x4_t e = vbslq_s32(isExponentZero, exponentSub, exponentNor);
-    int32x4_t t = vbslq_s32(isExponentZero, trailingSub, trailingNor);
-
-    // Compute the approximation.
-    int32x4_t tmp = vorrq_s32(g_XMOne, t);
-    float32x4_t y = vsubq_f32(vreinterpretq_f32_s32(tmp), g_XMOne);
-
-    float32x4_t log2 = vmlaq_f32(g_XMLogEst6, g_XMLogEst7, y);
-    log2 = vmlaq_f32(g_XMLogEst5, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst4, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst3, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst2, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst1, log2, y);
-    log2 = vmlaq_f32(g_XMLogEst0, log2, y);
-    log2 = vmlaq_f32(vcvtq_f32_s32(e), log2, y);
-
-    log2 = vmulq_f32(g_XMInvLgE, log2);
-
-    //  if (x is NaN) -> QNaN
-    //  else if (V is positive)
-    //      if (V is infinite) -> +inf
-    //      else -> log2(V)
-    //  else
-    //      if (V is zero) -> -inf
-    //      else -> -QNaN
-
-    uint32x4_t isInfinite = vandq_u32(vreinterpretq_u32_f32(V), g_XMAbsMask);
-    isInfinite = vceqq_u32(isInfinite, g_XMInfinity);
-
-    uint32x4_t isGreaterZero = vcgtq_s32(vreinterpretq_s32_f32(V), g_XMZero);
-    uint32x4_t isNotFinite = vcgtq_s32(vreinterpretq_s32_f32(V), g_XMInfinity);
-    uint32x4_t isPositive = vbicq_u32(isGreaterZero, isNotFinite);
-
-    uint32x4_t isZero = vandq_u32(vreinterpretq_u32_f32(V), g_XMAbsMask);
-    isZero = vceqq_u32(isZero, g_XMZero);
-
-    uint32x4_t t0 = vandq_u32(vreinterpretq_u32_f32(V), g_XMQNaNTest);
-    uint32x4_t t1 = vandq_u32(vreinterpretq_u32_f32(V), g_XMInfinity);
-    t0 = vceqq_u32(t0, g_XMZero);
-    t1 = vceqq_u32(t1, g_XMInfinity);
-    uint32x4_t isNaN = vbicq_u32(t1, t0);
-
-    float32x4_t result = vbslq_f32(isInfinite, g_XMInfinity, log2);
-    float32x4_t tmp2 = vbslq_f32(isZero, g_XMNegInfinity, g_XMNegQNaN);
-    result = vbslq_f32(isPositive, result, tmp2);
-    result = vbslq_f32(isNaN, g_XMQNaN, result);
-    return result;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_log_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i rawBiased = _mm_and_si128(_mm_castps_si128(V), g_XMInfinity);
-    __m128i trailing = _mm_and_si128(_mm_castps_si128(V), g_XMQNaNTest);
-    __m128i isExponentZero = _mm_cmpeq_epi32(g_XMZero, rawBiased);
-
-    // Compute exponent and significand for normals.
-    __m128i biased = _mm_srli_epi32(rawBiased, 23);
-    __m128i exponentNor = _mm_sub_epi32(biased, g_XMExponentBias);
-    __m128i trailingNor = trailing;
-
-    // Compute exponent and significand for subnormals.
-    __m128i leading = Internal::GetLeadingBit(trailing);
-    __m128i shift = _mm_sub_epi32(g_XMNumTrailing, leading);
-    __m128i exponentSub = _mm_sub_epi32(g_XMSubnormalExponent, shift);
-    __m128i trailingSub = Internal::multi_sll_epi32(trailing, shift);
-    trailingSub = _mm_and_si128(trailingSub, g_XMQNaNTest);
-
-    __m128i select0 = _mm_and_si128(isExponentZero, exponentSub);
-    __m128i select1 = _mm_andnot_si128(isExponentZero, exponentNor);
-    __m128i e = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isExponentZero, trailingSub);
-    select1 = _mm_andnot_si128(isExponentZero, trailingNor);
-    __m128i t = _mm_or_si128(select0, select1);
-
-    // Compute the approximation.
-    __m128i tmp = _mm_or_si128(g_XMOne, t);
-    __m128 y = _mm_sub_ps(_mm_castsi128_ps(tmp), g_XMOne);
-
-    __m128 log2 = XM_FMADD_PS(g_XMLogEst7, y, g_XMLogEst6);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst5);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst4);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst3);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst2);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst1);
-    log2 = XM_FMADD_PS(log2, y, g_XMLogEst0);
-    log2 = XM_FMADD_PS(log2, y, _mm_cvtepi32_ps(e));
-
-    log2 = _mm_mul_ps(g_XMInvLgE, log2);
-
-    //  if (x is NaN) -> QNaN
-    //  else if (V is positive)
-    //      if (V is infinite) -> +inf
-    //      else -> log2(V)
-    //  else
-    //      if (V is zero) -> -inf
-    //      else -> -QNaN
-
-    __m128i isInfinite = _mm_and_si128(_mm_castps_si128(V), g_XMAbsMask);
-    isInfinite = _mm_cmpeq_epi32(isInfinite, g_XMInfinity);
-
-    __m128i isGreaterZero = _mm_cmpgt_epi32(_mm_castps_si128(V), g_XMZero);
-    __m128i isNotFinite = _mm_cmpgt_epi32(_mm_castps_si128(V), g_XMInfinity);
-    __m128i isPositive = _mm_andnot_si128(isNotFinite, isGreaterZero);
-
-    __m128i isZero = _mm_and_si128(_mm_castps_si128(V), g_XMAbsMask);
-    isZero = _mm_cmpeq_epi32(isZero, g_XMZero);
-
-    __m128i t0 = _mm_and_si128(_mm_castps_si128(V), g_XMQNaNTest);
-    __m128i t1 = _mm_and_si128(_mm_castps_si128(V), g_XMInfinity);
-    t0 = _mm_cmpeq_epi32(t0, g_XMZero);
-    t1 = _mm_cmpeq_epi32(t1, g_XMInfinity);
-    __m128i isNaN = _mm_andnot_si128(t0, t1);
-
-    select0 = _mm_and_si128(isInfinite, g_XMInfinity);
-    select1 = _mm_andnot_si128(isInfinite, _mm_castps_si128(log2));
-    __m128i result = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isZero, g_XMNegInfinity);
-    select1 = _mm_andnot_si128(isZero, g_XMNegQNaN);
-    tmp = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isPositive, result);
-    select1 = _mm_andnot_si128(isPositive, tmp);
-    result = _mm_or_si128(select0, select1);
-
-    select0 = _mm_and_si128(isNaN, g_XMQNaN);
-    select1 = _mm_andnot_si128(isNaN, result);
-    result = _mm_or_si128(select0, select1);
-
-    return _mm_castsi128_ps(result);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorLog(FXMVECTOR V) noexcept
-{
-    return XMVectorLog2(V);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorPow
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            powf(V1.vector4_f32[0], V2.vector4_f32[0]),
-            powf(V1.vector4_f32[1], V2.vector4_f32[1]),
-            powf(V1.vector4_f32[2], V2.vector4_f32[2]),
-            powf(V1.vector4_f32[3], V2.vector4_f32[3])
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            powf(vgetq_lane_f32(V1, 0), vgetq_lane_f32(V2, 0)),
-            powf(vgetq_lane_f32(V1, 1), vgetq_lane_f32(V2, 1)),
-            powf(vgetq_lane_f32(V1, 2), vgetq_lane_f32(V2, 2)),
-            powf(vgetq_lane_f32(V1, 3), vgetq_lane_f32(V2, 3))
-        } } };
-    return vResult.v;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_pow_ps(V1, V2);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XM_ALIGNED_DATA(16) float a[4];
-    XM_ALIGNED_DATA(16) float b[4];
-    _mm_store_ps(a, V1);
-    _mm_store_ps(b, V2);
-    XMVECTOR vResult = _mm_setr_ps(
-            powf(a[0], b[0]),
-            powf(a[1], b[1]),
-            powf(a[2], b[2]),
-            powf(a[3], b[3]));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorAbs(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            fabsf(V.vector4_f32[0]),
-            fabsf(V.vector4_f32[1]),
-            fabsf(V.vector4_f32[2]),
-            fabsf(V.vector4_f32[3])
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    return vabsq_f32(V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = _mm_setzero_ps();
-    vResult = _mm_sub_ps(vResult, V);
-    vResult = _mm_max_ps(vResult, V);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorMod
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    // V1 % V2 = V1 - V2 * truncate(V1 / V2)
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Quotient = XMVectorDivide(V1, V2);
-    Quotient = XMVectorTruncate(Quotient);
-    XMVECTOR Result = XMVectorNegativeMultiplySubtract(V2, Quotient, V1);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR vResult = XMVectorDivide(V1, V2);
-    vResult = XMVectorTruncate(vResult);
-    return vmlsq_f32(V1, vResult, V2);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = _mm_div_ps(V1, V2);
-    vResult = XMVectorTruncate(vResult);
-    return XM_FNMADD_PS(vResult, V2, V1);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorModAngles(FXMVECTOR Angles) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR V;
-    XMVECTOR Result;
-
-    // Modulo the range of the given angles such that -XM_PI <= Angles < XM_PI
-    V = XMVectorMultiply(Angles, g_XMReciprocalTwoPi.v);
-    V = XMVectorRound(V);
-    Result = XMVectorNegativeMultiplySubtract(g_XMTwoPi.v, V, Angles);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Modulo the range of the given angles such that -XM_PI <= Angles < XM_PI
-    XMVECTOR vResult = vmulq_f32(Angles, g_XMReciprocalTwoPi);
-    // Use the inline function due to complexity for rounding
-    vResult = XMVectorRound(vResult);
-    return vmlsq_f32(Angles, vResult, g_XMTwoPi);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Modulo the range of the given angles such that -XM_PI <= Angles < XM_PI
-    XMVECTOR vResult = _mm_mul_ps(Angles, g_XMReciprocalTwoPi);
-    // Use the inline function due to complexity for rounding
-    vResult = XMVectorRound(vResult);
-    return XM_FNMADD_PS(vResult, g_XMTwoPi, Angles);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSin(FXMVECTOR V) noexcept
-{
-    // 11-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            sinf(V.vector4_f32[0]),
-            sinf(V.vector4_f32[1]),
-            sinf(V.vector4_f32[2]),
-            sinf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Force the value within the bounds of pi
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with sin(y) = sin(x).
-    uint32x4_t sign = vandq_u32(vreinterpretq_u32_f32(x), g_XMNegativeZero);
-    uint32x4_t c = vorrq_u32(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    float32x4_t absx = vabsq_f32(x);
-    float32x4_t rflx = vsubq_f32(vreinterpretq_f32_u32(c), x);
-    uint32x4_t comp = vcleq_f32(absx, g_XMHalfPi);
-    x = vbslq_f32(comp, x, rflx);
-
-    float32x4_t x2 = vmulq_f32(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR SC1 = g_XMSinCoefficients1;
-    const XMVECTOR SC0 = g_XMSinCoefficients0;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(SC0), 1);
-    XMVECTOR Result = vmlaq_lane_f32(vConstants, x2, vget_low_f32(SC1), 0);
-
-    vConstants = vdupq_lane_f32(vget_high_f32(SC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(SC0), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(SC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    Result = vmlaq_f32(g_XMOne, Result, x2);
-    Result = vmulq_f32(Result, x);
-    return Result;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_sin_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Force the value within the bounds of pi
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with sin(y) = sin(x).
-    __m128 sign = _mm_and_ps(x, g_XMNegativeZero);
-    __m128 c = _mm_or_ps(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    __m128 absx = _mm_andnot_ps(sign, x);  // |x|
-    __m128 rflx = _mm_sub_ps(c, x);
-    __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi);
-    __m128 select0 = _mm_and_ps(comp, x);
-    __m128 select1 = _mm_andnot_ps(comp, rflx);
-    x = _mm_or_ps(select0, select1);
-
-    __m128 x2 = _mm_mul_ps(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR SC1 = g_XMSinCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(SC1, _MM_SHUFFLE(0, 0, 0, 0));
-    const XMVECTOR SC0 = g_XMSinCoefficients0;
-    __m128 vConstants = XM_PERMUTE_PS(SC0, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(SC0, _MM_SHUFFLE(2, 2, 2, 2));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(SC0, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(SC0, _MM_SHUFFLE(0, 0, 0, 0));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    Result = XM_FMADD_PS(Result, x2, g_XMOne);
-    Result = _mm_mul_ps(Result, x);
-    return Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorCos(FXMVECTOR V) noexcept
-{
-    // 10-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            cosf(V.vector4_f32[0]),
-            cosf(V.vector4_f32[1]),
-            cosf(V.vector4_f32[2]),
-            cosf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Map V to x in [-pi,pi].
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x).
-    uint32x4_t sign = vandq_u32(vreinterpretq_u32_f32(x), g_XMNegativeZero);
-    uint32x4_t c = vorrq_u32(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    float32x4_t absx = vabsq_f32(x);
-    float32x4_t rflx = vsubq_f32(vreinterpretq_f32_u32(c), x);
-    uint32x4_t comp = vcleq_f32(absx, g_XMHalfPi);
-    x = vbslq_f32(comp, x, rflx);
-    float32x4_t fsign = vbslq_f32(comp, g_XMOne, g_XMNegativeOne);
-
-    float32x4_t x2 = vmulq_f32(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR CC1 = g_XMCosCoefficients1;
-    const XMVECTOR CC0 = g_XMCosCoefficients0;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(CC0), 1);
-    XMVECTOR Result = vmlaq_lane_f32(vConstants, x2, vget_low_f32(CC1), 0);
-
-    vConstants = vdupq_lane_f32(vget_high_f32(CC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(CC0), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(CC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    Result = vmlaq_f32(g_XMOne, Result, x2);
-    Result = vmulq_f32(Result, fsign);
-    return Result;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_cos_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Map V to x in [-pi,pi].
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x).
-    XMVECTOR sign = _mm_and_ps(x, g_XMNegativeZero);
-    __m128 c = _mm_or_ps(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    __m128 absx = _mm_andnot_ps(sign, x);  // |x|
-    __m128 rflx = _mm_sub_ps(c, x);
-    __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi);
-    __m128 select0 = _mm_and_ps(comp, x);
-    __m128 select1 = _mm_andnot_ps(comp, rflx);
-    x = _mm_or_ps(select0, select1);
-    select0 = _mm_and_ps(comp, g_XMOne);
-    select1 = _mm_andnot_ps(comp, g_XMNegativeOne);
-    sign = _mm_or_ps(select0, select1);
-
-    __m128 x2 = _mm_mul_ps(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR CC1 = g_XMCosCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(CC1, _MM_SHUFFLE(0, 0, 0, 0));
-    const XMVECTOR CC0 = g_XMCosCoefficients0;
-    __m128 vConstants = XM_PERMUTE_PS(CC0, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(CC0, _MM_SHUFFLE(2, 2, 2, 2));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(CC0, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(CC0, _MM_SHUFFLE(0, 0, 0, 0));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    Result = XM_FMADD_PS(Result, x2, g_XMOne);
-    Result = _mm_mul_ps(Result, sign);
-    return Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorSinCos
-        (
-                XMVECTOR* pSin,
-                XMVECTOR* pCos,
-                FXMVECTOR V
-        ) noexcept
-{
-    assert(pSin != nullptr);
-    assert(pCos != nullptr);
-
-    // 11/10-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Sin = { { {
-            sinf(V.vector4_f32[0]),
-            sinf(V.vector4_f32[1]),
-            sinf(V.vector4_f32[2]),
-            sinf(V.vector4_f32[3])
-        } } };
-
-    XMVECTORF32 Cos = { { {
-            cosf(V.vector4_f32[0]),
-            cosf(V.vector4_f32[1]),
-            cosf(V.vector4_f32[2]),
-            cosf(V.vector4_f32[3])
-        } } };
-
-    *pSin = Sin.v;
-    *pCos = Cos.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Force the value within the bounds of pi
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x).
-    uint32x4_t sign = vandq_u32(vreinterpretq_u32_f32(x), g_XMNegativeZero);
-    uint32x4_t c = vorrq_u32(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    float32x4_t absx = vabsq_f32(x);
-    float32x4_t  rflx = vsubq_f32(vreinterpretq_f32_u32(c), x);
-    uint32x4_t comp = vcleq_f32(absx, g_XMHalfPi);
-    x = vbslq_f32(comp, x, rflx);
-    float32x4_t fsign = vbslq_f32(comp, g_XMOne, g_XMNegativeOne);
-
-    float32x4_t x2 = vmulq_f32(x, x);
-
-    // Compute polynomial approximation for sine
-    const XMVECTOR SC1 = g_XMSinCoefficients1;
-    const XMVECTOR SC0 = g_XMSinCoefficients0;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(SC0), 1);
-    XMVECTOR Result = vmlaq_lane_f32(vConstants, x2, vget_low_f32(SC1), 0);
-
-    vConstants = vdupq_lane_f32(vget_high_f32(SC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(SC0), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(SC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    Result = vmlaq_f32(g_XMOne, Result, x2);
-    *pSin = vmulq_f32(Result, x);
-
-    // Compute polynomial approximation for cosine
-    const XMVECTOR CC1 = g_XMCosCoefficients1;
-    const XMVECTOR CC0 = g_XMCosCoefficients0;
-    vConstants = vdupq_lane_f32(vget_high_f32(CC0), 1);
-    Result = vmlaq_lane_f32(vConstants, x2, vget_low_f32(CC1), 0);
-
-    vConstants = vdupq_lane_f32(vget_high_f32(CC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(CC0), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(CC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    Result = vmlaq_f32(g_XMOne, Result, x2);
-    *pCos = vmulq_f32(Result, fsign);
-#elif defined(_XM_SVML_INTRINSICS_)
-    *pSin = _mm_sincos_ps(pCos, V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Force the value within the bounds of pi
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with sin(y) = sin(x), cos(y) = sign*cos(x).
-    XMVECTOR sign = _mm_and_ps(x, g_XMNegativeZero);
-    __m128 c = _mm_or_ps(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    __m128 absx = _mm_andnot_ps(sign, x);  // |x|
-    __m128 rflx = _mm_sub_ps(c, x);
-    __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi);
-    __m128 select0 = _mm_and_ps(comp, x);
-    __m128 select1 = _mm_andnot_ps(comp, rflx);
-    x = _mm_or_ps(select0, select1);
-    select0 = _mm_and_ps(comp, g_XMOne);
-    select1 = _mm_andnot_ps(comp, g_XMNegativeOne);
-    sign = _mm_or_ps(select0, select1);
-
-    __m128 x2 = _mm_mul_ps(x, x);
-
-    // Compute polynomial approximation of sine
-    const XMVECTOR SC1 = g_XMSinCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(SC1, _MM_SHUFFLE(0, 0, 0, 0));
-    const XMVECTOR SC0 = g_XMSinCoefficients0;
-    __m128 vConstants = XM_PERMUTE_PS(SC0, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(SC0, _MM_SHUFFLE(2, 2, 2, 2));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(SC0, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(SC0, _MM_SHUFFLE(0, 0, 0, 0));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    Result = XM_FMADD_PS(Result, x2, g_XMOne);
-    Result = _mm_mul_ps(Result, x);
-    *pSin = Result;
-
-    // Compute polynomial approximation of cosine
-    const XMVECTOR CC1 = g_XMCosCoefficients1;
-    vConstantsB = XM_PERMUTE_PS(CC1, _MM_SHUFFLE(0, 0, 0, 0));
-    const XMVECTOR CC0 = g_XMCosCoefficients0;
-    vConstants = XM_PERMUTE_PS(CC0, _MM_SHUFFLE(3, 3, 3, 3));
-    Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(CC0, _MM_SHUFFLE(2, 2, 2, 2));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(CC0, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(CC0, _MM_SHUFFLE(0, 0, 0, 0));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    Result = XM_FMADD_PS(Result, x2, g_XMOne);
-    Result = _mm_mul_ps(Result, sign);
-    *pCos = Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorTan(FXMVECTOR V) noexcept
-{
-    // Cody and Waite algorithm to compute tangent.
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            tanf(V.vector4_f32[0]),
-            tanf(V.vector4_f32[1]),
-            tanf(V.vector4_f32[2]),
-            tanf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_tan_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-
-    static const XMVECTORF32 TanCoefficients0 = { { { 1.0f, -4.667168334e-1f, 2.566383229e-2f, -3.118153191e-4f } } };
-    static const XMVECTORF32 TanCoefficients1 = { { { 4.981943399e-7f, -1.333835001e-1f, 3.424887824e-3f, -1.786170734e-5f } } };
-    static const XMVECTORF32 TanConstants = { { { 1.570796371f, 6.077100628e-11f, 0.000244140625f, 0.63661977228f /*2 / Pi*/ } } };
-    static const XMVECTORU32 Mask = { { { 0x1, 0x1, 0x1, 0x1 } } };
-
-    XMVECTOR TwoDivPi = XMVectorSplatW(TanConstants.v);
-
-    XMVECTOR Zero = XMVectorZero();
-
-    XMVECTOR C0 = XMVectorSplatX(TanConstants.v);
-    XMVECTOR C1 = XMVectorSplatY(TanConstants.v);
-    XMVECTOR Epsilon = XMVectorSplatZ(TanConstants.v);
-
-    XMVECTOR VA = XMVectorMultiply(V, TwoDivPi);
-
-    VA = XMVectorRound(VA);
-
-    XMVECTOR VC = XMVectorNegativeMultiplySubtract(VA, C0, V);
-
-    XMVECTOR VB = XMVectorAbs(VA);
-
-    VC = XMVectorNegativeMultiplySubtract(VA, C1, VC);
-
-#if defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    VB = vreinterpretq_f32_u32(vcvtq_u32_f32(VB));
-#elif defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    reinterpret_cast<__m128i*>(&VB)[0] = _mm_cvttps_epi32(VB);
-#else
-    for (size_t i = 0; i < 4; i++)
-    {
-        VB.vector4_u32[i] = static_cast<uint32_t>(VB.vector4_f32[i]);
-    }
-#endif
-
-    XMVECTOR VC2 = XMVectorMultiply(VC, VC);
-
-    XMVECTOR T7 = XMVectorSplatW(TanCoefficients1.v);
-    XMVECTOR T6 = XMVectorSplatZ(TanCoefficients1.v);
-    XMVECTOR T4 = XMVectorSplatX(TanCoefficients1.v);
-    XMVECTOR T3 = XMVectorSplatW(TanCoefficients0.v);
-    XMVECTOR T5 = XMVectorSplatY(TanCoefficients1.v);
-    XMVECTOR T2 = XMVectorSplatZ(TanCoefficients0.v);
-    XMVECTOR T1 = XMVectorSplatY(TanCoefficients0.v);
-    XMVECTOR T0 = XMVectorSplatX(TanCoefficients0.v);
-
-    XMVECTOR VBIsEven = XMVectorAndInt(VB, Mask.v);
-    VBIsEven = XMVectorEqualInt(VBIsEven, Zero);
-
-    XMVECTOR N = XMVectorMultiplyAdd(VC2, T7, T6);
-    XMVECTOR D = XMVectorMultiplyAdd(VC2, T4, T3);
-    N = XMVectorMultiplyAdd(VC2, N, T5);
-    D = XMVectorMultiplyAdd(VC2, D, T2);
-    N = XMVectorMultiply(VC2, N);
-    D = XMVectorMultiplyAdd(VC2, D, T1);
-    N = XMVectorMultiplyAdd(VC, N, VC);
-    XMVECTOR VCNearZero = XMVectorInBounds(VC, Epsilon);
-    D = XMVectorMultiplyAdd(VC2, D, T0);
-
-    N = XMVectorSelect(N, VC, VCNearZero);
-    D = XMVectorSelect(D, g_XMOne.v, VCNearZero);
-
-    XMVECTOR R0 = XMVectorNegate(N);
-    XMVECTOR R1 = XMVectorDivide(N, D);
-    R0 = XMVectorDivide(D, R0);
-
-    XMVECTOR VIsZero = XMVectorEqual(V, Zero);
-
-    XMVECTOR Result = XMVectorSelect(R0, R1, VBIsEven);
-
-    Result = XMVectorSelect(Result, Zero, VIsZero);
-
-    return Result;
-
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSinH(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            sinhf(V.vector4_f32[0]),
-            sinhf(V.vector4_f32[1]),
-            sinhf(V.vector4_f32[2]),
-            sinhf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 1.442695040888963f, 1.442695040888963f, 1.442695040888963f, 1.442695040888963f } } }; // 1.0f / ln(2.0f)
-
-    XMVECTOR V1 = vmlaq_f32(g_XMNegativeOne.v, V, Scale.v);
-    XMVECTOR V2 = vmlsq_f32(g_XMNegativeOne.v, V, Scale.v);
-    XMVECTOR E1 = XMVectorExp(V1);
-    XMVECTOR E2 = XMVectorExp(V2);
-
-    return vsubq_f32(E1, E2);
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_sinh_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 1.442695040888963f, 1.442695040888963f, 1.442695040888963f, 1.442695040888963f } } }; // 1.0f / ln(2.0f)
-
-    XMVECTOR V1 = XM_FMADD_PS(V, Scale, g_XMNegativeOne);
-    XMVECTOR V2 = XM_FNMADD_PS(V, Scale, g_XMNegativeOne);
-    XMVECTOR E1 = XMVectorExp(V1);
-    XMVECTOR E2 = XMVectorExp(V2);
-
-    return _mm_sub_ps(E1, E2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorCosH(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            coshf(V.vector4_f32[0]),
-            coshf(V.vector4_f32[1]),
-            coshf(V.vector4_f32[2]),
-            coshf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 1.442695040888963f, 1.442695040888963f, 1.442695040888963f, 1.442695040888963f } } }; // 1.0f / ln(2.0f)
-
-    XMVECTOR V1 = vmlaq_f32(g_XMNegativeOne.v, V, Scale.v);
-    XMVECTOR V2 = vmlsq_f32(g_XMNegativeOne.v, V, Scale.v);
-    XMVECTOR E1 = XMVectorExp(V1);
-    XMVECTOR E2 = XMVectorExp(V2);
-    return vaddq_f32(E1, E2);
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_cosh_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 1.442695040888963f, 1.442695040888963f, 1.442695040888963f, 1.442695040888963f } } }; // 1.0f / ln(2.0f)
-
-    XMVECTOR V1 = XM_FMADD_PS(V, Scale.v, g_XMNegativeOne.v);
-    XMVECTOR V2 = XM_FNMADD_PS(V, Scale.v, g_XMNegativeOne.v);
-    XMVECTOR E1 = XMVectorExp(V1);
-    XMVECTOR E2 = XMVectorExp(V2);
-    return _mm_add_ps(E1, E2);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorTanH(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            tanhf(V.vector4_f32[0]),
-            tanhf(V.vector4_f32[1]),
-            tanhf(V.vector4_f32[2]),
-            tanhf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 2.8853900817779268f, 2.8853900817779268f, 2.8853900817779268f, 2.8853900817779268f } } }; // 2.0f / ln(2.0f)
-
-    XMVECTOR E = vmulq_f32(V, Scale.v);
-    E = XMVectorExp(E);
-    E = vmlaq_f32(g_XMOneHalf.v, E, g_XMOneHalf.v);
-    E = XMVectorReciprocal(E);
-    return vsubq_f32(g_XMOne.v, E);
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_tanh_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 2.8853900817779268f, 2.8853900817779268f, 2.8853900817779268f, 2.8853900817779268f } } }; // 2.0f / ln(2.0f)
-
-    XMVECTOR E = _mm_mul_ps(V, Scale.v);
-    E = XMVectorExp(E);
-    E = XM_FMADD_PS(E, g_XMOneHalf.v, g_XMOneHalf.v);
-    E = _mm_div_ps(g_XMOne.v, E);
-    return _mm_sub_ps(g_XMOne.v, E);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorASin(FXMVECTOR V) noexcept
-{
-    // 7-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            asinf(V.vector4_f32[0]),
-            asinf(V.vector4_f32[1]),
-            asinf(V.vector4_f32[2]),
-            asinf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t nonnegative = vcgeq_f32(V, g_XMZero);
-    float32x4_t x = vabsq_f32(V);
-
-    // Compute (1-|V|), clamp to zero to avoid sqrt of negative number.
-    float32x4_t oneMValue = vsubq_f32(g_XMOne, x);
-    float32x4_t clampOneMValue = vmaxq_f32(g_XMZero, oneMValue);
-    float32x4_t root = XMVectorSqrt(clampOneMValue);
-
-    // Compute polynomial approximation
-    const XMVECTOR AC1 = g_XMArcCoefficients1;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AC1), 0);
-    XMVECTOR t0 = vmlaq_lane_f32(vConstants, x, vget_high_f32(AC1), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AC1), 1);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AC1), 0);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    const XMVECTOR AC0 = g_XMArcCoefficients0;
-    vConstants = vdupq_lane_f32(vget_high_f32(AC0), 1);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_high_f32(AC0), 0);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AC0), 1);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AC0), 0);
-    t0 = vmlaq_f32(vConstants, t0, x);
-    t0 = vmulq_f32(t0, root);
-
-    float32x4_t t1 = vsubq_f32(g_XMPi, t0);
-    t0 = vbslq_f32(nonnegative, t0, t1);
-    t0 = vsubq_f32(g_XMHalfPi, t0);
-    return t0;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_asin_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 nonnegative = _mm_cmpge_ps(V, g_XMZero);
-    __m128 mvalue = _mm_sub_ps(g_XMZero, V);
-    __m128 x = _mm_max_ps(V, mvalue);  // |V|
-
-    // Compute (1-|V|), clamp to zero to avoid sqrt of negative number.
-    __m128 oneMValue = _mm_sub_ps(g_XMOne, x);
-    __m128 clampOneMValue = _mm_max_ps(g_XMZero, oneMValue);
-    __m128 root = _mm_sqrt_ps(clampOneMValue);  // sqrt(1-|V|)
-
-    // Compute polynomial approximation
-    const XMVECTOR AC1 = g_XMArcCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(AC1, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 vConstants = XM_PERMUTE_PS(AC1, _MM_SHUFFLE(2, 2, 2, 2));
-    __m128 t0 = XM_FMADD_PS(vConstantsB, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC1, _MM_SHUFFLE(1, 1, 1, 1));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC1, _MM_SHUFFLE(0, 0, 0, 0));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    const XMVECTOR AC0 = g_XMArcCoefficients0;
-    vConstants = XM_PERMUTE_PS(AC0, _MM_SHUFFLE(3, 3, 3, 3));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC0, _MM_SHUFFLE(2, 2, 2, 2));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC0, _MM_SHUFFLE(1, 1, 1, 1));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC0, _MM_SHUFFLE(0, 0, 0, 0));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-    t0 = _mm_mul_ps(t0, root);
-
-    __m128 t1 = _mm_sub_ps(g_XMPi, t0);
-    t0 = _mm_and_ps(nonnegative, t0);
-    t1 = _mm_andnot_ps(nonnegative, t1);
-    t0 = _mm_or_ps(t0, t1);
-    t0 = _mm_sub_ps(g_XMHalfPi, t0);
-    return t0;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorACos(FXMVECTOR V) noexcept
-{
-    // 7-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            acosf(V.vector4_f32[0]),
-            acosf(V.vector4_f32[1]),
-            acosf(V.vector4_f32[2]),
-            acosf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t nonnegative = vcgeq_f32(V, g_XMZero);
-    float32x4_t x = vabsq_f32(V);
-
-    // Compute (1-|V|), clamp to zero to avoid sqrt of negative number.
-    float32x4_t oneMValue = vsubq_f32(g_XMOne, x);
-    float32x4_t clampOneMValue = vmaxq_f32(g_XMZero, oneMValue);
-    float32x4_t root = XMVectorSqrt(clampOneMValue);
-
-    // Compute polynomial approximation
-    const XMVECTOR AC1 = g_XMArcCoefficients1;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AC1), 0);
-    XMVECTOR t0 = vmlaq_lane_f32(vConstants, x, vget_high_f32(AC1), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AC1), 1);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AC1), 0);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    const XMVECTOR AC0 = g_XMArcCoefficients0;
-    vConstants = vdupq_lane_f32(vget_high_f32(AC0), 1);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_high_f32(AC0), 0);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AC0), 1);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AC0), 0);
-    t0 = vmlaq_f32(vConstants, t0, x);
-    t0 = vmulq_f32(t0, root);
-
-    float32x4_t t1 = vsubq_f32(g_XMPi, t0);
-    t0 = vbslq_f32(nonnegative, t0, t1);
-    return t0;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_acos_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 nonnegative = _mm_cmpge_ps(V, g_XMZero);
-    __m128 mvalue = _mm_sub_ps(g_XMZero, V);
-    __m128 x = _mm_max_ps(V, mvalue);  // |V|
-
-    // Compute (1-|V|), clamp to zero to avoid sqrt of negative number.
-    __m128 oneMValue = _mm_sub_ps(g_XMOne, x);
-    __m128 clampOneMValue = _mm_max_ps(g_XMZero, oneMValue);
-    __m128 root = _mm_sqrt_ps(clampOneMValue);  // sqrt(1-|V|)
-
-    // Compute polynomial approximation
-    const XMVECTOR AC1 = g_XMArcCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(AC1, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 vConstants = XM_PERMUTE_PS(AC1, _MM_SHUFFLE(2, 2, 2, 2));
-    __m128 t0 = XM_FMADD_PS(vConstantsB, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC1, _MM_SHUFFLE(1, 1, 1, 1));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC1, _MM_SHUFFLE(0, 0, 0, 0));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    const XMVECTOR AC0 = g_XMArcCoefficients0;
-    vConstants = XM_PERMUTE_PS(AC0, _MM_SHUFFLE(3, 3, 3, 3));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC0, _MM_SHUFFLE(2, 2, 2, 2));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC0, _MM_SHUFFLE(1, 1, 1, 1));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AC0, _MM_SHUFFLE(0, 0, 0, 0));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-    t0 = _mm_mul_ps(t0, root);
-
-    __m128 t1 = _mm_sub_ps(g_XMPi, t0);
-    t0 = _mm_and_ps(nonnegative, t0);
-    t1 = _mm_andnot_ps(nonnegative, t1);
-    t0 = _mm_or_ps(t0, t1);
-    return t0;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorATan(FXMVECTOR V) noexcept
-{
-    // 17-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            atanf(V.vector4_f32[0]),
-            atanf(V.vector4_f32[1]),
-            atanf(V.vector4_f32[2]),
-            atanf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t absV = vabsq_f32(V);
-    float32x4_t invV = XMVectorReciprocal(V);
-    uint32x4_t comp = vcgtq_f32(V, g_XMOne);
-    float32x4_t sign = vbslq_f32(comp, g_XMOne, g_XMNegativeOne);
-    comp = vcleq_f32(absV, g_XMOne);
-    sign = vbslq_f32(comp, g_XMZero, sign);
-    float32x4_t x = vbslq_f32(comp, V, invV);
-
-    float32x4_t x2 = vmulq_f32(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR TC1 = g_XMATanCoefficients1;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(TC1), 0);
-    XMVECTOR Result = vmlaq_lane_f32(vConstants, x2, vget_high_f32(TC1), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(TC1), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(TC1), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    const XMVECTOR TC0 = g_XMATanCoefficients0;
-    vConstants = vdupq_lane_f32(vget_high_f32(TC0), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_high_f32(TC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(TC0), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(TC0), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    Result = vmlaq_f32(g_XMOne, Result, x2);
-    Result = vmulq_f32(Result, x);
-
-    float32x4_t result1 = vmulq_f32(sign, g_XMHalfPi);
-    result1 = vsubq_f32(result1, Result);
-
-    comp = vceqq_f32(sign, g_XMZero);
-    Result = vbslq_f32(comp, Result, result1);
-    return Result;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_atan_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 absV = XMVectorAbs(V);
-    __m128 invV = _mm_div_ps(g_XMOne, V);
-    __m128 comp = _mm_cmpgt_ps(V, g_XMOne);
-    __m128 select0 = _mm_and_ps(comp, g_XMOne);
-    __m128 select1 = _mm_andnot_ps(comp, g_XMNegativeOne);
-    __m128 sign = _mm_or_ps(select0, select1);
-    comp = _mm_cmple_ps(absV, g_XMOne);
-    select0 = _mm_and_ps(comp, g_XMZero);
-    select1 = _mm_andnot_ps(comp, sign);
-    sign = _mm_or_ps(select0, select1);
-    select0 = _mm_and_ps(comp, V);
-    select1 = _mm_andnot_ps(comp, invV);
-    __m128 x = _mm_or_ps(select0, select1);
-
-    __m128 x2 = _mm_mul_ps(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR TC1 = g_XMATanCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(TC1, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 vConstants = XM_PERMUTE_PS(TC1, _MM_SHUFFLE(2, 2, 2, 2));
-    __m128 Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(TC1, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(TC1, _MM_SHUFFLE(0, 0, 0, 0));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    const XMVECTOR TC0 = g_XMATanCoefficients0;
-    vConstants = XM_PERMUTE_PS(TC0, _MM_SHUFFLE(3, 3, 3, 3));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(TC0, _MM_SHUFFLE(2, 2, 2, 2));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(TC0, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(TC0, _MM_SHUFFLE(0, 0, 0, 0));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    Result = XM_FMADD_PS(Result, x2, g_XMOne);
-
-    Result = _mm_mul_ps(Result, x);
-    __m128 result1 = _mm_mul_ps(sign, g_XMHalfPi);
-    result1 = _mm_sub_ps(result1, Result);
-
-    comp = _mm_cmpeq_ps(sign, g_XMZero);
-    select0 = _mm_and_ps(comp, Result);
-    select1 = _mm_andnot_ps(comp, result1);
-    Result = _mm_or_ps(select0, select1);
-    return Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorATan2
-        (
-                FXMVECTOR Y,
-                FXMVECTOR X
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            atan2f(Y.vector4_f32[0], X.vector4_f32[0]),
-            atan2f(Y.vector4_f32[1], X.vector4_f32[1]),
-            atan2f(Y.vector4_f32[2], X.vector4_f32[2]),
-            atan2f(Y.vector4_f32[3], X.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_atan2_ps(Y, X);
-    return Result;
-#else
-
-    // Return the inverse tangent of Y / X in the range of -Pi to Pi with the following exceptions:
-
-    //     Y == 0 and X is Negative         -> Pi with the sign of Y
-    //     y == 0 and x is positive         -> 0 with the sign of y
-    //     Y != 0 and X == 0                -> Pi / 2 with the sign of Y
-    //     Y != 0 and X is Negative         -> atan(y/x) + (PI with the sign of Y)
-    //     X == -Infinity and Finite Y      -> Pi with the sign of Y
-    //     X == +Infinity and Finite Y      -> 0 with the sign of Y
-    //     Y == Infinity and X is Finite    -> Pi / 2 with the sign of Y
-    //     Y == Infinity and X == -Infinity -> 3Pi / 4 with the sign of Y
-    //     Y == Infinity and X == +Infinity -> Pi / 4 with the sign of Y
-
-    static const XMVECTORF32 ATan2Constants = { { { XM_PI, XM_PIDIV2, XM_PIDIV4, XM_PI * 3.0f / 4.0f } } };
-
-    XMVECTOR Zero = XMVectorZero();
-    XMVECTOR ATanResultValid = XMVectorTrueInt();
-
-    XMVECTOR Pi = XMVectorSplatX(ATan2Constants);
-    XMVECTOR PiOverTwo = XMVectorSplatY(ATan2Constants);
-    XMVECTOR PiOverFour = XMVectorSplatZ(ATan2Constants);
-    XMVECTOR ThreePiOverFour = XMVectorSplatW(ATan2Constants);
-
-    XMVECTOR YEqualsZero = XMVectorEqual(Y, Zero);
-    XMVECTOR XEqualsZero = XMVectorEqual(X, Zero);
-    XMVECTOR XIsPositive = XMVectorAndInt(X, g_XMNegativeZero.v);
-    XIsPositive = XMVectorEqualInt(XIsPositive, Zero);
-    XMVECTOR YEqualsInfinity = XMVectorIsInfinite(Y);
-    XMVECTOR XEqualsInfinity = XMVectorIsInfinite(X);
-
-    XMVECTOR YSign = XMVectorAndInt(Y, g_XMNegativeZero.v);
-    Pi = XMVectorOrInt(Pi, YSign);
-    PiOverTwo = XMVectorOrInt(PiOverTwo, YSign);
-    PiOverFour = XMVectorOrInt(PiOverFour, YSign);
-    ThreePiOverFour = XMVectorOrInt(ThreePiOverFour, YSign);
-
-    XMVECTOR R1 = XMVectorSelect(Pi, YSign, XIsPositive);
-    XMVECTOR R2 = XMVectorSelect(ATanResultValid, PiOverTwo, XEqualsZero);
-    XMVECTOR R3 = XMVectorSelect(R2, R1, YEqualsZero);
-    XMVECTOR R4 = XMVectorSelect(ThreePiOverFour, PiOverFour, XIsPositive);
-    XMVECTOR R5 = XMVectorSelect(PiOverTwo, R4, XEqualsInfinity);
-    XMVECTOR Result = XMVectorSelect(R3, R5, YEqualsInfinity);
-    ATanResultValid = XMVectorEqualInt(Result, ATanResultValid);
-
-    XMVECTOR V = XMVectorDivide(Y, X);
-
-    XMVECTOR R0 = XMVectorATan(V);
-
-    R1 = XMVectorSelect(Pi, g_XMNegativeZero, XIsPositive);
-    R2 = XMVectorAdd(R0, R1);
-
-    return XMVectorSelect(Result, R2, ATanResultValid);
-
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorSinEst(FXMVECTOR V) noexcept
-{
-    // 7-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            sinf(V.vector4_f32[0]),
-            sinf(V.vector4_f32[1]),
-            sinf(V.vector4_f32[2]),
-            sinf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Force the value within the bounds of pi
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with sin(y) = sin(x).
-    uint32x4_t sign = vandq_u32(vreinterpretq_u32_f32(x), g_XMNegativeZero);
-    uint32x4_t c = vorrq_u32(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    float32x4_t absx = vabsq_f32(x);
-    float32x4_t rflx = vsubq_f32(vreinterpretq_f32_u32(c), x);
-    uint32x4_t comp = vcleq_f32(absx, g_XMHalfPi);
-    x = vbslq_f32(comp, x, rflx);
-
-    float32x4_t x2 = vmulq_f32(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR SEC = g_XMSinCoefficients1;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(SEC), 0);
-    XMVECTOR Result = vmlaq_lane_f32(vConstants, x2, vget_high_f32(SEC), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(SEC), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    Result = vmlaq_f32(g_XMOne, Result, x2);
-    Result = vmulq_f32(Result, x);
-    return Result;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_sin_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Force the value within the bounds of pi
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with sin(y) = sin(x).
-    __m128 sign = _mm_and_ps(x, g_XMNegativeZero);
-    __m128 c = _mm_or_ps(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    __m128 absx = _mm_andnot_ps(sign, x);  // |x|
-    __m128 rflx = _mm_sub_ps(c, x);
-    __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi);
-    __m128 select0 = _mm_and_ps(comp, x);
-    __m128 select1 = _mm_andnot_ps(comp, rflx);
-    x = _mm_or_ps(select0, select1);
-
-    __m128 x2 = _mm_mul_ps(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR SEC = g_XMSinCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(SEC, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 vConstants = XM_PERMUTE_PS(SEC, _MM_SHUFFLE(2, 2, 2, 2));
-    __m128 Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(SEC, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-    Result = XM_FMADD_PS(Result, x2, g_XMOne);
-    Result = _mm_mul_ps(Result, x);
-    return Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorCosEst(FXMVECTOR V) noexcept
-{
-    // 6-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            cosf(V.vector4_f32[0]),
-            cosf(V.vector4_f32[1]),
-            cosf(V.vector4_f32[2]),
-            cosf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Map V to x in [-pi,pi].
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x).
-    uint32x4_t sign = vandq_u32(vreinterpretq_u32_f32(x), g_XMNegativeZero);
-    uint32x4_t c = vorrq_u32(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    float32x4_t absx = vabsq_f32(x);
-    float32x4_t rflx = vsubq_f32(vreinterpretq_f32_u32(c), x);
-    uint32x4_t comp = vcleq_f32(absx, g_XMHalfPi);
-    x = vbslq_f32(comp, x, rflx);
-    float32x4_t fsign = vbslq_f32(comp, g_XMOne, g_XMNegativeOne);
-
-    float32x4_t x2 = vmulq_f32(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR CEC = g_XMCosCoefficients1;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(CEC), 0);
-    XMVECTOR Result = vmlaq_lane_f32(vConstants, x2, vget_high_f32(CEC), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(CEC), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    Result = vmlaq_f32(g_XMOne, Result, x2);
-    Result = vmulq_f32(Result, fsign);
-    return Result;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_cos_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Map V to x in [-pi,pi].
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x).
-    XMVECTOR sign = _mm_and_ps(x, g_XMNegativeZero);
-    __m128 c = _mm_or_ps(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    __m128 absx = _mm_andnot_ps(sign, x);  // |x|
-    __m128 rflx = _mm_sub_ps(c, x);
-    __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi);
-    __m128 select0 = _mm_and_ps(comp, x);
-    __m128 select1 = _mm_andnot_ps(comp, rflx);
-    x = _mm_or_ps(select0, select1);
-    select0 = _mm_and_ps(comp, g_XMOne);
-    select1 = _mm_andnot_ps(comp, g_XMNegativeOne);
-    sign = _mm_or_ps(select0, select1);
-
-    __m128 x2 = _mm_mul_ps(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR CEC = g_XMCosCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(CEC, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 vConstants = XM_PERMUTE_PS(CEC, _MM_SHUFFLE(2, 2, 2, 2));
-    __m128 Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(CEC, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-    Result = XM_FMADD_PS(Result, x2, g_XMOne);
-    Result = _mm_mul_ps(Result, sign);
-    return Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVectorSinCosEst
-        (
-                XMVECTOR* pSin,
-                XMVECTOR* pCos,
-                FXMVECTOR  V
-        ) noexcept
-{
-    assert(pSin != nullptr);
-    assert(pCos != nullptr);
-
-    // 7/6-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Sin = { { {
-            sinf(V.vector4_f32[0]),
-            sinf(V.vector4_f32[1]),
-            sinf(V.vector4_f32[2]),
-            sinf(V.vector4_f32[3])
-        } } };
-
-    XMVECTORF32 Cos = { { {
-            cosf(V.vector4_f32[0]),
-            cosf(V.vector4_f32[1]),
-            cosf(V.vector4_f32[2]),
-            cosf(V.vector4_f32[3])
-        } } };
-
-    *pSin = Sin.v;
-    *pCos = Cos.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Force the value within the bounds of pi
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x).
-    uint32x4_t sign = vandq_u32(vreinterpretq_u32_f32(x), g_XMNegativeZero);
-    uint32x4_t c = vorrq_u32(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    float32x4_t absx = vabsq_f32(x);
-    float32x4_t rflx = vsubq_f32(vreinterpretq_f32_u32(c), x);
-    uint32x4_t comp = vcleq_f32(absx, g_XMHalfPi);
-    x = vbslq_f32(comp, x, rflx);
-    float32x4_t fsign = vbslq_f32(comp, g_XMOne, g_XMNegativeOne);
-
-    float32x4_t x2 = vmulq_f32(x, x);
-
-    // Compute polynomial approximation for sine
-    const XMVECTOR SEC = g_XMSinCoefficients1;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(SEC), 0);
-    XMVECTOR Result = vmlaq_lane_f32(vConstants, x2, vget_high_f32(SEC), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(SEC), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    Result = vmlaq_f32(g_XMOne, Result, x2);
-    *pSin = vmulq_f32(Result, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR CEC = g_XMCosCoefficients1;
-    vConstants = vdupq_lane_f32(vget_high_f32(CEC), 0);
-    Result = vmlaq_lane_f32(vConstants, x2, vget_high_f32(CEC), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(CEC), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    Result = vmlaq_f32(g_XMOne, Result, x2);
-    *pCos = vmulq_f32(Result, fsign);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Force the value within the bounds of pi
-    XMVECTOR x = XMVectorModAngles(V);
-
-    // Map in [-pi/2,pi/2] with sin(y) = sin(x), cos(y) = sign*cos(x).
-    XMVECTOR sign = _mm_and_ps(x, g_XMNegativeZero);
-    __m128 c = _mm_or_ps(g_XMPi, sign);  // pi when x >= 0, -pi when x < 0
-    __m128 absx = _mm_andnot_ps(sign, x);  // |x|
-    __m128 rflx = _mm_sub_ps(c, x);
-    __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi);
-    __m128 select0 = _mm_and_ps(comp, x);
-    __m128 select1 = _mm_andnot_ps(comp, rflx);
-    x = _mm_or_ps(select0, select1);
-    select0 = _mm_and_ps(comp, g_XMOne);
-    select1 = _mm_andnot_ps(comp, g_XMNegativeOne);
-    sign = _mm_or_ps(select0, select1);
-
-    __m128 x2 = _mm_mul_ps(x, x);
-
-    // Compute polynomial approximation for sine
-    const XMVECTOR SEC = g_XMSinCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(SEC, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 vConstants = XM_PERMUTE_PS(SEC, _MM_SHUFFLE(2, 2, 2, 2));
-    __m128 Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(SEC, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-    Result = XM_FMADD_PS(Result, x2, g_XMOne);
-    Result = _mm_mul_ps(Result, x);
-    *pSin = Result;
-
-    // Compute polynomial approximation for cosine
-    const XMVECTOR CEC = g_XMCosCoefficients1;
-    vConstantsB = XM_PERMUTE_PS(CEC, _MM_SHUFFLE(3, 3, 3, 3));
-    vConstants = XM_PERMUTE_PS(CEC, _MM_SHUFFLE(2, 2, 2, 2));
-    Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(CEC, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-    Result = XM_FMADD_PS(Result, x2, g_XMOne);
-    Result = _mm_mul_ps(Result, sign);
-    *pCos = Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorTanEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            tanf(V.vector4_f32[0]),
-            tanf(V.vector4_f32[1]),
-            tanf(V.vector4_f32[2]),
-            tanf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_tan_ps(V);
-    return Result;
-#else
-
-    XMVECTOR OneOverPi = XMVectorSplatW(g_XMTanEstCoefficients.v);
-
-    XMVECTOR V1 = XMVectorMultiply(V, OneOverPi);
-    V1 = XMVectorRound(V1);
-
-    V1 = XMVectorNegativeMultiplySubtract(g_XMPi.v, V1, V);
-
-    XMVECTOR T0 = XMVectorSplatX(g_XMTanEstCoefficients.v);
-    XMVECTOR T1 = XMVectorSplatY(g_XMTanEstCoefficients.v);
-    XMVECTOR T2 = XMVectorSplatZ(g_XMTanEstCoefficients.v);
-
-    XMVECTOR V2T2 = XMVectorNegativeMultiplySubtract(V1, V1, T2);
-    XMVECTOR V2 = XMVectorMultiply(V1, V1);
-    XMVECTOR V1T0 = XMVectorMultiply(V1, T0);
-    XMVECTOR V1T1 = XMVectorMultiply(V1, T1);
-
-    XMVECTOR D = XMVectorReciprocalEst(V2T2);
-    XMVECTOR N = XMVectorMultiplyAdd(V2, V1T1, V1T0);
-
-    return XMVectorMultiply(N, D);
-
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorASinEst(FXMVECTOR V) noexcept
-{
-    // 3-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result;
-    Result.f[0] = asinf(V.vector4_f32[0]);
-    Result.f[1] = asinf(V.vector4_f32[1]);
-    Result.f[2] = asinf(V.vector4_f32[2]);
-    Result.f[3] = asinf(V.vector4_f32[3]);
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t nonnegative = vcgeq_f32(V, g_XMZero);
-    float32x4_t x = vabsq_f32(V);
-
-    // Compute (1-|V|), clamp to zero to avoid sqrt of negative number.
-    float32x4_t oneMValue = vsubq_f32(g_XMOne, x);
-    float32x4_t clampOneMValue = vmaxq_f32(g_XMZero, oneMValue);
-    float32x4_t root = XMVectorSqrt(clampOneMValue);
-
-    // Compute polynomial approximation
-    const XMVECTOR AEC = g_XMArcEstCoefficients;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AEC), 0);
-    XMVECTOR t0 = vmlaq_lane_f32(vConstants, x, vget_high_f32(AEC), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AEC), 1);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AEC), 0);
-    t0 = vmlaq_f32(vConstants, t0, x);
-    t0 = vmulq_f32(t0, root);
-
-    float32x4_t t1 = vsubq_f32(g_XMPi, t0);
-    t0 = vbslq_f32(nonnegative, t0, t1);
-    t0 = vsubq_f32(g_XMHalfPi, t0);
-    return t0;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_asin_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 nonnegative = _mm_cmpge_ps(V, g_XMZero);
-    __m128 mvalue = _mm_sub_ps(g_XMZero, V);
-    __m128 x = _mm_max_ps(V, mvalue);  // |V|
-
-    // Compute (1-|V|), clamp to zero to avoid sqrt of negative number.
-    __m128 oneMValue = _mm_sub_ps(g_XMOne, x);
-    __m128 clampOneMValue = _mm_max_ps(g_XMZero, oneMValue);
-    __m128 root = _mm_sqrt_ps(clampOneMValue);  // sqrt(1-|V|)
-
-    // Compute polynomial approximation
-    const XMVECTOR AEC = g_XMArcEstCoefficients;
-    __m128 vConstantsB = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 vConstants = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(2, 2, 2, 2));
-    __m128 t0 = XM_FMADD_PS(vConstantsB, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(1, 1, 1, 1));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(0, 0, 0, 0));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-    t0 = _mm_mul_ps(t0, root);
-
-    __m128 t1 = _mm_sub_ps(g_XMPi, t0);
-    t0 = _mm_and_ps(nonnegative, t0);
-    t1 = _mm_andnot_ps(nonnegative, t1);
-    t0 = _mm_or_ps(t0, t1);
-    t0 = _mm_sub_ps(g_XMHalfPi, t0);
-    return t0;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorACosEst(FXMVECTOR V) noexcept
-{
-    // 3-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            acosf(V.vector4_f32[0]),
-            acosf(V.vector4_f32[1]),
-            acosf(V.vector4_f32[2]),
-            acosf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t nonnegative = vcgeq_f32(V, g_XMZero);
-    float32x4_t x = vabsq_f32(V);
-
-    // Compute (1-|V|), clamp to zero to avoid sqrt of negative number.
-    float32x4_t oneMValue = vsubq_f32(g_XMOne, x);
-    float32x4_t clampOneMValue = vmaxq_f32(g_XMZero, oneMValue);
-    float32x4_t root = XMVectorSqrt(clampOneMValue);
-
-    // Compute polynomial approximation
-    const XMVECTOR AEC = g_XMArcEstCoefficients;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AEC), 0);
-    XMVECTOR t0 = vmlaq_lane_f32(vConstants, x, vget_high_f32(AEC), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AEC), 1);
-    t0 = vmlaq_f32(vConstants, t0, x);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AEC), 0);
-    t0 = vmlaq_f32(vConstants, t0, x);
-    t0 = vmulq_f32(t0, root);
-
-    float32x4_t t1 = vsubq_f32(g_XMPi, t0);
-    t0 = vbslq_f32(nonnegative, t0, t1);
-    return t0;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_acos_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 nonnegative = _mm_cmpge_ps(V, g_XMZero);
-    __m128 mvalue = _mm_sub_ps(g_XMZero, V);
-    __m128 x = _mm_max_ps(V, mvalue);  // |V|
-
-    // Compute (1-|V|), clamp to zero to avoid sqrt of negative number.
-    __m128 oneMValue = _mm_sub_ps(g_XMOne, x);
-    __m128 clampOneMValue = _mm_max_ps(g_XMZero, oneMValue);
-    __m128 root = _mm_sqrt_ps(clampOneMValue);  // sqrt(1-|V|)
-
-    // Compute polynomial approximation
-    const XMVECTOR AEC = g_XMArcEstCoefficients;
-    __m128 vConstantsB = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 vConstants = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(2, 2, 2, 2));
-    __m128 t0 = XM_FMADD_PS(vConstantsB, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(1, 1, 1, 1));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(0, 0, 0, 0));
-    t0 = XM_FMADD_PS(t0, x, vConstants);
-    t0 = _mm_mul_ps(t0, root);
-
-    __m128 t1 = _mm_sub_ps(g_XMPi, t0);
-    t0 = _mm_and_ps(nonnegative, t0);
-    t1 = _mm_andnot_ps(nonnegative, t1);
-    t0 = _mm_or_ps(t0, t1);
-    return t0;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorATanEst(FXMVECTOR V) noexcept
-{
-    // 9-degree minimax approximation
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            atanf(V.vector4_f32[0]),
-            atanf(V.vector4_f32[1]),
-            atanf(V.vector4_f32[2]),
-            atanf(V.vector4_f32[3])
-        } } };
-    return Result.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t absV = vabsq_f32(V);
-    float32x4_t invV = XMVectorReciprocalEst(V);
-    uint32x4_t comp = vcgtq_f32(V, g_XMOne);
-    float32x4_t sign = vbslq_f32(comp, g_XMOne, g_XMNegativeOne);
-    comp = vcleq_f32(absV, g_XMOne);
-    sign = vbslq_f32(comp, g_XMZero, sign);
-    float32x4_t x = vbslq_f32(comp, V, invV);
-
-    float32x4_t x2 = vmulq_f32(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR AEC = g_XMATanEstCoefficients1;
-    XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AEC), 0);
-    XMVECTOR Result = vmlaq_lane_f32(vConstants, x2, vget_high_f32(AEC), 1);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AEC), 1);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    vConstants = vdupq_lane_f32(vget_low_f32(AEC), 0);
-    Result = vmlaq_f32(vConstants, Result, x2);
-
-    // ATanEstCoefficients0 is already splatted
-    Result = vmlaq_f32(g_XMATanEstCoefficients0, Result, x2);
-    Result = vmulq_f32(Result, x);
-
-    float32x4_t result1 = vmulq_f32(sign, g_XMHalfPi);
-    result1 = vsubq_f32(result1, Result);
-
-    comp = vceqq_f32(sign, g_XMZero);
-    Result = vbslq_f32(comp, Result, result1);
-    return Result;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_atan_ps(V);
-    return Result;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128 absV = XMVectorAbs(V);
-    __m128 invV = _mm_div_ps(g_XMOne, V);
-    __m128 comp = _mm_cmpgt_ps(V, g_XMOne);
-    __m128 select0 = _mm_and_ps(comp, g_XMOne);
-    __m128 select1 = _mm_andnot_ps(comp, g_XMNegativeOne);
-    __m128 sign = _mm_or_ps(select0, select1);
-    comp = _mm_cmple_ps(absV, g_XMOne);
-    select0 = _mm_and_ps(comp, g_XMZero);
-    select1 = _mm_andnot_ps(comp, sign);
-    sign = _mm_or_ps(select0, select1);
-    select0 = _mm_and_ps(comp, V);
-    select1 = _mm_andnot_ps(comp, invV);
-    __m128 x = _mm_or_ps(select0, select1);
-
-    __m128 x2 = _mm_mul_ps(x, x);
-
-    // Compute polynomial approximation
-    const XMVECTOR AEC = g_XMATanEstCoefficients1;
-    __m128 vConstantsB = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(3, 3, 3, 3));
-    __m128 vConstants = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(2, 2, 2, 2));
-    __m128 Result = XM_FMADD_PS(vConstantsB, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(1, 1, 1, 1));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-
-    vConstants = XM_PERMUTE_PS(AEC, _MM_SHUFFLE(0, 0, 0, 0));
-    Result = XM_FMADD_PS(Result, x2, vConstants);
-    // ATanEstCoefficients0 is already splatted
-    Result = XM_FMADD_PS(Result, x2, g_XMATanEstCoefficients0);
-    Result = _mm_mul_ps(Result, x);
-    __m128 result1 = _mm_mul_ps(sign, g_XMHalfPi);
-    result1 = _mm_sub_ps(result1, Result);
-
-    comp = _mm_cmpeq_ps(sign, g_XMZero);
-    select0 = _mm_and_ps(comp, Result);
-    select1 = _mm_andnot_ps(comp, result1);
-    Result = _mm_or_ps(select0, select1);
-    return Result;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorATan2Est
-        (
-                FXMVECTOR Y,
-                FXMVECTOR X
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 Result = { { {
-            atan2f(Y.vector4_f32[0], X.vector4_f32[0]),
-            atan2f(Y.vector4_f32[1], X.vector4_f32[1]),
-            atan2f(Y.vector4_f32[2], X.vector4_f32[2]),
-            atan2f(Y.vector4_f32[3], X.vector4_f32[3]),
-        } } };
-    return Result.v;
-#elif defined(_XM_SVML_INTRINSICS_)
-    XMVECTOR Result = _mm_atan2_ps(Y, X);
-    return Result;
-#else
-
-    static const XMVECTORF32 ATan2Constants = { { { XM_PI, XM_PIDIV2, XM_PIDIV4, 2.3561944905f /* Pi*3/4 */ } } };
-
-    const XMVECTOR Zero = XMVectorZero();
-    XMVECTOR ATanResultValid = XMVectorTrueInt();
-
-    XMVECTOR Pi = XMVectorSplatX(ATan2Constants);
-    XMVECTOR PiOverTwo = XMVectorSplatY(ATan2Constants);
-    XMVECTOR PiOverFour = XMVectorSplatZ(ATan2Constants);
-    XMVECTOR ThreePiOverFour = XMVectorSplatW(ATan2Constants);
-
-    XMVECTOR YEqualsZero = XMVectorEqual(Y, Zero);
-    XMVECTOR XEqualsZero = XMVectorEqual(X, Zero);
-    XMVECTOR XIsPositive = XMVectorAndInt(X, g_XMNegativeZero.v);
-    XIsPositive = XMVectorEqualInt(XIsPositive, Zero);
-    XMVECTOR YEqualsInfinity = XMVectorIsInfinite(Y);
-    XMVECTOR XEqualsInfinity = XMVectorIsInfinite(X);
-
-    XMVECTOR YSign = XMVectorAndInt(Y, g_XMNegativeZero.v);
-    Pi = XMVectorOrInt(Pi, YSign);
-    PiOverTwo = XMVectorOrInt(PiOverTwo, YSign);
-    PiOverFour = XMVectorOrInt(PiOverFour, YSign);
-    ThreePiOverFour = XMVectorOrInt(ThreePiOverFour, YSign);
-
-    XMVECTOR R1 = XMVectorSelect(Pi, YSign, XIsPositive);
-    XMVECTOR R2 = XMVectorSelect(ATanResultValid, PiOverTwo, XEqualsZero);
-    XMVECTOR R3 = XMVectorSelect(R2, R1, YEqualsZero);
-    XMVECTOR R4 = XMVectorSelect(ThreePiOverFour, PiOverFour, XIsPositive);
-    XMVECTOR R5 = XMVectorSelect(PiOverTwo, R4, XEqualsInfinity);
-    XMVECTOR Result = XMVectorSelect(R3, R5, YEqualsInfinity);
-    ATanResultValid = XMVectorEqualInt(Result, ATanResultValid);
-
-    XMVECTOR Reciprocal = XMVectorReciprocalEst(X);
-    XMVECTOR V = XMVectorMultiply(Y, Reciprocal);
-    XMVECTOR R0 = XMVectorATanEst(V);
-
-    R1 = XMVectorSelect(Pi, g_XMNegativeZero, XIsPositive);
-    R2 = XMVectorAdd(R0, R1);
-
-    Result = XMVectorSelect(Result, R2, ATanResultValid);
-
-    return Result;
-
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorLerp
-        (
-                FXMVECTOR V0,
-                FXMVECTOR V1,
-                float    t
-        ) noexcept
-{
-    // V0 + t * (V1 - V0)
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Scale = XMVectorReplicate(t);
-    XMVECTOR Length = XMVectorSubtract(V1, V0);
-    return XMVectorMultiplyAdd(Length, Scale, V0);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR L = vsubq_f32(V1, V0);
-    return vmlaq_n_f32(V0, L, t);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR L = _mm_sub_ps(V1, V0);
-    XMVECTOR S = _mm_set_ps1(t);
-    return XM_FMADD_PS(L, S, V0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorLerpV
-        (
-                FXMVECTOR V0,
-                FXMVECTOR V1,
-                FXMVECTOR T
-        ) noexcept
-{
-    // V0 + T * (V1 - V0)
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Length = XMVectorSubtract(V1, V0);
-    return XMVectorMultiplyAdd(Length, T, V0);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR L = vsubq_f32(V1, V0);
-    return vmlaq_f32(V0, L, T);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR Length = _mm_sub_ps(V1, V0);
-    return XM_FMADD_PS(Length, T, V0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorHermite
-        (
-                FXMVECTOR Position0,
-                FXMVECTOR Tangent0,
-                FXMVECTOR Position1,
-                GXMVECTOR Tangent1,
-                float    t
-        ) noexcept
-{
-    // Result = (2 * t^3 - 3 * t^2 + 1) * Position0 +
-    //          (t^3 - 2 * t^2 + t) * Tangent0 +
-    //          (-2 * t^3 + 3 * t^2) * Position1 +
-    //          (t^3 - t^2) * Tangent1
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float t2 = t * t;
-    float t3 = t * t2;
-
-    XMVECTOR P0 = XMVectorReplicate(2.0f * t3 - 3.0f * t2 + 1.0f);
-    XMVECTOR T0 = XMVectorReplicate(t3 - 2.0f * t2 + t);
-    XMVECTOR P1 = XMVectorReplicate(-2.0f * t3 + 3.0f * t2);
-    XMVECTOR T1 = XMVectorReplicate(t3 - t2);
-
-    XMVECTOR Result = XMVectorMultiply(P0, Position0);
-    Result = XMVectorMultiplyAdd(T0, Tangent0, Result);
-    Result = XMVectorMultiplyAdd(P1, Position1, Result);
-    Result = XMVectorMultiplyAdd(T1, Tangent1, Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float t2 = t * t;
-    float t3 = t * t2;
-
-    float p0 = 2.0f * t3 - 3.0f * t2 + 1.0f;
-    float t0 = t3 - 2.0f * t2 + t;
-    float p1 = -2.0f * t3 + 3.0f * t2;
-    float t1 = t3 - t2;
-
-    XMVECTOR vResult = vmulq_n_f32(Position0, p0);
-    vResult = vmlaq_n_f32(vResult, Tangent0, t0);
-    vResult = vmlaq_n_f32(vResult, Position1, p1);
-    vResult = vmlaq_n_f32(vResult, Tangent1, t1);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    float t2 = t * t;
-    float t3 = t * t2;
-
-    XMVECTOR P0 = _mm_set_ps1(2.0f * t3 - 3.0f * t2 + 1.0f);
-    XMVECTOR T0 = _mm_set_ps1(t3 - 2.0f * t2 + t);
-    XMVECTOR P1 = _mm_set_ps1(-2.0f * t3 + 3.0f * t2);
-    XMVECTOR T1 = _mm_set_ps1(t3 - t2);
-
-    XMVECTOR vResult = _mm_mul_ps(P0, Position0);
-    vResult = XM_FMADD_PS(Tangent0, T0, vResult);
-    vResult = XM_FMADD_PS(Position1, P1, vResult);
-    vResult = XM_FMADD_PS(Tangent1, T1, vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorHermiteV
-        (
-                FXMVECTOR Position0,
-                FXMVECTOR Tangent0,
-                FXMVECTOR Position1,
-                GXMVECTOR Tangent1,
-                HXMVECTOR T
-        ) noexcept
-{
-    // Result = (2 * t^3 - 3 * t^2 + 1) * Position0 +
-    //          (t^3 - 2 * t^2 + t) * Tangent0 +
-    //          (-2 * t^3 + 3 * t^2) * Position1 +
-    //          (t^3 - t^2) * Tangent1
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR T2 = XMVectorMultiply(T, T);
-    XMVECTOR T3 = XMVectorMultiply(T, T2);
-
-    XMVECTOR P0 = XMVectorReplicate(2.0f * T3.vector4_f32[0] - 3.0f * T2.vector4_f32[0] + 1.0f);
-    XMVECTOR T0 = XMVectorReplicate(T3.vector4_f32[1] - 2.0f * T2.vector4_f32[1] + T.vector4_f32[1]);
-    XMVECTOR P1 = XMVectorReplicate(-2.0f * T3.vector4_f32[2] + 3.0f * T2.vector4_f32[2]);
-    XMVECTOR T1 = XMVectorReplicate(T3.vector4_f32[3] - T2.vector4_f32[3]);
-
-    XMVECTOR Result = XMVectorMultiply(P0, Position0);
-    Result = XMVectorMultiplyAdd(T0, Tangent0, Result);
-    Result = XMVectorMultiplyAdd(P1, Position1, Result);
-    Result = XMVectorMultiplyAdd(T1, Tangent1, Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 CatMulT2 = { { { -3.0f, -2.0f, 3.0f, -1.0f } } };
-    static const XMVECTORF32 CatMulT3 = { { { 2.0f, 1.0f, -2.0f, 1.0f } } };
-
-    XMVECTOR T2 = vmulq_f32(T, T);
-    XMVECTOR T3 = vmulq_f32(T, T2);
-    // Mul by the constants against t^2
-    T2 = vmulq_f32(T2, CatMulT2);
-    // Mul by the constants against t^3
-    T3 = vmlaq_f32(T2, T3, CatMulT3);
-    // T3 now has the pre-result.
-    // I need to add t.y only
-    T2 = vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(T), g_XMMaskY));
-    T3 = vaddq_f32(T3, T2);
-    // Add 1.0f to x
-    T3 = vaddq_f32(T3, g_XMIdentityR0);
-    // Now, I have the constants created
-    // Mul the x constant to Position0
-    XMVECTOR vResult = vmulq_lane_f32(Position0, vget_low_f32(T3), 0); // T3[0]
-    // Mul the y constant to Tangent0
-    vResult = vmlaq_lane_f32(vResult, Tangent0, vget_low_f32(T3), 1); // T3[1]
-    // Mul the z constant to Position1
-    vResult = vmlaq_lane_f32(vResult, Position1, vget_high_f32(T3), 0); // T3[2]
-    // Mul the w constant to Tangent1
-    vResult = vmlaq_lane_f32(vResult, Tangent1, vget_high_f32(T3), 1); // T3[3]
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 CatMulT2 = { { { -3.0f, -2.0f, 3.0f, -1.0f } } };
-    static const XMVECTORF32 CatMulT3 = { { { 2.0f, 1.0f, -2.0f, 1.0f } } };
-
-    XMVECTOR T2 = _mm_mul_ps(T, T);
-    XMVECTOR T3 = _mm_mul_ps(T, T2);
-    // Mul by the constants against t^2
-    T2 = _mm_mul_ps(T2, CatMulT2);
-    // Mul by the constants against t^3
-    T3 = XM_FMADD_PS(T3, CatMulT3, T2);
-    // T3 now has the pre-result.
-    // I need to add t.y only
-    T2 = _mm_and_ps(T, g_XMMaskY);
-    T3 = _mm_add_ps(T3, T2);
-    // Add 1.0f to x
-    T3 = _mm_add_ps(T3, g_XMIdentityR0);
-    // Now, I have the constants created
-    // Mul the x constant to Position0
-    XMVECTOR vResult = XM_PERMUTE_PS(T3, _MM_SHUFFLE(0, 0, 0, 0));
-    vResult = _mm_mul_ps(vResult, Position0);
-    // Mul the y constant to Tangent0
-    T2 = XM_PERMUTE_PS(T3, _MM_SHUFFLE(1, 1, 1, 1));
-    vResult = XM_FMADD_PS(T2, Tangent0, vResult);
-    // Mul the z constant to Position1
-    T2 = XM_PERMUTE_PS(T3, _MM_SHUFFLE(2, 2, 2, 2));
-    vResult = XM_FMADD_PS(T2, Position1, vResult);
-    // Mul the w constant to Tangent1
-    T3 = XM_PERMUTE_PS(T3, _MM_SHUFFLE(3, 3, 3, 3));
-    vResult = XM_FMADD_PS(T3, Tangent1, vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorCatmullRom
-        (
-                FXMVECTOR Position0,
-                FXMVECTOR Position1,
-                FXMVECTOR Position2,
-                GXMVECTOR Position3,
-                float    t
-        ) noexcept
-{
-    // Result = ((-t^3 + 2 * t^2 - t) * Position0 +
-    //           (3 * t^3 - 5 * t^2 + 2) * Position1 +
-    //           (-3 * t^3 + 4 * t^2 + t) * Position2 +
-    //           (t^3 - t^2) * Position3) * 0.5
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float t2 = t * t;
-    float t3 = t * t2;
-
-    XMVECTOR P0 = XMVectorReplicate((-t3 + 2.0f * t2 - t) * 0.5f);
-    XMVECTOR P1 = XMVectorReplicate((3.0f * t3 - 5.0f * t2 + 2.0f) * 0.5f);
-    XMVECTOR P2 = XMVectorReplicate((-3.0f * t3 + 4.0f * t2 + t) * 0.5f);
-    XMVECTOR P3 = XMVectorReplicate((t3 - t2) * 0.5f);
-
-    XMVECTOR Result = XMVectorMultiply(P0, Position0);
-    Result = XMVectorMultiplyAdd(P1, Position1, Result);
-    Result = XMVectorMultiplyAdd(P2, Position2, Result);
-    Result = XMVectorMultiplyAdd(P3, Position3, Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float t2 = t * t;
-    float t3 = t * t2;
-
-    float p0 = (-t3 + 2.0f * t2 - t) * 0.5f;
-    float p1 = (3.0f * t3 - 5.0f * t2 + 2.0f) * 0.5f;
-    float p2 = (-3.0f * t3 + 4.0f * t2 + t) * 0.5f;
-    float p3 = (t3 - t2) * 0.5f;
-
-    XMVECTOR P1 = vmulq_n_f32(Position1, p1);
-    XMVECTOR P0 = vmlaq_n_f32(P1, Position0, p0);
-    XMVECTOR P3 = vmulq_n_f32(Position3, p3);
-    XMVECTOR P2 = vmlaq_n_f32(P3, Position2, p2);
-    P0 = vaddq_f32(P0, P2);
-    return P0;
-#elif defined(_XM_SSE_INTRINSICS_)
-    float t2 = t * t;
-    float t3 = t * t2;
-
-    XMVECTOR P0 = _mm_set_ps1((-t3 + 2.0f * t2 - t) * 0.5f);
-    XMVECTOR P1 = _mm_set_ps1((3.0f * t3 - 5.0f * t2 + 2.0f) * 0.5f);
-    XMVECTOR P2 = _mm_set_ps1((-3.0f * t3 + 4.0f * t2 + t) * 0.5f);
-    XMVECTOR P3 = _mm_set_ps1((t3 - t2) * 0.5f);
-
-    P1 = _mm_mul_ps(Position1, P1);
-    P0 = XM_FMADD_PS(Position0, P0, P1);
-    P3 = _mm_mul_ps(Position3, P3);
-    P2 = XM_FMADD_PS(Position2, P2, P3);
-    P0 = _mm_add_ps(P0, P2);
-    return P0;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorCatmullRomV
-        (
-                FXMVECTOR Position0,
-                FXMVECTOR Position1,
-                FXMVECTOR Position2,
-                GXMVECTOR Position3,
-                HXMVECTOR T
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float fx = T.vector4_f32[0];
-    float fy = T.vector4_f32[1];
-    float fz = T.vector4_f32[2];
-    float fw = T.vector4_f32[3];
-    XMVECTORF32 vResult = { { {
-            0.5f * ((-fx * fx * fx + 2 * fx * fx - fx) * Position0.vector4_f32[0]
-            + (3 * fx * fx * fx - 5 * fx * fx + 2) * Position1.vector4_f32[0]
-            + (-3 * fx * fx * fx + 4 * fx * fx + fx) * Position2.vector4_f32[0]
-            + (fx * fx * fx - fx * fx) * Position3.vector4_f32[0]),
-
-            0.5f * ((-fy * fy * fy + 2 * fy * fy - fy) * Position0.vector4_f32[1]
-            + (3 * fy * fy * fy - 5 * fy * fy + 2) * Position1.vector4_f32[1]
-            + (-3 * fy * fy * fy + 4 * fy * fy + fy) * Position2.vector4_f32[1]
-            + (fy * fy * fy - fy * fy) * Position3.vector4_f32[1]),
-
-            0.5f * ((-fz * fz * fz + 2 * fz * fz - fz) * Position0.vector4_f32[2]
-            + (3 * fz * fz * fz - 5 * fz * fz + 2) * Position1.vector4_f32[2]
-            + (-3 * fz * fz * fz + 4 * fz * fz + fz) * Position2.vector4_f32[2]
-            + (fz * fz * fz - fz * fz) * Position3.vector4_f32[2]),
-
-            0.5f * ((-fw * fw * fw + 2 * fw * fw - fw) * Position0.vector4_f32[3]
-            + (3 * fw * fw * fw - 5 * fw * fw + 2) * Position1.vector4_f32[3]
-            + (-3 * fw * fw * fw + 4 * fw * fw + fw) * Position2.vector4_f32[3]
-            + (fw * fw * fw - fw * fw) * Position3.vector4_f32[3])
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 Catmul2 = { { { 2.0f, 2.0f, 2.0f, 2.0f } } };
-    static const XMVECTORF32 Catmul3 = { { { 3.0f, 3.0f, 3.0f, 3.0f } } };
-    static const XMVECTORF32 Catmul4 = { { { 4.0f, 4.0f, 4.0f, 4.0f } } };
-    static const XMVECTORF32 Catmul5 = { { { 5.0f, 5.0f, 5.0f, 5.0f } } };
-    // Cache T^2 and T^3
-    XMVECTOR T2 = vmulq_f32(T, T);
-    XMVECTOR T3 = vmulq_f32(T, T2);
-    // Perform the Position0 term
-    XMVECTOR vResult = vaddq_f32(T2, T2);
-    vResult = vsubq_f32(vResult, T);
-    vResult = vsubq_f32(vResult, T3);
-    vResult = vmulq_f32(vResult, Position0);
-    // Perform the Position1 term and add
-    XMVECTOR vTemp = vmulq_f32(T3, Catmul3);
-    vTemp = vmlsq_f32(vTemp, T2, Catmul5);
-    vTemp = vaddq_f32(vTemp, Catmul2);
-    vResult = vmlaq_f32(vResult, vTemp, Position1);
-    // Perform the Position2 term and add
-    vTemp = vmulq_f32(T2, Catmul4);
-    vTemp = vmlsq_f32(vTemp, T3, Catmul3);
-    vTemp = vaddq_f32(vTemp, T);
-    vResult = vmlaq_f32(vResult, vTemp, Position2);
-    // Position3 is the last term
-    T3 = vsubq_f32(T3, T2);
-    vResult = vmlaq_f32(vResult, T3, Position3);
-    // Multiply by 0.5f and exit
-    vResult = vmulq_f32(vResult, g_XMOneHalf);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 Catmul2 = { { { 2.0f, 2.0f, 2.0f, 2.0f } } };
-    static const XMVECTORF32 Catmul3 = { { { 3.0f, 3.0f, 3.0f, 3.0f } } };
-    static const XMVECTORF32 Catmul4 = { { { 4.0f, 4.0f, 4.0f, 4.0f } } };
-    static const XMVECTORF32 Catmul5 = { { { 5.0f, 5.0f, 5.0f, 5.0f } } };
-    // Cache T^2 and T^3
-    XMVECTOR T2 = _mm_mul_ps(T, T);
-    XMVECTOR T3 = _mm_mul_ps(T, T2);
-    // Perform the Position0 term
-    XMVECTOR vResult = _mm_add_ps(T2, T2);
-    vResult = _mm_sub_ps(vResult, T);
-    vResult = _mm_sub_ps(vResult, T3);
-    vResult = _mm_mul_ps(vResult, Position0);
-    // Perform the Position1 term and add
-    XMVECTOR vTemp = _mm_mul_ps(T3, Catmul3);
-    vTemp = XM_FNMADD_PS(T2, Catmul5, vTemp);
-    vTemp = _mm_add_ps(vTemp, Catmul2);
-    vResult = XM_FMADD_PS(vTemp, Position1, vResult);
-    // Perform the Position2 term and add
-    vTemp = _mm_mul_ps(T2, Catmul4);
-    vTemp = XM_FNMADD_PS(T3, Catmul3, vTemp);
-    vTemp = _mm_add_ps(vTemp, T);
-    vResult = XM_FMADD_PS(vTemp, Position2, vResult);
-    // Position3 is the last term
-    T3 = _mm_sub_ps(T3, T2);
-    vResult = XM_FMADD_PS(T3, Position3, vResult);
-    // Multiply by 0.5f and exit
-    vResult = _mm_mul_ps(vResult, g_XMOneHalf);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorBaryCentric
-        (
-                FXMVECTOR Position0,
-                FXMVECTOR Position1,
-                FXMVECTOR Position2,
-                float    f,
-                float    g
-        ) noexcept
-{
-    // Result = Position0 + f * (Position1 - Position0) + g * (Position2 - Position0)
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR P10 = XMVectorSubtract(Position1, Position0);
-    XMVECTOR ScaleF = XMVectorReplicate(f);
-
-    XMVECTOR P20 = XMVectorSubtract(Position2, Position0);
-    XMVECTOR ScaleG = XMVectorReplicate(g);
-
-    XMVECTOR Result = XMVectorMultiplyAdd(P10, ScaleF, Position0);
-    Result = XMVectorMultiplyAdd(P20, ScaleG, Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR R1 = vsubq_f32(Position1, Position0);
-    XMVECTOR R2 = vsubq_f32(Position2, Position0);
-    R1 = vmlaq_n_f32(Position0, R1, f);
-    return vmlaq_n_f32(R1, R2, g);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR R1 = _mm_sub_ps(Position1, Position0);
-    XMVECTOR R2 = _mm_sub_ps(Position2, Position0);
-    XMVECTOR SF = _mm_set_ps1(f);
-    R1 = XM_FMADD_PS(R1, SF, Position0);
-    XMVECTOR SG = _mm_set_ps1(g);
-    return XM_FMADD_PS(R2, SG, R1);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVectorBaryCentricV
-        (
-                FXMVECTOR Position0,
-                FXMVECTOR Position1,
-                FXMVECTOR Position2,
-                GXMVECTOR F,
-                HXMVECTOR G
-        ) noexcept
-{
-    // Result = Position0 + f * (Position1 - Position0) + g * (Position2 - Position0)
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR P10 = XMVectorSubtract(Position1, Position0);
-    XMVECTOR P20 = XMVectorSubtract(Position2, Position0);
-
-    XMVECTOR Result = XMVectorMultiplyAdd(P10, F, Position0);
-    Result = XMVectorMultiplyAdd(P20, G, Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR R1 = vsubq_f32(Position1, Position0);
-    XMVECTOR R2 = vsubq_f32(Position2, Position0);
-    R1 = vmlaq_f32(Position0, R1, F);
-    return vmlaq_f32(R1, R2, G);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR R1 = _mm_sub_ps(Position1, Position0);
-    XMVECTOR R2 = _mm_sub_ps(Position2, Position0);
-    R1 = XM_FMADD_PS(R1, F, Position0);
-    return XM_FMADD_PS(R2, G, R1);
-#endif
-}
-
-/****************************************************************************
- *
- * 2D Vector
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-// Comparison operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2Equal
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] == V2.vector4_f32[0]) && (V1.vector4_f32[1] == V2.vector4_f32[1])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vceq_f32(vget_low_f32(V1), vget_low_f32(V2));
-    return (vget_lane_u64(vreinterpret_u64_u32(vTemp), 0) == 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpeq_ps(V1, V2);
-    // z and w are don't care
-    return (((_mm_movemask_ps(vTemp) & 3) == 3) != 0);
-#endif
-}
-
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector2EqualR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t CR = 0;
-    if ((V1.vector4_f32[0] == V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] == V2.vector4_f32[1]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_f32[0] != V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] != V2.vector4_f32[1]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vceq_f32(vget_low_f32(V1), vget_low_f32(V2));
-    uint64_t r = vget_lane_u64(vreinterpret_u64_u32(vTemp), 0);
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFFFFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpeq_ps(V1, V2);
-    // z and w are don't care
-    int iTest = _mm_movemask_ps(vTemp) & 3;
-    uint32_t CR = 0;
-    if (iTest == 3)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2EqualInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_u32[0] == V2.vector4_u32[0]) && (V1.vector4_u32[1] == V2.vector4_u32[1])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vceq_u32(vget_low_u32(vreinterpretq_u32_f32(V1)), vget_low_u32(vreinterpretq_u32_f32(V2)));
-    return (vget_lane_u64(vreinterpret_u64_u32(vTemp), 0) == 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return (((_mm_movemask_ps(_mm_castsi128_ps(vTemp)) & 3) == 3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector2EqualIntR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t CR = 0;
-    if ((V1.vector4_u32[0] == V2.vector4_u32[0]) &&
-        (V1.vector4_u32[1] == V2.vector4_u32[1]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_u32[0] != V2.vector4_u32[0]) &&
-        (V1.vector4_u32[1] != V2.vector4_u32[1]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vceq_u32(vget_low_u32(vreinterpretq_u32_f32(V1)), vget_low_u32(vreinterpretq_u32_f32(V2)));
-    uint64_t r = vget_lane_u64(vreinterpret_u64_u32(vTemp), 0);
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFFFFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    int iTest = _mm_movemask_ps(_mm_castsi128_ps(vTemp)) & 3;
-    uint32_t CR = 0;
-    if (iTest == 3)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2NearEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2,
-                FXMVECTOR Epsilon
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float dx = fabsf(V1.vector4_f32[0] - V2.vector4_f32[0]);
-    float dy = fabsf(V1.vector4_f32[1] - V2.vector4_f32[1]);
-    return ((dx <= Epsilon.vector4_f32[0]) &&
-        (dy <= Epsilon.vector4_f32[1]));
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t vDelta = vsub_f32(vget_low_f32(V1), vget_low_f32(V2));
-#if defined(_MSC_VER) && !defined(__clang__)
-    uint32x2_t vTemp = vacle_f32(vDelta, vget_low_u32(Epsilon));
-#else
-    uint32x2_t vTemp = vcle_f32(vabs_f32(vDelta), vget_low_f32(Epsilon));
-#endif
-    uint64_t r = vget_lane_u64(vreinterpret_u64_u32(vTemp), 0);
-    return (r == 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Get the difference
-    XMVECTOR vDelta = _mm_sub_ps(V1, V2);
-    // Get the absolute value of the difference
-    XMVECTOR vTemp = _mm_setzero_ps();
-    vTemp = _mm_sub_ps(vTemp, vDelta);
-    vTemp = _mm_max_ps(vTemp, vDelta);
-    vTemp = _mm_cmple_ps(vTemp, Epsilon);
-    // z and w are don't care
-    return (((_mm_movemask_ps(vTemp) & 3) == 0x3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2NotEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] != V2.vector4_f32[0]) || (V1.vector4_f32[1] != V2.vector4_f32[1])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vceq_f32(vget_low_f32(V1), vget_low_f32(V2));
-    return (vget_lane_u64(vreinterpret_u64_u32(vTemp), 0) != 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpeq_ps(V1, V2);
-    // z and w are don't care
-    return (((_mm_movemask_ps(vTemp) & 3) != 3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2NotEqualInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_u32[0] != V2.vector4_u32[0]) || (V1.vector4_u32[1] != V2.vector4_u32[1])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vceq_u32(vget_low_u32(vreinterpretq_u32_f32(V1)), vget_low_u32(vreinterpretq_u32_f32(V2)));
-    return (vget_lane_u64(vreinterpret_u64_u32(vTemp), 0) != 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return (((_mm_movemask_ps(_mm_castsi128_ps(vTemp)) & 3) != 3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2Greater
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] > V2.vector4_f32[0]) && (V1.vector4_f32[1] > V2.vector4_f32[1])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vcgt_f32(vget_low_f32(V1), vget_low_f32(V2));
-    return (vget_lane_u64(vreinterpret_u64_u32(vTemp), 0) == 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpgt_ps(V1, V2);
-    // z and w are don't care
-    return (((_mm_movemask_ps(vTemp) & 3) == 3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector2GreaterR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t CR = 0;
-    if ((V1.vector4_f32[0] > V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] > V2.vector4_f32[1]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_f32[0] <= V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] <= V2.vector4_f32[1]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vcgt_f32(vget_low_f32(V1), vget_low_f32(V2));
-    uint64_t r = vget_lane_u64(vreinterpret_u64_u32(vTemp), 0);
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFFFFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpgt_ps(V1, V2);
-    int iTest = _mm_movemask_ps(vTemp) & 3;
-    uint32_t CR = 0;
-    if (iTest == 3)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2GreaterOrEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] >= V2.vector4_f32[0]) && (V1.vector4_f32[1] >= V2.vector4_f32[1])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vcge_f32(vget_low_f32(V1), vget_low_f32(V2));
-    return (vget_lane_u64(vreinterpret_u64_u32(vTemp), 0) == 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpge_ps(V1, V2);
-    return (((_mm_movemask_ps(vTemp) & 3) == 3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector2GreaterOrEqualR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t CR = 0;
-    if ((V1.vector4_f32[0] >= V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] >= V2.vector4_f32[1]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_f32[0] < V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] < V2.vector4_f32[1]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vcge_f32(vget_low_f32(V1), vget_low_f32(V2));
-    uint64_t r = vget_lane_u64(vreinterpret_u64_u32(vTemp), 0);
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFFFFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpge_ps(V1, V2);
-    int iTest = _mm_movemask_ps(vTemp) & 3;
-    uint32_t CR = 0;
-    if (iTest == 3)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2Less
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] < V2.vector4_f32[0]) && (V1.vector4_f32[1] < V2.vector4_f32[1])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vclt_f32(vget_low_f32(V1), vget_low_f32(V2));
-    return (vget_lane_u64(vreinterpret_u64_u32(vTemp), 0) == 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmplt_ps(V1, V2);
-    return (((_mm_movemask_ps(vTemp) & 3) == 3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2LessOrEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] <= V2.vector4_f32[0]) && (V1.vector4_f32[1] <= V2.vector4_f32[1])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vTemp = vcle_f32(vget_low_f32(V1), vget_low_f32(V2));
-    return (vget_lane_u64(vreinterpret_u64_u32(vTemp), 0) == 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmple_ps(V1, V2);
-    return (((_mm_movemask_ps(vTemp) & 3) == 3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2InBounds
-        (
-                FXMVECTOR V,
-                FXMVECTOR Bounds
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) &&
-        (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    float32x2_t B = vget_low_f32(Bounds);
-    // Test if less than or equal
-    uint32x2_t ivTemp1 = vcle_f32(VL, B);
-    // Negate the bounds
-    float32x2_t vTemp2 = vneg_f32(B);
-    // Test if greater or equal (Reversed)
-    uint32x2_t ivTemp2 = vcle_f32(vTemp2, VL);
-    // Blend answers
-    ivTemp1 = vand_u32(ivTemp1, ivTemp2);
-    // x and y in bounds?
-    return (vget_lane_u64(vreinterpret_u64_u32(ivTemp1), 0) == 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Test if less than or equal
-    XMVECTOR vTemp1 = _mm_cmple_ps(V, Bounds);
-    // Negate the bounds
-    XMVECTOR vTemp2 = _mm_mul_ps(Bounds, g_XMNegativeOne);
-    // Test if greater or equal (Reversed)
-    vTemp2 = _mm_cmple_ps(vTemp2, V);
-    // Blend answers
-    vTemp1 = _mm_and_ps(vTemp1, vTemp2);
-    // x and y in bounds? (z and w are don't care)
-    return (((_mm_movemask_ps(vTemp1) & 0x3) == 0x3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(push)
-#pragma float_control(precise, on)
-#endif
-
-inline bool XM_CALLCONV XMVector2IsNaN(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (XMISNAN(V.vector4_f32[0]) ||
-        XMISNAN(V.vector4_f32[1]));
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    // Test against itself. NaN is always not equal
-    uint32x2_t vTempNan = vceq_f32(VL, VL);
-    // If x or y are NaN, the mask is zero
-    return (vget_lane_u64(vreinterpret_u64_u32(vTempNan), 0) != 0xFFFFFFFFFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Test against itself. NaN is always not equal
-    XMVECTOR vTempNan = _mm_cmpneq_ps(V, V);
-    // If x or y are NaN, the mask is non-zero
-    return ((_mm_movemask_ps(vTempNan) & 3) != 0);
-#endif
-}
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector2IsInfinite(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    return (XMISINF(V.vector4_f32[0]) ||
-        XMISINF(V.vector4_f32[1]));
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Mask off the sign bit
-    uint32x2_t vTemp = vand_u32(vget_low_u32(vreinterpretq_u32_f32(V)), vget_low_u32(g_XMAbsMask));
-    // Compare to infinity
-    vTemp = vceq_f32(vreinterpret_f32_u32(vTemp), vget_low_f32(g_XMInfinity));
-    // If any are infinity, the signs are true.
-    return vget_lane_u64(vreinterpret_u64_u32(vTemp), 0) != 0;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Mask off the sign bit
-    __m128 vTemp = _mm_and_ps(V, g_XMAbsMask);
-    // Compare to infinity
-    vTemp = _mm_cmpeq_ps(vTemp, g_XMInfinity);
-    // If x or z are infinity, the signs are true.
-    return ((_mm_movemask_ps(vTemp) & 3) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Computation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2Dot
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result;
-    Result.f[0] =
-        Result.f[1] =
-        Result.f[2] =
-        Result.f[3] = V1.vector4_f32[0] * V2.vector4_f32[0] + V1.vector4_f32[1] * V2.vector4_f32[1];
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Perform the dot product on x and y
-    float32x2_t vTemp = vmul_f32(vget_low_f32(V1), vget_low_f32(V2));
-    vTemp = vpadd_f32(vTemp, vTemp);
-    return vcombine_f32(vTemp, vTemp);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    return _mm_dp_ps(V1, V2, 0x3f);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vDot = _mm_mul_ps(V1, V2);
-    vDot = _mm_hadd_ps(vDot, vDot);
-    vDot = _mm_moveldup_ps(vDot);
-    return vDot;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x and y
-    XMVECTOR vLengthSq = _mm_mul_ps(V1, V2);
-    // vTemp has y splatted
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 1, 1, 1));
-    // x+y
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2Cross
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    // [ V1.x*V2.y - V1.y*V2.x, V1.x*V2.y - V1.y*V2.x ]
-
-#if defined(_XM_NO_INTRINSICS_)
-    float fCross = (V1.vector4_f32[0] * V2.vector4_f32[1]) - (V1.vector4_f32[1] * V2.vector4_f32[0]);
-    XMVECTORF32 vResult;
-    vResult.f[0] =
-        vResult.f[1] =
-        vResult.f[2] =
-        vResult.f[3] = fCross;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 Negate = { { { 1.f, -1.f, 0, 0 } } };
-
-    float32x2_t vTemp = vmul_f32(vget_low_f32(V1), vrev64_f32(vget_low_f32(V2)));
-    vTemp = vmul_f32(vTemp, vget_low_f32(Negate));
-    vTemp = vpadd_f32(vTemp, vTemp);
-    return vcombine_f32(vTemp, vTemp);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Swap x and y
-    XMVECTOR vResult = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 1, 0, 1));
-    // Perform the muls
-    vResult = _mm_mul_ps(vResult, V1);
-    // Splat y
-    XMVECTOR vTemp = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(1, 1, 1, 1));
-    // Sub the values
-    vResult = _mm_sub_ss(vResult, vTemp);
-    // Splat the cross product
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(0, 0, 0, 0));
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2LengthSq(FXMVECTOR V) noexcept
-{
-    return XMVector2Dot(V, V);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2ReciprocalLengthEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-    Result = XMVector2LengthSq(V);
-    Result = XMVectorReciprocalSqrtEst(Result);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    // Dot2
-    float32x2_t vTemp = vmul_f32(VL, VL);
-    vTemp = vpadd_f32(vTemp, vTemp);
-    // Reciprocal sqrt (estimate)
-    vTemp = vrsqrte_f32(vTemp);
-    return vcombine_f32(vTemp, vTemp);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x3f);
-    return _mm_rsqrt_ps(vTemp);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    XMVECTOR vTemp = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_rsqrt_ss(vTemp);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x and y
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has y splatted
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 1, 1, 1));
-    // x+y
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vLengthSq = _mm_rsqrt_ss(vLengthSq);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2ReciprocalLength(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-    Result = XMVector2LengthSq(V);
-    Result = XMVectorReciprocalSqrt(Result);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    // Dot2
-    float32x2_t vTemp = vmul_f32(VL, VL);
-    vTemp = vpadd_f32(vTemp, vTemp);
-    // Reciprocal sqrt
-    float32x2_t  S0 = vrsqrte_f32(vTemp);
-    float32x2_t  P0 = vmul_f32(vTemp, S0);
-    float32x2_t  R0 = vrsqrts_f32(P0, S0);
-    float32x2_t  S1 = vmul_f32(S0, R0);
-    float32x2_t  P1 = vmul_f32(vTemp, S1);
-    float32x2_t  R1 = vrsqrts_f32(P1, S1);
-    float32x2_t Result = vmul_f32(S1, R1);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x3f);
-    XMVECTOR vLengthSq = _mm_sqrt_ps(vTemp);
-    return _mm_div_ps(g_XMOne, vLengthSq);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    XMVECTOR vTemp = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_sqrt_ss(vTemp);
-    vLengthSq = _mm_div_ss(g_XMOne, vLengthSq);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x and y
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has y splatted
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 1, 1, 1));
-    // x+y
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vLengthSq = _mm_sqrt_ss(vLengthSq);
-    vLengthSq = _mm_div_ss(g_XMOne, vLengthSq);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2LengthEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-    Result = XMVector2LengthSq(V);
-    Result = XMVectorSqrtEst(Result);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    // Dot2
-    float32x2_t vTemp = vmul_f32(VL, VL);
-    vTemp = vpadd_f32(vTemp, vTemp);
-    const float32x2_t zero = vdup_n_f32(0);
-    uint32x2_t VEqualsZero = vceq_f32(vTemp, zero);
-    // Sqrt (estimate)
-    float32x2_t Result = vrsqrte_f32(vTemp);
-    Result = vmul_f32(vTemp, Result);
-    Result = vbsl_f32(VEqualsZero, zero, Result);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x3f);
-    return _mm_sqrt_ps(vTemp);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    XMVECTOR vTemp = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_sqrt_ss(vTemp);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x and y
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has y splatted
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 1, 1, 1));
-    // x+y
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vLengthSq = _mm_sqrt_ss(vLengthSq);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2Length(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-    Result = XMVector2LengthSq(V);
-    Result = XMVectorSqrt(Result);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    // Dot2
-    float32x2_t vTemp = vmul_f32(VL, VL);
-    vTemp = vpadd_f32(vTemp, vTemp);
-    const float32x2_t zero = vdup_n_f32(0);
-    uint32x2_t VEqualsZero = vceq_f32(vTemp, zero);
-    // Sqrt
-    float32x2_t S0 = vrsqrte_f32(vTemp);
-    float32x2_t P0 = vmul_f32(vTemp, S0);
-    float32x2_t R0 = vrsqrts_f32(P0, S0);
-    float32x2_t S1 = vmul_f32(S0, R0);
-    float32x2_t P1 = vmul_f32(vTemp, S1);
-    float32x2_t R1 = vrsqrts_f32(P1, S1);
-    float32x2_t Result = vmul_f32(S1, R1);
-    Result = vmul_f32(vTemp, Result);
-    Result = vbsl_f32(VEqualsZero, zero, Result);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x3f);
-    return _mm_sqrt_ps(vTemp);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    XMVECTOR vTemp = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_sqrt_ss(vTemp);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x and y
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has y splatted
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 1, 1, 1));
-    // x+y
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// XMVector2NormalizeEst uses a reciprocal estimate and
-// returns QNaN on zero and infinite vectors.
-
-inline XMVECTOR XM_CALLCONV XMVector2NormalizeEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-    Result = XMVector2ReciprocalLength(V);
-    Result = XMVectorMultiply(V, Result);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    // Dot2
-    float32x2_t vTemp = vmul_f32(VL, VL);
-    vTemp = vpadd_f32(vTemp, vTemp);
-    // Reciprocal sqrt (estimate)
-    vTemp = vrsqrte_f32(vTemp);
-    // Normalize
-    float32x2_t Result = vmul_f32(VL, vTemp);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x3f);
-    XMVECTOR vResult = _mm_rsqrt_ps(vTemp);
-    return _mm_mul_ps(vResult, V);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_rsqrt_ss(vLengthSq);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    vLengthSq = _mm_mul_ps(vLengthSq, V);
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x and y
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has y splatted
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 1, 1, 1));
-    // x+y
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vLengthSq = _mm_rsqrt_ss(vLengthSq);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    vLengthSq = _mm_mul_ps(vLengthSq, V);
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2Normalize(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR vResult = XMVector2Length(V);
-    float fLength = vResult.vector4_f32[0];
-
-    // Prevent divide by zero
-    if (fLength > 0)
-    {
-        fLength = 1.0f / fLength;
-    }
-
-    vResult.vector4_f32[0] = V.vector4_f32[0] * fLength;
-    vResult.vector4_f32[1] = V.vector4_f32[1] * fLength;
-    vResult.vector4_f32[2] = V.vector4_f32[2] * fLength;
-    vResult.vector4_f32[3] = V.vector4_f32[3] * fLength;
-    return vResult;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    // Dot2
-    float32x2_t vTemp = vmul_f32(VL, VL);
-    vTemp = vpadd_f32(vTemp, vTemp);
-    uint32x2_t VEqualsZero = vceq_f32(vTemp, vdup_n_f32(0));
-    uint32x2_t VEqualsInf = vceq_f32(vTemp, vget_low_f32(g_XMInfinity));
-    // Reciprocal sqrt (2 iterations of Newton-Raphson)
-    float32x2_t S0 = vrsqrte_f32(vTemp);
-    float32x2_t P0 = vmul_f32(vTemp, S0);
-    float32x2_t R0 = vrsqrts_f32(P0, S0);
-    float32x2_t S1 = vmul_f32(S0, R0);
-    float32x2_t P1 = vmul_f32(vTemp, S1);
-    float32x2_t R1 = vrsqrts_f32(P1, S1);
-    vTemp = vmul_f32(S1, R1);
-    // Normalize
-    float32x2_t Result = vmul_f32(VL, vTemp);
-    Result = vbsl_f32(VEqualsZero, vdup_n_f32(0), Result);
-    Result = vbsl_f32(VEqualsInf, vget_low_f32(g_XMQNaN), Result);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_dp_ps(V, V, 0x3f);
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Create zero with a single instruction
-    XMVECTOR vZeroMask = _mm_setzero_ps();
-    // Test for a divide by zero (Must be FP to detect -0.0)
-    vZeroMask = _mm_cmpneq_ps(vZeroMask, vResult);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Reciprocal mul to perform the normalization
-    vResult = _mm_div_ps(V, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vZeroMask);
-    // Select qnan or result based on infinite length
-    XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq, g_XMQNaN);
-    XMVECTOR vTemp2 = _mm_and_ps(vResult, vLengthSq);
-    vResult = _mm_or_ps(vTemp1, vTemp2);
-    return vResult;
-#elif defined(_XM_SSE3_INTRINSICS_)
-    // Perform the dot product on x and y only
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_moveldup_ps(vLengthSq);
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Create zero with a single instruction
-    XMVECTOR vZeroMask = _mm_setzero_ps();
-    // Test for a divide by zero (Must be FP to detect -0.0)
-    vZeroMask = _mm_cmpneq_ps(vZeroMask, vResult);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Reciprocal mul to perform the normalization
-    vResult = _mm_div_ps(V, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vZeroMask);
-    // Select qnan or result based on infinite length
-    XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq, g_XMQNaN);
-    XMVECTOR vTemp2 = _mm_and_ps(vResult, vLengthSq);
-    vResult = _mm_or_ps(vTemp1, vTemp2);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x and y only
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 1, 1, 1));
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Create zero with a single instruction
-    XMVECTOR vZeroMask = _mm_setzero_ps();
-    // Test for a divide by zero (Must be FP to detect -0.0)
-    vZeroMask = _mm_cmpneq_ps(vZeroMask, vResult);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Reciprocal mul to perform the normalization
-    vResult = _mm_div_ps(V, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vZeroMask);
-    // Select qnan or result based on infinite length
-    XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq, g_XMQNaN);
-    XMVECTOR vTemp2 = _mm_and_ps(vResult, vLengthSq);
-    vResult = _mm_or_ps(vTemp1, vTemp2);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2ClampLength
-        (
-                FXMVECTOR V,
-                float    LengthMin,
-                float    LengthMax
-        ) noexcept
-{
-    XMVECTOR ClampMax = XMVectorReplicate(LengthMax);
-    XMVECTOR ClampMin = XMVectorReplicate(LengthMin);
-    return XMVector2ClampLengthV(V, ClampMin, ClampMax);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2ClampLengthV
-        (
-                FXMVECTOR V,
-                FXMVECTOR LengthMin,
-                FXMVECTOR LengthMax
-        ) noexcept
-{
-    assert((XMVectorGetY(LengthMin) == XMVectorGetX(LengthMin)));
-    assert((XMVectorGetY(LengthMax) == XMVectorGetX(LengthMax)));
-    assert(XMVector2GreaterOrEqual(LengthMin, g_XMZero));
-    assert(XMVector2GreaterOrEqual(LengthMax, g_XMZero));
-    assert(XMVector2GreaterOrEqual(LengthMax, LengthMin));
-
-    XMVECTOR LengthSq = XMVector2LengthSq(V);
-
-    const XMVECTOR Zero = XMVectorZero();
-
-    XMVECTOR RcpLength = XMVectorReciprocalSqrt(LengthSq);
-
-    XMVECTOR InfiniteLength = XMVectorEqualInt(LengthSq, g_XMInfinity.v);
-    XMVECTOR ZeroLength = XMVectorEqual(LengthSq, Zero);
-
-    XMVECTOR Length = XMVectorMultiply(LengthSq, RcpLength);
-
-    XMVECTOR Normal = XMVectorMultiply(V, RcpLength);
-
-    XMVECTOR Select = XMVectorEqualInt(InfiniteLength, ZeroLength);
-    Length = XMVectorSelect(LengthSq, Length, Select);
-    Normal = XMVectorSelect(LengthSq, Normal, Select);
-
-    XMVECTOR ControlMax = XMVectorGreater(Length, LengthMax);
-    XMVECTOR ControlMin = XMVectorLess(Length, LengthMin);
-
-    XMVECTOR ClampLength = XMVectorSelect(Length, LengthMax, ControlMax);
-    ClampLength = XMVectorSelect(ClampLength, LengthMin, ControlMin);
-
-    XMVECTOR Result = XMVectorMultiply(Normal, ClampLength);
-
-    // Preserve the original vector (with no precision loss) if the length falls within the given range
-    XMVECTOR Control = XMVectorEqualInt(ControlMax, ControlMin);
-    Result = XMVectorSelect(Result, V, Control);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2Reflect
-        (
-                FXMVECTOR Incident,
-                FXMVECTOR Normal
-        ) noexcept
-{
-    // Result = Incident - (2 * dot(Incident, Normal)) * Normal
-
-    XMVECTOR Result;
-    Result = XMVector2Dot(Incident, Normal);
-    Result = XMVectorAdd(Result, Result);
-    Result = XMVectorNegativeMultiplySubtract(Result, Normal, Incident);
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2Refract
-        (
-                FXMVECTOR Incident,
-                FXMVECTOR Normal,
-                float    RefractionIndex
-        ) noexcept
-{
-    XMVECTOR Index = XMVectorReplicate(RefractionIndex);
-    return XMVector2RefractV(Incident, Normal, Index);
-}
-
-//------------------------------------------------------------------------------
-
-// Return the refraction of a 2D vector
-inline XMVECTOR XM_CALLCONV XMVector2RefractV
-        (
-                FXMVECTOR Incident,
-                FXMVECTOR Normal,
-                FXMVECTOR RefractionIndex
-        ) noexcept
-{
-    // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) +
-    // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal))))
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    float IDotN = (Incident.vector4_f32[0] * Normal.vector4_f32[0]) + (Incident.vector4_f32[1] * Normal.vector4_f32[1]);
-    // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN)
-    float RY = 1.0f - (IDotN * IDotN);
-    float RX = 1.0f - (RY * RefractionIndex.vector4_f32[0] * RefractionIndex.vector4_f32[0]);
-    RY = 1.0f - (RY * RefractionIndex.vector4_f32[1] * RefractionIndex.vector4_f32[1]);
-    if (RX >= 0.0f)
-    {
-        RX = (RefractionIndex.vector4_f32[0] * Incident.vector4_f32[0]) - (Normal.vector4_f32[0] * ((RefractionIndex.vector4_f32[0] * IDotN) + sqrtf(RX)));
-    }
-    else
-    {
-        RX = 0.0f;
-    }
-    if (RY >= 0.0f)
-    {
-        RY = (RefractionIndex.vector4_f32[1] * Incident.vector4_f32[1]) - (Normal.vector4_f32[1] * ((RefractionIndex.vector4_f32[1] * IDotN) + sqrtf(RY)));
-    }
-    else
-    {
-        RY = 0.0f;
-    }
-
-    XMVECTOR vResult;
-    vResult.vector4_f32[0] = RX;
-    vResult.vector4_f32[1] = RY;
-    vResult.vector4_f32[2] = 0.0f;
-    vResult.vector4_f32[3] = 0.0f;
-    return vResult;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t IL = vget_low_f32(Incident);
-    float32x2_t NL = vget_low_f32(Normal);
-    float32x2_t RIL = vget_low_f32(RefractionIndex);
-    // Get the 2D Dot product of Incident-Normal
-    float32x2_t vTemp = vmul_f32(IL, NL);
-    float32x2_t IDotN = vpadd_f32(vTemp, vTemp);
-    // vTemp = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN)
-    vTemp = vmls_f32(vget_low_f32(g_XMOne), IDotN, IDotN);
-    vTemp = vmul_f32(vTemp, RIL);
-    vTemp = vmls_f32(vget_low_f32(g_XMOne), vTemp, RIL);
-    // If any terms are <=0, sqrt() will fail, punt to zero
-    uint32x2_t vMask = vcgt_f32(vTemp, vget_low_f32(g_XMZero));
-    // Sqrt(vTemp)
-    float32x2_t S0 = vrsqrte_f32(vTemp);
-    float32x2_t P0 = vmul_f32(vTemp, S0);
-    float32x2_t R0 = vrsqrts_f32(P0, S0);
-    float32x2_t S1 = vmul_f32(S0, R0);
-    float32x2_t P1 = vmul_f32(vTemp, S1);
-    float32x2_t R1 = vrsqrts_f32(P1, S1);
-    float32x2_t S2 = vmul_f32(S1, R1);
-    vTemp = vmul_f32(vTemp, S2);
-    // R = RefractionIndex * IDotN + sqrt(R)
-    vTemp = vmla_f32(vTemp, RIL, IDotN);
-    // Result = RefractionIndex * Incident - Normal * R
-    float32x2_t vResult = vmul_f32(RIL, IL);
-    vResult = vmls_f32(vResult, vTemp, NL);
-    vResult = vreinterpret_f32_u32(vand_u32(vreinterpret_u32_f32(vResult), vMask));
-    return vcombine_f32(vResult, vResult);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) +
-    // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal))))
-    // Get the 2D Dot product of Incident-Normal
-    XMVECTOR IDotN = XMVector2Dot(Incident, Normal);
-    // vTemp = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN)
-    XMVECTOR vTemp = XM_FNMADD_PS(IDotN, IDotN, g_XMOne);
-    vTemp = _mm_mul_ps(vTemp, RefractionIndex);
-    vTemp = XM_FNMADD_PS(vTemp, RefractionIndex, g_XMOne);
-    // If any terms are <=0, sqrt() will fail, punt to zero
-    XMVECTOR vMask = _mm_cmpgt_ps(vTemp, g_XMZero);
-    // R = RefractionIndex * IDotN + sqrt(R)
-    vTemp = _mm_sqrt_ps(vTemp);
-    vTemp = XM_FMADD_PS(RefractionIndex, IDotN, vTemp);
-    // Result = RefractionIndex * Incident - Normal * R
-    XMVECTOR vResult = _mm_mul_ps(RefractionIndex, Incident);
-    vResult = XM_FNMADD_PS(vTemp, Normal, vResult);
-    vResult = _mm_and_ps(vResult, vMask);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2Orthogonal(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            -V.vector4_f32[1],
-            V.vector4_f32[0],
-            0.f,
-            0.f
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 Negate = { { { -1.f, 1.f, 0, 0 } } };
-    const float32x2_t zero = vdup_n_f32(0);
-
-    float32x2_t VL = vget_low_f32(V);
-    float32x2_t Result = vmul_f32(vrev64_f32(VL), vget_low_f32(Negate));
-    return vcombine_f32(Result, zero);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 2, 0, 1));
-    vResult = _mm_mul_ps(vResult, g_XMNegateX);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2AngleBetweenNormalsEst
-        (
-                FXMVECTOR N1,
-                FXMVECTOR N2
-        ) noexcept
-{
-    XMVECTOR Result = XMVector2Dot(N1, N2);
-    Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v);
-    Result = XMVectorACosEst(Result);
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2AngleBetweenNormals
-        (
-                FXMVECTOR N1,
-                FXMVECTOR N2
-        ) noexcept
-{
-    XMVECTOR Result = XMVector2Dot(N1, N2);
-    Result = XMVectorClamp(Result, g_XMNegativeOne, g_XMOne);
-    Result = XMVectorACos(Result);
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2AngleBetweenVectors
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    XMVECTOR L1 = XMVector2ReciprocalLength(V1);
-    XMVECTOR L2 = XMVector2ReciprocalLength(V2);
-
-    XMVECTOR Dot = XMVector2Dot(V1, V2);
-
-    L1 = XMVectorMultiply(L1, L2);
-
-    XMVECTOR CosAngle = XMVectorMultiply(Dot, L1);
-    CosAngle = XMVectorClamp(CosAngle, g_XMNegativeOne.v, g_XMOne.v);
-
-    return XMVectorACos(CosAngle);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2LinePointDistance
-        (
-                FXMVECTOR LinePoint1,
-                FXMVECTOR LinePoint2,
-                FXMVECTOR Point
-        ) noexcept
-{
-    // Given a vector PointVector from LinePoint1 to Point and a vector
-    // LineVector from LinePoint1 to LinePoint2, the scaled distance
-    // PointProjectionScale from LinePoint1 to the perpendicular projection
-    // of PointVector onto the line is defined as:
-    //
-    //     PointProjectionScale = dot(PointVector, LineVector) / LengthSq(LineVector)
-
-    XMVECTOR PointVector = XMVectorSubtract(Point, LinePoint1);
-    XMVECTOR LineVector = XMVectorSubtract(LinePoint2, LinePoint1);
-
-    XMVECTOR LengthSq = XMVector2LengthSq(LineVector);
-
-    XMVECTOR PointProjectionScale = XMVector2Dot(PointVector, LineVector);
-    PointProjectionScale = XMVectorDivide(PointProjectionScale, LengthSq);
-
-    XMVECTOR DistanceVector = XMVectorMultiply(LineVector, PointProjectionScale);
-    DistanceVector = XMVectorSubtract(PointVector, DistanceVector);
-
-    return XMVector2Length(DistanceVector);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2IntersectLine
-        (
-                FXMVECTOR Line1Point1,
-                FXMVECTOR Line1Point2,
-                FXMVECTOR Line2Point1,
-                GXMVECTOR Line2Point2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
-
-    XMVECTOR V1 = XMVectorSubtract(Line1Point2, Line1Point1);
-    XMVECTOR V2 = XMVectorSubtract(Line2Point2, Line2Point1);
-    XMVECTOR V3 = XMVectorSubtract(Line1Point1, Line2Point1);
-
-    XMVECTOR C1 = XMVector2Cross(V1, V2);
-    XMVECTOR C2 = XMVector2Cross(V2, V3);
-
-    XMVECTOR Result;
-    const XMVECTOR Zero = XMVectorZero();
-    if (XMVector2NearEqual(C1, Zero, g_XMEpsilon.v))
-    {
-        if (XMVector2NearEqual(C2, Zero, g_XMEpsilon.v))
-        {
-            // Coincident
-            Result = g_XMInfinity.v;
-        }
-        else
-        {
-            // Parallel
-            Result = g_XMQNaN.v;
-        }
-    }
-    else
-    {
-        // Intersection point = Line1Point1 + V1 * (C2 / C1)
-        XMVECTOR Scale = XMVectorReciprocal(C1);
-        Scale = XMVectorMultiply(C2, Scale);
-        Result = XMVectorMultiplyAdd(V1, Scale, Line1Point1);
-    }
-
-    return Result;
-
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR V1 = _mm_sub_ps(Line1Point2, Line1Point1);
-    XMVECTOR V2 = _mm_sub_ps(Line2Point2, Line2Point1);
-    XMVECTOR V3 = _mm_sub_ps(Line1Point1, Line2Point1);
-    // Generate the cross products
-    XMVECTOR C1 = XMVector2Cross(V1, V2);
-    XMVECTOR C2 = XMVector2Cross(V2, V3);
-    // If C1 is not close to epsilon, use the calculated value
-    XMVECTOR vResultMask = _mm_setzero_ps();
-    vResultMask = _mm_sub_ps(vResultMask, C1);
-    vResultMask = _mm_max_ps(vResultMask, C1);
-    // 0xFFFFFFFF if the calculated value is to be used
-    vResultMask = _mm_cmpgt_ps(vResultMask, g_XMEpsilon);
-    // If C1 is close to epsilon, which fail type is it? INFINITY or NAN?
-    XMVECTOR vFailMask = _mm_setzero_ps();
-    vFailMask = _mm_sub_ps(vFailMask, C2);
-    vFailMask = _mm_max_ps(vFailMask, C2);
-    vFailMask = _mm_cmple_ps(vFailMask, g_XMEpsilon);
-    XMVECTOR vFail = _mm_and_ps(vFailMask, g_XMInfinity);
-    vFailMask = _mm_andnot_ps(vFailMask, g_XMQNaN);
-    // vFail is NAN or INF
-    vFail = _mm_or_ps(vFail, vFailMask);
-    // Intersection point = Line1Point1 + V1 * (C2 / C1)
-    XMVECTOR vResult = _mm_div_ps(C2, C1);
-    vResult = XM_FMADD_PS(vResult, V1, Line1Point1);
-    // Use result, or failure value
-    vResult = _mm_and_ps(vResult, vResultMask);
-    vResultMask = _mm_andnot_ps(vResultMask, vFail);
-    vResult = _mm_or_ps(vResult, vResultMask);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2Transform
-        (
-                FXMVECTOR V,
-                FXMMATRIX M
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Y = XMVectorSplatY(V);
-    XMVECTOR X = XMVectorSplatX(V);
-
-    XMVECTOR Result = XMVectorMultiplyAdd(Y, M.r[1], M.r[3]);
-    Result = XMVectorMultiplyAdd(X, M.r[0], Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    float32x4_t Result = vmlaq_lane_f32(M.r[3], M.r[1], VL, 1); // Y
-    return vmlaq_lane_f32(Result, M.r[0], VL, 0); // X
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1)); // Y
-    vResult = XM_FMADD_PS(vResult, M.r[1], M.r[3]);
-    XMVECTOR vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0)); // X
-    vResult = XM_FMADD_PS(vTemp, M.r[0], vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline XMFLOAT4* XM_CALLCONV XMVector2TransformStream
-        (
-                XMFLOAT4* pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT2* pInputStream,
-                size_t          InputStride,
-                size_t          VectorCount,
-                FXMMATRIX       M
-        ) noexcept
-{
-    assert(pOutputStream != nullptr);
-    assert(pInputStream != nullptr);
-
-    assert(InputStride >= sizeof(XMFLOAT2));
-    _Analysis_assume_(InputStride >= sizeof(XMFLOAT2));
-
-    assert(OutputStride >= sizeof(XMFLOAT4));
-    _Analysis_assume_(OutputStride >= sizeof(XMFLOAT4));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row3 = M.r[3];
-
-    for (size_t i = 0; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pInputVector));
-        XMVECTOR Y = XMVectorSplatY(V);
-        XMVECTOR X = XMVectorSplatX(V);
-
-        XMVECTOR Result = XMVectorMultiplyAdd(Y, row1, row3);
-        Result = XMVectorMultiplyAdd(X, row0, Result);
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015, "PREfast noise: Esp:1307" )
-#endif
-
-        XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(pOutputVector), Result);
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-        pInputVector += InputStride;
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row3 = M.r[3];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if ((InputStride == sizeof(XMFLOAT2)) && (OutputStride == sizeof(XMFLOAT4)))
-        {
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4x2_t V = vld2q_f32(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += sizeof(XMFLOAT2) * 4;
-
-                float32x2_t r3 = vget_low_f32(row3);
-                float32x2_t r = vget_low_f32(row0);
-                XMVECTOR vResult0 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), V.val[0], r, 0); // Ax+M
-                XMVECTOR vResult1 = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Bx+N
-
-                XM_PREFETCH(pInputVector);
-
-                r3 = vget_high_f32(row3);
-                r = vget_high_f32(row0);
-                XMVECTOR vResult2 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), V.val[0], r, 0); // Cx+O
-                XMVECTOR vResult3 = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Dx+P
-
-                XM_PREFETCH(pInputVector + XM_CACHE_LINE_SIZE);
-
-                r = vget_low_f32(row1);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[1], r, 0); // Ax+Ey+M
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[1], r, 1); // Bx+Fy+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 2));
-
-                r = vget_high_f32(row1);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[1], r, 0); // Cx+Gy+O
-                vResult3 = vmlaq_lane_f32(vResult3, V.val[1], r, 1); // Dx+Hy+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 3));
-
-                float32x4x4_t R;
-                R.val[0] = vResult0;
-                R.val[1] = vResult1;
-                R.val[2] = vResult2;
-                R.val[3] = vResult3;
-
-                vst4q_f32(reinterpret_cast<float*>(pOutputVector), R);
-                pOutputVector += sizeof(XMFLOAT4) * 4;
-
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        float32x2_t V = vld1_f32(reinterpret_cast<const float*>(pInputVector));
-        pInputVector += InputStride;
-
-        XMVECTOR vResult = vmlaq_lane_f32(row3, row0, V, 0); // X
-        vResult = vmlaq_lane_f32(vResult, row1, V, 1); // Y
-
-        vst1q_f32(reinterpret_cast<float*>(pOutputVector), vResult);
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-#elif defined(_XM_AVX2_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        __m256 row0 = _mm256_broadcast_ps(&M.r[0]);
-        __m256 row1 = _mm256_broadcast_ps(&M.r[1]);
-        __m256 row3 = _mm256_broadcast_ps(&M.r[3]);
-
-        if (InputStride == sizeof(XMFLOAT2))
-        {
-            if (OutputStride == sizeof(XMFLOAT4))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0x1F))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 4;
-
-                        __m256 Y2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-                        __m256 X2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                        __m256 Y1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                        __m256 X1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        __m256 vTempB = _mm256_fmadd_ps(Y1, row1, row3);
-                        __m256 vTempB2 = _mm256_fmadd_ps(Y2, row1, row3);
-                        __m256 vTempA = _mm256_mul_ps(X1, row0);
-                        __m256 vTempA2 = _mm256_mul_ps(X2, row0);
-                        vTempA = _mm256_add_ps(vTempA, vTempB);
-                        vTempA2 = _mm256_add_ps(vTempA2, vTempB2);
-
-                        X1 = _mm256_insertf128_ps(vTempA, _mm256_castps256_ps128(vTempA2), 1);
-                        XM256_STREAM_PS(reinterpret_cast<float*>(pOutputVector), X1);
-                        pOutputVector += sizeof(XMFLOAT4) * 2;
-
-                        X2 = _mm256_insertf128_ps(vTempA2, _mm256_extractf128_ps(vTempA, 1), 0);
-                        XM256_STREAM_PS(reinterpret_cast<float*>(pOutputVector), X2);
-                        pOutputVector += sizeof(XMFLOAT4) * 2;
-
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 4;
-
-                        __m256 Y2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-                        __m256 X2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                        __m256 Y1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                        __m256 X1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        __m256 vTempB = _mm256_fmadd_ps(Y1, row1, row3);
-                        __m256 vTempB2 = _mm256_fmadd_ps(Y2, row1, row3);
-                        __m256 vTempA = _mm256_mul_ps(X1, row0);
-                        __m256 vTempA2 = _mm256_mul_ps(X2, row0);
-                        vTempA = _mm256_add_ps(vTempA, vTempB);
-                        vTempA2 = _mm256_add_ps(vTempA2, vTempB2);
-
-                        X1 = _mm256_insertf128_ps(vTempA, _mm256_castps256_ps128(vTempA2), 1);
-                        _mm256_storeu_ps(reinterpret_cast<float*>(pOutputVector), X1);
-                        pOutputVector += sizeof(XMFLOAT4) * 2;
-
-                        X2 = _mm256_insertf128_ps(vTempA2, _mm256_extractf128_ps(vTempA, 1), 0);
-                        _mm256_storeu_ps(reinterpret_cast<float*>(pOutputVector), X2);
-                        pOutputVector += sizeof(XMFLOAT4) * 2;
-
-                        i += 4;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    pInputVector += sizeof(XMFLOAT2) * 4;
-
-                    __m256 Y2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-                    __m256 X2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                    __m256 Y1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                    __m256 X1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    __m256 vTempB = _mm256_fmadd_ps(Y1, row1, row3);
-                    __m256 vTempB2 = _mm256_fmadd_ps(Y2, row1, row3);
-                    __m256 vTempA = _mm256_mul_ps(X1, row0);
-                    __m256 vTempA2 = _mm256_mul_ps(X2, row0);
-                    vTempA = _mm256_add_ps(vTempA, vTempB);
-                    vTempA2 = _mm256_add_ps(vTempA2, vTempB2);
-
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), _mm256_castps256_ps128(vTempA));
-                    pOutputVector += OutputStride;
-
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), _mm256_castps256_ps128(vTempA2));
-                    pOutputVector += OutputStride;
-
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), _mm256_extractf128_ps(vTempA, 1));
-                    pOutputVector += OutputStride;
-
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), _mm256_extractf128_ps(vTempA2, 1));
-                    pOutputVector += OutputStride;
-
-                    i += 4;
-                }
-            }
-        }
-    }
-
-    if (i < VectorCount)
-    {
-        const XMVECTOR row0 = M.r[0];
-        const XMVECTOR row1 = M.r[1];
-        const XMVECTOR row3 = M.r[3];
-
-        for (; i < VectorCount; i++)
-        {
-            __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pInputVector)));
-            pInputVector += InputStride;
-
-            XMVECTOR Y = XM_PERMUTE_PS(xy, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(xy, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-            XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-            vTemp = _mm_add_ps(vTemp, vTemp2);
-
-            _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-            pOutputVector += OutputStride;
-        }
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#elif defined(_XM_SSE_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row3 = M.r[3];
-
-    size_t i = 0;
-    size_t two = VectorCount >> 1;
-    if (two > 0)
-    {
-        if (InputStride == sizeof(XMFLOAT2))
-        {
-            if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF))
-            {
-                // Packed input, aligned output
-                for (size_t j = 0; j < two; ++j)
-                {
-                    XMVECTOR V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    pInputVector += sizeof(XMFLOAT2) * 2;
-
-                    XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-                    XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                    XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-                    X = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-
-                    vTemp = XM_FMADD_PS(Y, row1, row3);
-                    vTemp2 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                    XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    i += 2;
-                }
-            }
-            else
-            {
-                // Packed input, unaligned output
-                for (size_t j = 0; j < two; ++j)
-                {
-                    XMVECTOR V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    pInputVector += sizeof(XMFLOAT2) * 2;
-
-                    XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-                    XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-                    X = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-
-                    vTemp = XM_FMADD_PS(Y, row1, row3);
-                    vTemp2 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    i += 2;
-                }
-            }
-        }
-    }
-
-    if (!(reinterpret_cast<uintptr_t>(pInputVector) & 0xF) && !(InputStride & 0xF))
-    {
-        if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF))
-        {
-            // Aligned input, aligned output
-            for (; i < VectorCount; i++)
-            {
-                XMVECTOR V = _mm_castsi128_ps(_mm_loadl_epi64(reinterpret_cast<const __m128i*>(pInputVector)));
-                pInputVector += InputStride;
-
-                XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-                XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-                vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-                pOutputVector += OutputStride;
-            }
-        }
-        else
-        {
-            // Aligned input, unaligned output
-            for (; i < VectorCount; i++)
-            {
-                XMVECTOR V = _mm_castsi128_ps(_mm_loadl_epi64(reinterpret_cast<const __m128i*>(pInputVector)));
-                pInputVector += InputStride;
-
-                XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-                XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-                vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-                pOutputVector += OutputStride;
-            }
-        }
-    }
-    else
-    {
-        // Unaligned input
-        for (; i < VectorCount; i++)
-        {
-            __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pInputVector)));
-            pInputVector += InputStride;
-
-            XMVECTOR Y = XM_PERMUTE_PS(xy, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(xy, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-            XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-            vTemp = _mm_add_ps(vTemp, vTemp2);
-
-            _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-            pOutputVector += OutputStride;
-        }
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2TransformCoord
-        (
-                FXMVECTOR V,
-                FXMMATRIX M
-        ) noexcept
-{
-    XMVECTOR Y = XMVectorSplatY(V);
-    XMVECTOR X = XMVectorSplatX(V);
-
-    XMVECTOR Result = XMVectorMultiplyAdd(Y, M.r[1], M.r[3]);
-    Result = XMVectorMultiplyAdd(X, M.r[0], Result);
-
-    XMVECTOR W = XMVectorSplatW(Result);
-    return XMVectorDivide(Result, W);
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline XMFLOAT2* XM_CALLCONV XMVector2TransformCoordStream
-        (
-                XMFLOAT2* pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT2* pInputStream,
-                size_t          InputStride,
-                size_t          VectorCount,
-                FXMMATRIX       M
-        ) noexcept
-{
-    assert(pOutputStream != nullptr);
-    assert(pInputStream != nullptr);
-
-    assert(InputStride >= sizeof(XMFLOAT2));
-    _Analysis_assume_(InputStride >= sizeof(XMFLOAT2));
-
-    assert(OutputStride >= sizeof(XMFLOAT2));
-    _Analysis_assume_(OutputStride >= sizeof(XMFLOAT2));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row3 = M.r[3];
-
-    for (size_t i = 0; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pInputVector));
-        XMVECTOR Y = XMVectorSplatY(V);
-        XMVECTOR X = XMVectorSplatX(V);
-
-        XMVECTOR Result = XMVectorMultiplyAdd(Y, row1, row3);
-        Result = XMVectorMultiplyAdd(X, row0, Result);
-
-        XMVECTOR W = XMVectorSplatW(Result);
-
-        Result = XMVectorDivide(Result, W);
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015, "PREfast noise: Esp:1307" )
-#endif
-
-        XMStoreFloat2(reinterpret_cast<XMFLOAT2*>(pOutputVector), Result);
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-        pInputVector += InputStride;
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row3 = M.r[3];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if ((InputStride == sizeof(XMFLOAT2)) && (OutputStride == sizeof(XMFLOAT2)))
-        {
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4x2_t V = vld2q_f32(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += sizeof(XMFLOAT2) * 4;
-
-                float32x2_t r3 = vget_low_f32(row3);
-                float32x2_t r = vget_low_f32(row0);
-                XMVECTOR vResult0 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), V.val[0], r, 0); // Ax+M
-                XMVECTOR vResult1 = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Bx+N
-
-                XM_PREFETCH(pInputVector);
-
-                r3 = vget_high_f32(row3);
-                r = vget_high_f32(row0);
-                XMVECTOR W = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Dx+P
-
-                XM_PREFETCH(pInputVector + XM_CACHE_LINE_SIZE);
-
-                r = vget_low_f32(row1);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[1], r, 0); // Ax+Ey+M
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[1], r, 1); // Bx+Fy+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 2));
-
-                r = vget_high_f32(row1);
-                W = vmlaq_lane_f32(W, V.val[1], r, 1); // Dx+Hy+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 3));
-
-#if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-                V.val[0] = vdivq_f32(vResult0, W);
-                V.val[1] = vdivq_f32(vResult1, W);
-#else
-                // 2 iterations of Newton-Raphson refinement of reciprocal
-                float32x4_t Reciprocal = vrecpeq_f32(W);
-                float32x4_t S = vrecpsq_f32(Reciprocal, W);
-                Reciprocal = vmulq_f32(S, Reciprocal);
-                S = vrecpsq_f32(Reciprocal, W);
-                Reciprocal = vmulq_f32(S, Reciprocal);
-
-                V.val[0] = vmulq_f32(vResult0, Reciprocal);
-                V.val[1] = vmulq_f32(vResult1, Reciprocal);
-#endif
-
-                vst2q_f32(reinterpret_cast<float*>(pOutputVector), V);
-                pOutputVector += sizeof(XMFLOAT2) * 4;
-
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        float32x2_t V = vld1_f32(reinterpret_cast<const float*>(pInputVector));
-        pInputVector += InputStride;
-
-        XMVECTOR vResult = vmlaq_lane_f32(row3, row0, V, 0); // X
-        vResult = vmlaq_lane_f32(vResult, row1, V, 1); // Y
-
-        V = vget_high_f32(vResult);
-        float32x2_t W = vdup_lane_f32(V, 1);
-
-#if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-        V = vget_low_f32(vResult);
-        V = vdiv_f32(V, W);
-#else
-        // 2 iterations of Newton-Raphson refinement of reciprocal for W
-        float32x2_t Reciprocal = vrecpe_f32(W);
-        float32x2_t S = vrecps_f32(Reciprocal, W);
-        Reciprocal = vmul_f32(S, Reciprocal);
-        S = vrecps_f32(Reciprocal, W);
-        Reciprocal = vmul_f32(S, Reciprocal);
-
-        V = vget_low_f32(vResult);
-        V = vmul_f32(V, Reciprocal);
-#endif
-
-        vst1_f32(reinterpret_cast<float*>(pOutputVector), V);
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-#elif defined(_XM_AVX2_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        __m256 row0 = _mm256_broadcast_ps(&M.r[0]);
-        __m256 row1 = _mm256_broadcast_ps(&M.r[1]);
-        __m256 row3 = _mm256_broadcast_ps(&M.r[3]);
-
-        if (InputStride == sizeof(XMFLOAT2))
-        {
-            if (OutputStride == sizeof(XMFLOAT2))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0x1F))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 4;
-
-                        __m256 Y2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-                        __m256 X2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                        __m256 Y1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                        __m256 X1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        __m256 vTempB = _mm256_fmadd_ps(Y1, row1, row3);
-                        __m256 vTempB2 = _mm256_fmadd_ps(Y2, row1, row3);
-                        __m256 vTempA = _mm256_mul_ps(X1, row0);
-                        __m256 vTempA2 = _mm256_mul_ps(X2, row0);
-                        vTempA = _mm256_add_ps(vTempA, vTempB);
-                        vTempA2 = _mm256_add_ps(vTempA2, vTempB2);
-
-                        __m256 W = _mm256_shuffle_ps(vTempA, vTempA, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTempA = _mm256_div_ps(vTempA, W);
-
-                        W = _mm256_shuffle_ps(vTempA2, vTempA2, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTempA2 = _mm256_div_ps(vTempA2, W);
-
-                        X1 = _mm256_shuffle_ps(vTempA, vTempA2, 0x44);
-                        XM256_STREAM_PS(reinterpret_cast<float*>(pOutputVector), X1);
-                        pOutputVector += sizeof(XMFLOAT2) * 4;
-
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 4;
-
-                        __m256 Y2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-                        __m256 X2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                        __m256 Y1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                        __m256 X1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        __m256 vTempB = _mm256_fmadd_ps(Y1, row1, row3);
-                        __m256 vTempB2 = _mm256_fmadd_ps(Y2, row1, row3);
-                        __m256 vTempA = _mm256_mul_ps(X1, row0);
-                        __m256 vTempA2 = _mm256_mul_ps(X2, row0);
-                        vTempA = _mm256_add_ps(vTempA, vTempB);
-                        vTempA2 = _mm256_add_ps(vTempA2, vTempB2);
-
-                        __m256 W = _mm256_shuffle_ps(vTempA, vTempA, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTempA = _mm256_div_ps(vTempA, W);
-
-                        W = _mm256_shuffle_ps(vTempA2, vTempA2, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTempA2 = _mm256_div_ps(vTempA2, W);
-
-                        X1 = _mm256_shuffle_ps(vTempA, vTempA2, 0x44);
-                        _mm256_storeu_ps(reinterpret_cast<float*>(pOutputVector), X1);
-                        pOutputVector += sizeof(XMFLOAT2) * 4;
-
-                        i += 4;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    pInputVector += sizeof(XMFLOAT2) * 4;
-
-                    __m256 Y2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-                    __m256 X2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                    __m256 Y1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                    __m256 X1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    __m256 vTempB = _mm256_fmadd_ps(Y1, row1, row3);
-                    __m256 vTempB2 = _mm256_fmadd_ps(Y2, row1, row3);
-                    __m256 vTempA = _mm256_mul_ps(X1, row0);
-                    __m256 vTempA2 = _mm256_mul_ps(X2, row0);
-                    vTempA = _mm256_add_ps(vTempA, vTempB);
-                    vTempA2 = _mm256_add_ps(vTempA2, vTempB2);
-
-                    __m256 W = _mm256_shuffle_ps(vTempA, vTempA, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTempA = _mm256_div_ps(vTempA, W);
-
-                    W = _mm256_shuffle_ps(vTempA2, vTempA2, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTempA2 = _mm256_div_ps(vTempA2, W);
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector),
-                        _mm_castps_pd(_mm256_castps256_ps128(vTempA)));
-                    pOutputVector += OutputStride;
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector),
-                        _mm_castps_pd(_mm256_castps256_ps128(vTempA2)));
-                    pOutputVector += OutputStride;
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector),
-                        _mm_castps_pd(_mm256_extractf128_ps(vTempA, 1)));
-                    pOutputVector += OutputStride;
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector),
-                        _mm_castps_pd(_mm256_extractf128_ps(vTempA2, 1)));
-                    pOutputVector += OutputStride;
-
-                    i += 4;
-                }
-            }
-        }
-    }
-
-    if (i < VectorCount)
-    {
-        const XMVECTOR row0 = M.r[0];
-        const XMVECTOR row1 = M.r[1];
-        const XMVECTOR row3 = M.r[3];
-
-        for (; i < VectorCount; i++)
-        {
-            __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pInputVector)));
-            pInputVector += InputStride;
-
-            XMVECTOR Y = XM_PERMUTE_PS(xy, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(xy, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-            XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-            vTemp = _mm_add_ps(vTemp, vTemp2);
-
-            XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-            vTemp = _mm_div_ps(vTemp, W);
-
-            _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-            pOutputVector += OutputStride;
-        }
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#elif defined(_XM_SSE_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row3 = M.r[3];
-
-    size_t i = 0;
-    size_t two = VectorCount >> 1;
-    if (two > 0)
-    {
-        if (InputStride == sizeof(XMFLOAT2))
-        {
-            if (OutputStride == sizeof(XMFLOAT2))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < two; ++j)
-                    {
-                        XMVECTOR V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 2;
-
-                        // Result 1
-                        XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-                        XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        XMVECTOR V1 = _mm_div_ps(vTemp, W);
-
-                        // Result 2
-                        Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-                        X = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-
-                        vTemp = XM_FMADD_PS(Y, row1, row3);
-                        vTemp2 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        XMVECTOR V2 = _mm_div_ps(vTemp, W);
-
-                        vTemp = _mm_movelh_ps(V1, V2);
-
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-                        pOutputVector += sizeof(XMFLOAT2) * 2;
-
-                        i += 2;
-                    }
-                }
-                else
-                {
-                    // Packed input, unaligned & packed output
-                    for (size_t j = 0; j < two; ++j)
-                    {
-                        XMVECTOR V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 2;
-
-                        // Result 1
-                        XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-                        XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        XMVECTOR V1 = _mm_div_ps(vTemp, W);
-
-                        // Result 2
-                        Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-                        X = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-
-                        vTemp = XM_FMADD_PS(Y, row1, row3);
-                        vTemp2 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        XMVECTOR V2 = _mm_div_ps(vTemp, W);
-
-                        vTemp = _mm_movelh_ps(V1, V2);
-
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-                        pOutputVector += sizeof(XMFLOAT2) * 2;
-
-                        i += 2;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < two; ++j)
-                {
-                    XMVECTOR V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    pInputVector += sizeof(XMFLOAT2) * 2;
-
-                    // Result 1
-                    XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-                    XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                    XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                    vTemp = _mm_div_ps(vTemp, W);
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-                    pOutputVector += OutputStride;
-
-                    // Result 2
-                    Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-                    X = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-
-                    vTemp = XM_FMADD_PS(Y, row1, row3);
-                    vTemp2 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                    vTemp = _mm_div_ps(vTemp, W);
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-                    pOutputVector += OutputStride;
-
-                    i += 2;
-                }
-            }
-        }
-    }
-
-    if (!(reinterpret_cast<uintptr_t>(pInputVector) & 0xF) && !(InputStride & 0xF))
-    {
-        // Aligned input
-        for (; i < VectorCount; i++)
-        {
-            XMVECTOR V = _mm_castsi128_ps(_mm_loadl_epi64(reinterpret_cast<const __m128i*>(pInputVector)));
-            pInputVector += InputStride;
-
-            XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-            XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-            vTemp = _mm_add_ps(vTemp, vTemp2);
-
-            XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-            vTemp = _mm_div_ps(vTemp, W);
-
-            _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-            pOutputVector += OutputStride;
-        }
-    }
-    else
-    {
-        // Unaligned input
-        for (; i < VectorCount; i++)
-        {
-            __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pInputVector)));
-            pInputVector += InputStride;
-
-            XMVECTOR Y = XM_PERMUTE_PS(xy, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(xy, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = XM_FMADD_PS(Y, row1, row3);
-            XMVECTOR vTemp2 = _mm_mul_ps(X, row0);
-            vTemp = _mm_add_ps(vTemp, vTemp2);
-
-            XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-            vTemp = _mm_div_ps(vTemp, W);
-
-            _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-            pOutputVector += OutputStride;
-        }
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector2TransformNormal
-        (
-                FXMVECTOR V,
-                FXMMATRIX M
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Y = XMVectorSplatY(V);
-    XMVECTOR X = XMVectorSplatX(V);
-
-    XMVECTOR Result = XMVectorMultiply(Y, M.r[1]);
-    Result = XMVectorMultiplyAdd(X, M.r[0], Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    float32x4_t Result = vmulq_lane_f32(M.r[1], VL, 1); // Y
-    return vmlaq_lane_f32(Result, M.r[0], VL, 0); // X
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1)); // Y
-    vResult = _mm_mul_ps(vResult, M.r[1]);
-    XMVECTOR vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0)); // X
-    vResult = XM_FMADD_PS(vTemp, M.r[0], vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline XMFLOAT2* XM_CALLCONV XMVector2TransformNormalStream
-        (
-                XMFLOAT2* pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT2* pInputStream,
-                size_t          InputStride,
-                size_t          VectorCount,
-                FXMMATRIX       M
-        ) noexcept
-{
-    assert(pOutputStream != nullptr);
-    assert(pInputStream != nullptr);
-
-    assert(InputStride >= sizeof(XMFLOAT2));
-    _Analysis_assume_(InputStride >= sizeof(XMFLOAT2));
-
-    assert(OutputStride >= sizeof(XMFLOAT2));
-    _Analysis_assume_(OutputStride >= sizeof(XMFLOAT2));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-
-    for (size_t i = 0; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pInputVector));
-        XMVECTOR Y = XMVectorSplatY(V);
-        XMVECTOR X = XMVectorSplatX(V);
-
-        XMVECTOR Result = XMVectorMultiply(Y, row1);
-        Result = XMVectorMultiplyAdd(X, row0, Result);
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015, "PREfast noise: Esp:1307" )
-#endif
-
-        XMStoreFloat2(reinterpret_cast<XMFLOAT2*>(pOutputVector), Result);
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-        pInputVector += InputStride;
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if ((InputStride == sizeof(XMFLOAT2)) && (OutputStride == sizeof(XMFLOAT2)))
-        {
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4x2_t V = vld2q_f32(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += sizeof(XMFLOAT2) * 4;
-
-                float32x2_t r = vget_low_f32(row0);
-                XMVECTOR vResult0 = vmulq_lane_f32(V.val[0], r, 0); // Ax
-                XMVECTOR vResult1 = vmulq_lane_f32(V.val[0], r, 1); // Bx
-
-                XM_PREFETCH(pInputVector);
-                XM_PREFETCH(pInputVector + XM_CACHE_LINE_SIZE);
-
-                r = vget_low_f32(row1);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[1], r, 0); // Ax+Ey
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[1], r, 1); // Bx+Fy
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 2));
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 3));
-
-                V.val[0] = vResult0;
-                V.val[1] = vResult1;
-
-                vst2q_f32(reinterpret_cast<float*>(pOutputVector), V);
-                pOutputVector += sizeof(XMFLOAT2) * 4;
-
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        float32x2_t V = vld1_f32(reinterpret_cast<const float*>(pInputVector));
-        pInputVector += InputStride;
-
-        XMVECTOR vResult = vmulq_lane_f32(row0, V, 0); // X
-        vResult = vmlaq_lane_f32(vResult, row1, V, 1); // Y
-
-        V = vget_low_f32(vResult);
-        vst1_f32(reinterpret_cast<float*>(pOutputVector), V);
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-#elif defined(_XM_AVX2_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        __m256 row0 = _mm256_broadcast_ps(&M.r[0]);
-        __m256 row1 = _mm256_broadcast_ps(&M.r[1]);
-
-        if (InputStride == sizeof(XMFLOAT2))
-        {
-            if (OutputStride == sizeof(XMFLOAT2))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0x1F))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 4;
-
-                        __m256 Y2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-                        __m256 X2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                        __m256 Y1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                        __m256 X1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        __m256 vTempA = _mm256_mul_ps(Y1, row1);
-                        __m256 vTempB = _mm256_mul_ps(Y2, row1);
-                        vTempA = _mm256_fmadd_ps(X1, row0, vTempA);
-                        vTempB = _mm256_fmadd_ps(X2, row0, vTempB);
-
-                        X1 = _mm256_shuffle_ps(vTempA, vTempB, 0x44);
-                        XM256_STREAM_PS(reinterpret_cast<float*>(pOutputVector), X1);
-                        pOutputVector += sizeof(XMFLOAT2) * 4;
-
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 4;
-
-                        __m256 Y2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-                        __m256 X2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                        __m256 Y1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                        __m256 X1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        __m256 vTempA = _mm256_mul_ps(Y1, row1);
-                        __m256 vTempB = _mm256_mul_ps(Y2, row1);
-                        vTempA = _mm256_fmadd_ps(X1, row0, vTempA);
-                        vTempB = _mm256_fmadd_ps(X2, row0, vTempB);
-
-                        X1 = _mm256_shuffle_ps(vTempA, vTempB, 0x44);
-                        _mm256_storeu_ps(reinterpret_cast<float*>(pOutputVector), X1);
-                        pOutputVector += sizeof(XMFLOAT2) * 4;
-
-                        i += 4;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    pInputVector += sizeof(XMFLOAT2) * 4;
-
-                    __m256 Y2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-                    __m256 X2 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                    __m256 Y1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                    __m256 X1 = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    __m256 vTempA = _mm256_mul_ps(Y1, row1);
-                    __m256 vTempB = _mm256_mul_ps(Y2, row1);
-                    vTempA = _mm256_fmadd_ps(X1, row0, vTempA);
-                    vTempB = _mm256_fmadd_ps(X2, row0, vTempB);
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector),
-                        _mm_castps_pd(_mm256_castps256_ps128(vTempA)));
-                    pOutputVector += OutputStride;
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector),
-                        _mm_castps_pd(_mm256_castps256_ps128(vTempB)));
-                    pOutputVector += OutputStride;
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector),
-                        _mm_castps_pd(_mm256_extractf128_ps(vTempA, 1)));
-                    pOutputVector += OutputStride;
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector),
-                        _mm_castps_pd(_mm256_extractf128_ps(vTempB, 1)));
-                    pOutputVector += OutputStride;
-
-                    i += 4;
-                }
-            }
-        }
-    }
-
-    if (i < VectorCount)
-    {
-        const XMVECTOR row0 = M.r[0];
-        const XMVECTOR row1 = M.r[1];
-
-        for (; i < VectorCount; i++)
-        {
-            __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pInputVector)));
-            pInputVector += InputStride;
-
-            XMVECTOR Y = XM_PERMUTE_PS(xy, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(xy, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = _mm_mul_ps(Y, row1);
-            vTemp = XM_FMADD_PS(X, row0, vTemp);
-
-            _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-            pOutputVector += OutputStride;
-        }
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#elif defined(_XM_SSE_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-
-    size_t i = 0;
-    size_t two = VectorCount >> 1;
-    if (two > 0)
-    {
-        if (InputStride == sizeof(XMFLOAT2))
-        {
-            if (OutputStride == sizeof(XMFLOAT2))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < two; ++j)
-                    {
-                        XMVECTOR V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 2;
-
-                        // Result 1
-                        XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = _mm_mul_ps(Y, row1);
-                        XMVECTOR V1 = XM_FMADD_PS(X, row0, vTemp);
-
-                        // Result 2
-                        Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-                        X = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-
-                        vTemp = _mm_mul_ps(Y, row1);
-                        XMVECTOR V2 = XM_FMADD_PS(X, row0, vTemp);
-
-                        vTemp = _mm_movelh_ps(V1, V2);
-
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-                        pOutputVector += sizeof(XMFLOAT2) * 2;
-
-                        i += 2;
-                    }
-                }
-                else
-                {
-                    // Packed input, unaligned & packed output
-                    for (size_t j = 0; j < two; ++j)
-                    {
-                        XMVECTOR V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT2) * 2;
-
-                        // Result 1
-                        XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = _mm_mul_ps(Y, row1);
-                        XMVECTOR V1 = XM_FMADD_PS(X, row0, vTemp);
-
-                        // Result 2
-                        Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-                        X = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-
-                        vTemp = _mm_mul_ps(Y, row1);
-                        XMVECTOR V2 = XM_FMADD_PS(X, row0, vTemp);
-
-                        vTemp = _mm_movelh_ps(V1, V2);
-
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-                        pOutputVector += sizeof(XMFLOAT2) * 2;
-
-                        i += 2;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < two; ++j)
-                {
-                    XMVECTOR V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    pInputVector += sizeof(XMFLOAT2) * 2;
-
-                    // Result 1
-                    XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = _mm_mul_ps(Y, row1);
-                    vTemp = XM_FMADD_PS(X, row0, vTemp);
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-                    pOutputVector += OutputStride;
-
-                    // Result 2
-                    Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-                    X = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-
-                    vTemp = _mm_mul_ps(Y, row1);
-                    vTemp = XM_FMADD_PS(X, row0, vTemp);
-
-                    _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-                    pOutputVector += OutputStride;
-
-                    i += 2;
-                }
-            }
-        }
-    }
-
-    if (!(reinterpret_cast<uintptr_t>(pInputVector) & 0xF) && !(InputStride & 0xF))
-    {
-        // Aligned input
-        for (; i < VectorCount; i++)
-        {
-            XMVECTOR V = _mm_castsi128_ps(_mm_loadl_epi64(reinterpret_cast<const __m128i*>(pInputVector)));
-            pInputVector += InputStride;
-
-            XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = _mm_mul_ps(Y, row1);
-            vTemp = XM_FMADD_PS(X, row0, vTemp);
-
-            _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-            pOutputVector += OutputStride;
-        }
-    }
-    else
-    {
-        // Unaligned input
-        for (; i < VectorCount; i++)
-        {
-            __m128 xy = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(pInputVector)));
-            pInputVector += InputStride;
-
-            XMVECTOR Y = XM_PERMUTE_PS(xy, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(xy, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = _mm_mul_ps(Y, row1);
-            vTemp = XM_FMADD_PS(X, row0, vTemp);
-
-            _mm_store_sd(reinterpret_cast<double*>(pOutputVector), _mm_castps_pd(vTemp));
-            pOutputVector += OutputStride;
-        }
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#endif
-}
-
-/****************************************************************************
- *
- * 3D Vector
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-// Comparison operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3Equal
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] == V2.vector4_f32[0]) && (V1.vector4_f32[1] == V2.vector4_f32[1]) && (V1.vector4_f32[2] == V2.vector4_f32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) == 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpeq_ps(V1, V2);
-    return (((_mm_movemask_ps(vTemp) & 7) == 7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector3EqualR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    uint32_t CR = 0;
-    if ((V1.vector4_f32[0] == V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] == V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] == V2.vector4_f32[2]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_f32[0] != V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] != V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] != V2.vector4_f32[2]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU;
-
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpeq_ps(V1, V2);
-    int iTest = _mm_movemask_ps(vTemp) & 7;
-    uint32_t CR = 0;
-    if (iTest == 7)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3EqualInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_u32[0] == V2.vector4_u32[0]) && (V1.vector4_u32[1] == V2.vector4_u32[1]) && (V1.vector4_u32[2] == V2.vector4_u32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2));
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) == 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return (((_mm_movemask_ps(_mm_castsi128_ps(vTemp)) & 7) == 7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector3EqualIntR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    uint32_t CR = 0;
-    if ((V1.vector4_u32[0] == V2.vector4_u32[0]) &&
-        (V1.vector4_u32[1] == V2.vector4_u32[1]) &&
-        (V1.vector4_u32[2] == V2.vector4_u32[2]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_u32[0] != V2.vector4_u32[0]) &&
-        (V1.vector4_u32[1] != V2.vector4_u32[1]) &&
-        (V1.vector4_u32[2] != V2.vector4_u32[2]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2));
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU;
-
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    int iTemp = _mm_movemask_ps(_mm_castsi128_ps(vTemp)) & 7;
-    uint32_t CR = 0;
-    if (iTemp == 7)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTemp)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3NearEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2,
-                FXMVECTOR Epsilon
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float dx, dy, dz;
-
-    dx = fabsf(V1.vector4_f32[0] - V2.vector4_f32[0]);
-    dy = fabsf(V1.vector4_f32[1] - V2.vector4_f32[1]);
-    dz = fabsf(V1.vector4_f32[2] - V2.vector4_f32[2]);
-    return (((dx <= Epsilon.vector4_f32[0]) &&
-        (dy <= Epsilon.vector4_f32[1]) &&
-        (dz <= Epsilon.vector4_f32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t vDelta = vsubq_f32(V1, V2);
-#if defined(_MSC_VER) && !defined(__clang__)
-    uint32x4_t vResult = vacleq_f32(vDelta, Epsilon);
-#else
-    uint32x4_t vResult = vcleq_f32(vabsq_f32(vDelta), Epsilon);
-#endif
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) == 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Get the difference
-    XMVECTOR vDelta = _mm_sub_ps(V1, V2);
-    // Get the absolute value of the difference
-    XMVECTOR vTemp = _mm_setzero_ps();
-    vTemp = _mm_sub_ps(vTemp, vDelta);
-    vTemp = _mm_max_ps(vTemp, vDelta);
-    vTemp = _mm_cmple_ps(vTemp, Epsilon);
-    // w is don't care
-    return (((_mm_movemask_ps(vTemp) & 7) == 0x7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3NotEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] != V2.vector4_f32[0]) || (V1.vector4_f32[1] != V2.vector4_f32[1]) || (V1.vector4_f32[2] != V2.vector4_f32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) != 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpeq_ps(V1, V2);
-    return (((_mm_movemask_ps(vTemp) & 7) != 7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3NotEqualInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_u32[0] != V2.vector4_u32[0]) || (V1.vector4_u32[1] != V2.vector4_u32[1]) || (V1.vector4_u32[2] != V2.vector4_u32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2));
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) != 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return (((_mm_movemask_ps(_mm_castsi128_ps(vTemp)) & 7) != 7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3Greater
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] > V2.vector4_f32[0]) && (V1.vector4_f32[1] > V2.vector4_f32[1]) && (V1.vector4_f32[2] > V2.vector4_f32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgtq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) == 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpgt_ps(V1, V2);
-    return (((_mm_movemask_ps(vTemp) & 7) == 7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector3GreaterR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    uint32_t CR = 0;
-    if ((V1.vector4_f32[0] > V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] > V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] > V2.vector4_f32[2]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_f32[0] <= V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] <= V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] <= V2.vector4_f32[2]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgtq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU;
-
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpgt_ps(V1, V2);
-    uint32_t CR = 0;
-    int iTest = _mm_movemask_ps(vTemp) & 7;
-    if (iTest == 7)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3GreaterOrEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] >= V2.vector4_f32[0]) && (V1.vector4_f32[1] >= V2.vector4_f32[1]) && (V1.vector4_f32[2] >= V2.vector4_f32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgeq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) == 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpge_ps(V1, V2);
-    return (((_mm_movemask_ps(vTemp) & 7) == 7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector3GreaterOrEqualR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t CR = 0;
-    if ((V1.vector4_f32[0] >= V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] >= V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] >= V2.vector4_f32[2]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_f32[0] < V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] < V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] < V2.vector4_f32[2]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgeq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU;
-
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpge_ps(V1, V2);
-    uint32_t CR = 0;
-    int iTest = _mm_movemask_ps(vTemp) & 7;
-    if (iTest == 7)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3Less
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] < V2.vector4_f32[0]) && (V1.vector4_f32[1] < V2.vector4_f32[1]) && (V1.vector4_f32[2] < V2.vector4_f32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcltq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) == 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmplt_ps(V1, V2);
-    return (((_mm_movemask_ps(vTemp) & 7) == 7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3LessOrEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] <= V2.vector4_f32[0]) && (V1.vector4_f32[1] <= V2.vector4_f32[1]) && (V1.vector4_f32[2] <= V2.vector4_f32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcleq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) == 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmple_ps(V1, V2);
-    return (((_mm_movemask_ps(vTemp) & 7) == 7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3InBounds
-        (
-                FXMVECTOR V,
-                FXMVECTOR Bounds
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) &&
-        (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1]) &&
-        (V.vector4_f32[2] <= Bounds.vector4_f32[2] && V.vector4_f32[2] >= -Bounds.vector4_f32[2])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Test if less than or equal
-    uint32x4_t ivTemp1 = vcleq_f32(V, Bounds);
-    // Negate the bounds
-    float32x4_t vTemp2 = vnegq_f32(Bounds);
-    // Test if greater or equal (Reversed)
-    uint32x4_t ivTemp2 = vcleq_f32(vTemp2, V);
-    // Blend answers
-    ivTemp1 = vandq_u32(ivTemp1, ivTemp2);
-    // in bounds?
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(ivTemp1)), vget_high_u8(vreinterpretq_u8_u32(ivTemp1)));
-    uint16x4x2_t vTemp3 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp3.val[1]), 1) & 0xFFFFFFU) == 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Test if less than or equal
-    XMVECTOR vTemp1 = _mm_cmple_ps(V, Bounds);
-    // Negate the bounds
-    XMVECTOR vTemp2 = _mm_mul_ps(Bounds, g_XMNegativeOne);
-    // Test if greater or equal (Reversed)
-    vTemp2 = _mm_cmple_ps(vTemp2, V);
-    // Blend answers
-    vTemp1 = _mm_and_ps(vTemp1, vTemp2);
-    // x,y and z in bounds? (w is don't care)
-    return (((_mm_movemask_ps(vTemp1) & 0x7) == 0x7) != 0);
-#else
-    return XMComparisonAllInBounds(XMVector3InBoundsR(V, Bounds));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(push)
-#pragma float_control(precise, on)
-#endif
-
-inline bool XM_CALLCONV XMVector3IsNaN(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    return (XMISNAN(V.vector4_f32[0]) ||
-        XMISNAN(V.vector4_f32[1]) ||
-        XMISNAN(V.vector4_f32[2]));
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Test against itself. NaN is always not equal
-    uint32x4_t vTempNan = vceqq_f32(V, V);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vTempNan)), vget_high_u8(vreinterpretq_u8_u32(vTempNan)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    // If x or y or z are NaN, the mask is zero
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) != 0xFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Test against itself. NaN is always not equal
-    XMVECTOR vTempNan = _mm_cmpneq_ps(V, V);
-    // If x or y or z are NaN, the mask is non-zero
-    return ((_mm_movemask_ps(vTempNan) & 7) != 0);
-#endif
-}
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector3IsInfinite(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (XMISINF(V.vector4_f32[0]) ||
-        XMISINF(V.vector4_f32[1]) ||
-        XMISINF(V.vector4_f32[2]));
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Mask off the sign bit
-    uint32x4_t vTempInf = vandq_u32(vreinterpretq_u32_f32(V), g_XMAbsMask);
-    // Compare to infinity
-    vTempInf = vceqq_f32(vreinterpretq_f32_u32(vTempInf), g_XMInfinity);
-    // If any are infinity, the signs are true.
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vTempInf)), vget_high_u8(vreinterpretq_u8_u32(vTempInf)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return ((vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) & 0xFFFFFFU) != 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Mask off the sign bit
-    __m128 vTemp = _mm_and_ps(V, g_XMAbsMask);
-    // Compare to infinity
-    vTemp = _mm_cmpeq_ps(vTemp, g_XMInfinity);
-    // If x,y or z are infinity, the signs are true.
-    return ((_mm_movemask_ps(vTemp) & 7) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Computation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Dot
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float fValue = V1.vector4_f32[0] * V2.vector4_f32[0] + V1.vector4_f32[1] * V2.vector4_f32[1] + V1.vector4_f32[2] * V2.vector4_f32[2];
-    XMVECTORF32 vResult;
-    vResult.f[0] =
-        vResult.f[1] =
-        vResult.f[2] =
-        vResult.f[3] = fValue;
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t vTemp = vmulq_f32(V1, V2);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vpadd_f32(v1, v1);
-    v2 = vdup_lane_f32(v2, 0);
-    v1 = vadd_f32(v1, v2);
-    return vcombine_f32(v1, v1);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    return _mm_dp_ps(V1, V2, 0x7f);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vTemp = _mm_mul_ps(V1, V2);
-    vTemp = _mm_and_ps(vTemp, g_XMMask3);
-    vTemp = _mm_hadd_ps(vTemp, vTemp);
-    return _mm_hadd_ps(vTemp, vTemp);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product
-    XMVECTOR vDot = _mm_mul_ps(V1, V2);
-    // x=Dot.vector4_f32[1], y=Dot.vector4_f32[2]
-    XMVECTOR vTemp = XM_PERMUTE_PS(vDot, _MM_SHUFFLE(2, 1, 2, 1));
-    // Result.vector4_f32[0] = x+y
-    vDot = _mm_add_ss(vDot, vTemp);
-    // x=Dot.vector4_f32[2]
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(1, 1, 1, 1));
-    // Result.vector4_f32[0] = (x+y)+z
-    vDot = _mm_add_ss(vDot, vTemp);
-    // Splat x
-    return XM_PERMUTE_PS(vDot, _MM_SHUFFLE(0, 0, 0, 0));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Cross
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    // [ V1.y*V2.z - V1.z*V2.y, V1.z*V2.x - V1.x*V2.z, V1.x*V2.y - V1.y*V2.x ]
-
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            (V1.vector4_f32[1] * V2.vector4_f32[2]) - (V1.vector4_f32[2] * V2.vector4_f32[1]),
-            (V1.vector4_f32[2] * V2.vector4_f32[0]) - (V1.vector4_f32[0] * V2.vector4_f32[2]),
-            (V1.vector4_f32[0] * V2.vector4_f32[1]) - (V1.vector4_f32[1] * V2.vector4_f32[0]),
-            0.0f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t v1xy = vget_low_f32(V1);
-    float32x2_t v2xy = vget_low_f32(V2);
-
-    float32x2_t v1yx = vrev64_f32(v1xy);
-    float32x2_t v2yx = vrev64_f32(v2xy);
-
-    float32x2_t v1zz = vdup_lane_f32(vget_high_f32(V1), 0);
-    float32x2_t v2zz = vdup_lane_f32(vget_high_f32(V2), 0);
-
-    XMVECTOR vResult = vmulq_f32(vcombine_f32(v1yx, v1xy), vcombine_f32(v2zz, v2yx));
-    vResult = vmlsq_f32(vResult, vcombine_f32(v1zz, v1yx), vcombine_f32(v2yx, v2xy));
-    vResult = vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(vResult), g_XMFlipY));
-    return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(vResult), g_XMMask3));
-#elif defined(_XM_SSE_INTRINSICS_)
-    // y1,z1,x1,w1
-    XMVECTOR vTemp1 = XM_PERMUTE_PS(V1, _MM_SHUFFLE(3, 0, 2, 1));
-    // z2,x2,y2,w2
-    XMVECTOR vTemp2 = XM_PERMUTE_PS(V2, _MM_SHUFFLE(3, 1, 0, 2));
-    // Perform the left operation
-    XMVECTOR vResult = _mm_mul_ps(vTemp1, vTemp2);
-    // z1,x1,y1,w1
-    vTemp1 = XM_PERMUTE_PS(vTemp1, _MM_SHUFFLE(3, 0, 2, 1));
-    // y2,z2,x2,w2
-    vTemp2 = XM_PERMUTE_PS(vTemp2, _MM_SHUFFLE(3, 1, 0, 2));
-    // Perform the right operation
-    vResult = XM_FNMADD_PS(vTemp1, vTemp2, vResult);
-    // Set w to zero
-    return _mm_and_ps(vResult, g_XMMask3);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3LengthSq(FXMVECTOR V) noexcept
-{
-    return XMVector3Dot(V, V);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3ReciprocalLengthEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-
-    Result = XMVector3LengthSq(V);
-    Result = XMVectorReciprocalSqrtEst(Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot3
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vpadd_f32(v1, v1);
-    v2 = vdup_lane_f32(v2, 0);
-    v1 = vadd_f32(v1, v2);
-    // Reciprocal sqrt (estimate)
-    v2 = vrsqrte_f32(v1);
-    return vcombine_f32(v2, v2);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x7f);
-    return _mm_rsqrt_ps(vTemp);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_and_ps(vLengthSq, g_XMMask3);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_rsqrt_ps(vLengthSq);
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y and z
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has z and y
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 2, 1, 2));
-    // x+z, y
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    // y,y,y,y
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(1, 1, 1, 1));
-    // x+z+y,??,??,??
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    // Splat the length squared
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    // Get the reciprocal
-    vLengthSq = _mm_rsqrt_ps(vLengthSq);
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3ReciprocalLength(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-
-    Result = XMVector3LengthSq(V);
-    Result = XMVectorReciprocalSqrt(Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot3
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vpadd_f32(v1, v1);
-    v2 = vdup_lane_f32(v2, 0);
-    v1 = vadd_f32(v1, v2);
-    // Reciprocal sqrt
-    float32x2_t  S0 = vrsqrte_f32(v1);
-    float32x2_t  P0 = vmul_f32(v1, S0);
-    float32x2_t  R0 = vrsqrts_f32(P0, S0);
-    float32x2_t  S1 = vmul_f32(S0, R0);
-    float32x2_t  P1 = vmul_f32(v1, S1);
-    float32x2_t  R1 = vrsqrts_f32(P1, S1);
-    float32x2_t Result = vmul_f32(S1, R1);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x7f);
-    XMVECTOR vLengthSq = _mm_sqrt_ps(vTemp);
-    return _mm_div_ps(g_XMOne, vLengthSq);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vDot = _mm_mul_ps(V, V);
-    vDot = _mm_and_ps(vDot, g_XMMask3);
-    vDot = _mm_hadd_ps(vDot, vDot);
-    vDot = _mm_hadd_ps(vDot, vDot);
-    vDot = _mm_sqrt_ps(vDot);
-    vDot = _mm_div_ps(g_XMOne, vDot);
-    return vDot;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product
-    XMVECTOR vDot = _mm_mul_ps(V, V);
-    // x=Dot.y, y=Dot.z
-    XMVECTOR vTemp = XM_PERMUTE_PS(vDot, _MM_SHUFFLE(2, 1, 2, 1));
-    // Result.x = x+y
-    vDot = _mm_add_ss(vDot, vTemp);
-    // x=Dot.z
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(1, 1, 1, 1));
-    // Result.x = (x+y)+z
-    vDot = _mm_add_ss(vDot, vTemp);
-    // Splat x
-    vDot = XM_PERMUTE_PS(vDot, _MM_SHUFFLE(0, 0, 0, 0));
-    // Get the reciprocal
-    vDot = _mm_sqrt_ps(vDot);
-    // Get the reciprocal
-    vDot = _mm_div_ps(g_XMOne, vDot);
-    return vDot;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3LengthEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-
-    Result = XMVector3LengthSq(V);
-    Result = XMVectorSqrtEst(Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot3
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vpadd_f32(v1, v1);
-    v2 = vdup_lane_f32(v2, 0);
-    v1 = vadd_f32(v1, v2);
-    const float32x2_t zero = vdup_n_f32(0);
-    uint32x2_t VEqualsZero = vceq_f32(v1, zero);
-    // Sqrt (estimate)
-    float32x2_t Result = vrsqrte_f32(v1);
-    Result = vmul_f32(v1, Result);
-    Result = vbsl_f32(VEqualsZero, zero, Result);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x7f);
-    return _mm_sqrt_ps(vTemp);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_and_ps(vLengthSq, g_XMMask3);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y and z
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has z and y
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 2, 1, 2));
-    // x+z, y
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    // y,y,y,y
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(1, 1, 1, 1));
-    // x+z+y,??,??,??
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    // Splat the length squared
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    // Get the length
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Length(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-
-    Result = XMVector3LengthSq(V);
-    Result = XMVectorSqrt(Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot3
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vpadd_f32(v1, v1);
-    v2 = vdup_lane_f32(v2, 0);
-    v1 = vadd_f32(v1, v2);
-    const float32x2_t zero = vdup_n_f32(0);
-    uint32x2_t VEqualsZero = vceq_f32(v1, zero);
-    // Sqrt
-    float32x2_t S0 = vrsqrte_f32(v1);
-    float32x2_t P0 = vmul_f32(v1, S0);
-    float32x2_t R0 = vrsqrts_f32(P0, S0);
-    float32x2_t S1 = vmul_f32(S0, R0);
-    float32x2_t P1 = vmul_f32(v1, S1);
-    float32x2_t R1 = vrsqrts_f32(P1, S1);
-    float32x2_t Result = vmul_f32(S1, R1);
-    Result = vmul_f32(v1, Result);
-    Result = vbsl_f32(VEqualsZero, zero, Result);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x7f);
-    return _mm_sqrt_ps(vTemp);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_and_ps(vLengthSq, g_XMMask3);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y and z
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has z and y
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 2, 1, 2));
-    // x+z, y
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    // y,y,y,y
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(1, 1, 1, 1));
-    // x+z+y,??,??,??
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    // Splat the length squared
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    // Get the length
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// XMVector3NormalizeEst uses a reciprocal estimate and
-// returns QNaN on zero and infinite vectors.
-
-inline XMVECTOR XM_CALLCONV XMVector3NormalizeEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-    Result = XMVector3ReciprocalLength(V);
-    Result = XMVectorMultiply(V, Result);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot3
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vpadd_f32(v1, v1);
-    v2 = vdup_lane_f32(v2, 0);
-    v1 = vadd_f32(v1, v2);
-    // Reciprocal sqrt (estimate)
-    v2 = vrsqrte_f32(v1);
-    // Normalize
-    return vmulq_f32(V, vcombine_f32(v2, v2));
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0x7f);
-    XMVECTOR vResult = _mm_rsqrt_ps(vTemp);
-    return _mm_mul_ps(vResult, V);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vDot = _mm_mul_ps(V, V);
-    vDot = _mm_and_ps(vDot, g_XMMask3);
-    vDot = _mm_hadd_ps(vDot, vDot);
-    vDot = _mm_hadd_ps(vDot, vDot);
-    vDot = _mm_rsqrt_ps(vDot);
-    vDot = _mm_mul_ps(vDot, V);
-    return vDot;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product
-    XMVECTOR vDot = _mm_mul_ps(V, V);
-    // x=Dot.y, y=Dot.z
-    XMVECTOR vTemp = XM_PERMUTE_PS(vDot, _MM_SHUFFLE(2, 1, 2, 1));
-    // Result.x = x+y
-    vDot = _mm_add_ss(vDot, vTemp);
-    // x=Dot.z
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(1, 1, 1, 1));
-    // Result.x = (x+y)+z
-    vDot = _mm_add_ss(vDot, vTemp);
-    // Splat x
-    vDot = XM_PERMUTE_PS(vDot, _MM_SHUFFLE(0, 0, 0, 0));
-    // Get the reciprocal
-    vDot = _mm_rsqrt_ps(vDot);
-    // Perform the normalization
-    vDot = _mm_mul_ps(vDot, V);
-    return vDot;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Normalize(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float fLength;
-    XMVECTOR vResult;
-
-    vResult = XMVector3Length(V);
-    fLength = vResult.vector4_f32[0];
-
-    // Prevent divide by zero
-    if (fLength > 0)
-    {
-        fLength = 1.0f / fLength;
-    }
-
-    vResult.vector4_f32[0] = V.vector4_f32[0] * fLength;
-    vResult.vector4_f32[1] = V.vector4_f32[1] * fLength;
-    vResult.vector4_f32[2] = V.vector4_f32[2] * fLength;
-    vResult.vector4_f32[3] = V.vector4_f32[3] * fLength;
-    return vResult;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot3
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vpadd_f32(v1, v1);
-    v2 = vdup_lane_f32(v2, 0);
-    v1 = vadd_f32(v1, v2);
-    uint32x2_t VEqualsZero = vceq_f32(v1, vdup_n_f32(0));
-    uint32x2_t VEqualsInf = vceq_f32(v1, vget_low_f32(g_XMInfinity));
-    // Reciprocal sqrt (2 iterations of Newton-Raphson)
-    float32x2_t S0 = vrsqrte_f32(v1);
-    float32x2_t P0 = vmul_f32(v1, S0);
-    float32x2_t R0 = vrsqrts_f32(P0, S0);
-    float32x2_t S1 = vmul_f32(S0, R0);
-    float32x2_t P1 = vmul_f32(v1, S1);
-    float32x2_t R1 = vrsqrts_f32(P1, S1);
-    v2 = vmul_f32(S1, R1);
-    // Normalize
-    XMVECTOR vResult = vmulq_f32(V, vcombine_f32(v2, v2));
-    vResult = vbslq_f32(vcombine_u32(VEqualsZero, VEqualsZero), vdupq_n_f32(0), vResult);
-    return vbslq_f32(vcombine_u32(VEqualsInf, VEqualsInf), g_XMQNaN, vResult);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_dp_ps(V, V, 0x7f);
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Create zero with a single instruction
-    XMVECTOR vZeroMask = _mm_setzero_ps();
-    // Test for a divide by zero (Must be FP to detect -0.0)
-    vZeroMask = _mm_cmpneq_ps(vZeroMask, vResult);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Divide to perform the normalization
-    vResult = _mm_div_ps(V, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vZeroMask);
-    // Select qnan or result based on infinite length
-    XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq, g_XMQNaN);
-    XMVECTOR vTemp2 = _mm_and_ps(vResult, vLengthSq);
-    vResult = _mm_or_ps(vTemp1, vTemp2);
-    return vResult;
-#elif defined(_XM_SSE3_INTRINSICS_)
-    // Perform the dot product on x,y and z only
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_and_ps(vLengthSq, g_XMMask3);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Create zero with a single instruction
-    XMVECTOR vZeroMask = _mm_setzero_ps();
-    // Test for a divide by zero (Must be FP to detect -0.0)
-    vZeroMask = _mm_cmpneq_ps(vZeroMask, vResult);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Divide to perform the normalization
-    vResult = _mm_div_ps(V, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vZeroMask);
-    // Select qnan or result based on infinite length
-    XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq, g_XMQNaN);
-    XMVECTOR vTemp2 = _mm_and_ps(vResult, vLengthSq);
-    vResult = _mm_or_ps(vTemp1, vTemp2);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y and z only
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(2, 1, 2, 1));
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(1, 1, 1, 1));
-    vLengthSq = _mm_add_ss(vLengthSq, vTemp);
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(0, 0, 0, 0));
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Create zero with a single instruction
-    XMVECTOR vZeroMask = _mm_setzero_ps();
-    // Test for a divide by zero (Must be FP to detect -0.0)
-    vZeroMask = _mm_cmpneq_ps(vZeroMask, vResult);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Divide to perform the normalization
-    vResult = _mm_div_ps(V, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vZeroMask);
-    // Select qnan or result based on infinite length
-    XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq, g_XMQNaN);
-    XMVECTOR vTemp2 = _mm_and_ps(vResult, vLengthSq);
-    vResult = _mm_or_ps(vTemp1, vTemp2);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3ClampLength
-        (
-                FXMVECTOR V,
-                float    LengthMin,
-                float    LengthMax
-        ) noexcept
-{
-    XMVECTOR ClampMax = XMVectorReplicate(LengthMax);
-    XMVECTOR ClampMin = XMVectorReplicate(LengthMin);
-
-    return XMVector3ClampLengthV(V, ClampMin, ClampMax);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3ClampLengthV
-        (
-                FXMVECTOR V,
-                FXMVECTOR LengthMin,
-                FXMVECTOR LengthMax
-        ) noexcept
-{
-    assert((XMVectorGetY(LengthMin) == XMVectorGetX(LengthMin)) && (XMVectorGetZ(LengthMin) == XMVectorGetX(LengthMin)));
-    assert((XMVectorGetY(LengthMax) == XMVectorGetX(LengthMax)) && (XMVectorGetZ(LengthMax) == XMVectorGetX(LengthMax)));
-    assert(XMVector3GreaterOrEqual(LengthMin, XMVectorZero()));
-    assert(XMVector3GreaterOrEqual(LengthMax, XMVectorZero()));
-    assert(XMVector3GreaterOrEqual(LengthMax, LengthMin));
-
-    XMVECTOR LengthSq = XMVector3LengthSq(V);
-
-    const XMVECTOR Zero = XMVectorZero();
-
-    XMVECTOR RcpLength = XMVectorReciprocalSqrt(LengthSq);
-
-    XMVECTOR InfiniteLength = XMVectorEqualInt(LengthSq, g_XMInfinity.v);
-    XMVECTOR ZeroLength = XMVectorEqual(LengthSq, Zero);
-
-    XMVECTOR Normal = XMVectorMultiply(V, RcpLength);
-
-    XMVECTOR Length = XMVectorMultiply(LengthSq, RcpLength);
-
-    XMVECTOR Select = XMVectorEqualInt(InfiniteLength, ZeroLength);
-    Length = XMVectorSelect(LengthSq, Length, Select);
-    Normal = XMVectorSelect(LengthSq, Normal, Select);
-
-    XMVECTOR ControlMax = XMVectorGreater(Length, LengthMax);
-    XMVECTOR ControlMin = XMVectorLess(Length, LengthMin);
-
-    XMVECTOR ClampLength = XMVectorSelect(Length, LengthMax, ControlMax);
-    ClampLength = XMVectorSelect(ClampLength, LengthMin, ControlMin);
-
-    XMVECTOR Result = XMVectorMultiply(Normal, ClampLength);
-
-    // Preserve the original vector (with no precision loss) if the length falls within the given range
-    XMVECTOR Control = XMVectorEqualInt(ControlMax, ControlMin);
-    Result = XMVectorSelect(Result, V, Control);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Reflect
-        (
-                FXMVECTOR Incident,
-                FXMVECTOR Normal
-        ) noexcept
-{
-    // Result = Incident - (2 * dot(Incident, Normal)) * Normal
-
-    XMVECTOR Result = XMVector3Dot(Incident, Normal);
-    Result = XMVectorAdd(Result, Result);
-    Result = XMVectorNegativeMultiplySubtract(Result, Normal, Incident);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Refract
-        (
-                FXMVECTOR Incident,
-                FXMVECTOR Normal,
-                float    RefractionIndex
-        ) noexcept
-{
-    XMVECTOR Index = XMVectorReplicate(RefractionIndex);
-    return XMVector3RefractV(Incident, Normal, Index);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3RefractV
-        (
-                FXMVECTOR Incident,
-                FXMVECTOR Normal,
-                FXMVECTOR RefractionIndex
-        ) noexcept
-{
-    // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) +
-    // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal))))
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    const XMVECTOR  Zero = XMVectorZero();
-
-    XMVECTOR IDotN = XMVector3Dot(Incident, Normal);
-
-    // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN)
-    XMVECTOR R = XMVectorNegativeMultiplySubtract(IDotN, IDotN, g_XMOne.v);
-    R = XMVectorMultiply(R, RefractionIndex);
-    R = XMVectorNegativeMultiplySubtract(R, RefractionIndex, g_XMOne.v);
-
-    if (XMVector4LessOrEqual(R, Zero))
-    {
-        // Total internal reflection
-        return Zero;
-    }
-    else
-    {
-        // R = RefractionIndex * IDotN + sqrt(R)
-        R = XMVectorSqrt(R);
-        R = XMVectorMultiplyAdd(RefractionIndex, IDotN, R);
-
-        // Result = RefractionIndex * Incident - Normal * R
-        XMVECTOR Result = XMVectorMultiply(RefractionIndex, Incident);
-        Result = XMVectorNegativeMultiplySubtract(Normal, R, Result);
-
-        return Result;
-    }
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR IDotN = XMVector3Dot(Incident, Normal);
-
-    // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN)
-    float32x4_t R = vmlsq_f32(g_XMOne, IDotN, IDotN);
-    R = vmulq_f32(R, RefractionIndex);
-    R = vmlsq_f32(g_XMOne, R, RefractionIndex);
-
-    uint32x4_t isrzero = vcleq_f32(R, g_XMZero);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(isrzero)), vget_high_u8(vreinterpretq_u8_u32(isrzero)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-
-    float32x4_t vResult;
-    if (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) == 0xFFFFFFFFU)
-    {
-        // Total internal reflection
-        vResult = g_XMZero;
-    }
-    else
-    {
-        // Sqrt(R)
-        float32x4_t S0 = vrsqrteq_f32(R);
-        float32x4_t P0 = vmulq_f32(R, S0);
-        float32x4_t R0 = vrsqrtsq_f32(P0, S0);
-        float32x4_t S1 = vmulq_f32(S0, R0);
-        float32x4_t P1 = vmulq_f32(R, S1);
-        float32x4_t R1 = vrsqrtsq_f32(P1, S1);
-        float32x4_t S2 = vmulq_f32(S1, R1);
-        R = vmulq_f32(R, S2);
-        // R = RefractionIndex * IDotN + sqrt(R)
-        R = vmlaq_f32(R, RefractionIndex, IDotN);
-        // Result = RefractionIndex * Incident - Normal * R
-        vResult = vmulq_f32(RefractionIndex, Incident);
-        vResult = vmlsq_f32(vResult, R, Normal);
-    }
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) +
-    // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal))))
-    XMVECTOR IDotN = XMVector3Dot(Incident, Normal);
-    // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN)
-    XMVECTOR R = XM_FNMADD_PS(IDotN, IDotN, g_XMOne);
-    XMVECTOR R2 = _mm_mul_ps(RefractionIndex, RefractionIndex);
-    R = XM_FNMADD_PS(R, R2, g_XMOne);
-
-    XMVECTOR vResult = _mm_cmple_ps(R, g_XMZero);
-    if (_mm_movemask_ps(vResult) == 0x0f)
-    {
-        // Total internal reflection
-        vResult = g_XMZero;
-    }
-    else
-    {
-        // R = RefractionIndex * IDotN + sqrt(R)
-        R = _mm_sqrt_ps(R);
-        R = XM_FMADD_PS(RefractionIndex, IDotN, R);
-        // Result = RefractionIndex * Incident - Normal * R
-        vResult = _mm_mul_ps(RefractionIndex, Incident);
-        vResult = XM_FNMADD_PS(R, Normal, vResult);
-    }
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Orthogonal(FXMVECTOR V) noexcept
-{
-    XMVECTOR Zero = XMVectorZero();
-    XMVECTOR Z = XMVectorSplatZ(V);
-    XMVECTOR YZYY = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(V);
-
-    XMVECTOR NegativeV = XMVectorSubtract(Zero, V);
-
-    XMVECTOR ZIsNegative = XMVectorLess(Z, Zero);
-    XMVECTOR YZYYIsNegative = XMVectorLess(YZYY, Zero);
-
-    XMVECTOR S = XMVectorAdd(YZYY, Z);
-    XMVECTOR D = XMVectorSubtract(YZYY, Z);
-
-    XMVECTOR Select = XMVectorEqualInt(ZIsNegative, YZYYIsNegative);
-
-    XMVECTOR R0 = XMVectorPermute<XM_PERMUTE_1X, XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_0X>(NegativeV, S);
-    XMVECTOR R1 = XMVectorPermute<XM_PERMUTE_1X, XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_0X>(V, D);
-
-    return XMVectorSelect(R1, R0, Select);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3AngleBetweenNormalsEst
-        (
-                FXMVECTOR N1,
-                FXMVECTOR N2
-        ) noexcept
-{
-    XMVECTOR Result = XMVector3Dot(N1, N2);
-    Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v);
-    Result = XMVectorACosEst(Result);
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3AngleBetweenNormals
-        (
-                FXMVECTOR N1,
-                FXMVECTOR N2
-        ) noexcept
-{
-    XMVECTOR Result = XMVector3Dot(N1, N2);
-    Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v);
-    Result = XMVectorACos(Result);
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3AngleBetweenVectors
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    XMVECTOR L1 = XMVector3ReciprocalLength(V1);
-    XMVECTOR L2 = XMVector3ReciprocalLength(V2);
-
-    XMVECTOR Dot = XMVector3Dot(V1, V2);
-
-    L1 = XMVectorMultiply(L1, L2);
-
-    XMVECTOR CosAngle = XMVectorMultiply(Dot, L1);
-    CosAngle = XMVectorClamp(CosAngle, g_XMNegativeOne.v, g_XMOne.v);
-
-    return XMVectorACos(CosAngle);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3LinePointDistance
-        (
-                FXMVECTOR LinePoint1,
-                FXMVECTOR LinePoint2,
-                FXMVECTOR Point
-        ) noexcept
-{
-    // Given a vector PointVector from LinePoint1 to Point and a vector
-    // LineVector from LinePoint1 to LinePoint2, the scaled distance
-    // PointProjectionScale from LinePoint1 to the perpendicular projection
-    // of PointVector onto the line is defined as:
-    //
-    //     PointProjectionScale = dot(PointVector, LineVector) / LengthSq(LineVector)
-
-    XMVECTOR PointVector = XMVectorSubtract(Point, LinePoint1);
-    XMVECTOR LineVector = XMVectorSubtract(LinePoint2, LinePoint1);
-
-    XMVECTOR LengthSq = XMVector3LengthSq(LineVector);
-
-    XMVECTOR PointProjectionScale = XMVector3Dot(PointVector, LineVector);
-    PointProjectionScale = XMVectorDivide(PointProjectionScale, LengthSq);
-
-    XMVECTOR DistanceVector = XMVectorMultiply(LineVector, PointProjectionScale);
-    DistanceVector = XMVectorSubtract(PointVector, DistanceVector);
-
-    return XMVector3Length(DistanceVector);
-}
-
-//------------------------------------------------------------------------------
-
-    _Use_decl_annotations_
-inline void XM_CALLCONV XMVector3ComponentsFromNormal
-        (
-                XMVECTOR* pParallel,
-                XMVECTOR* pPerpendicular,
-                FXMVECTOR  V,
-                FXMVECTOR  Normal
-        ) noexcept
-{
-    assert(pParallel != nullptr);
-    assert(pPerpendicular != nullptr);
-
-    XMVECTOR Scale = XMVector3Dot(V, Normal);
-
-    XMVECTOR Parallel = XMVectorMultiply(Normal, Scale);
-
-    *pParallel = Parallel;
-    *pPerpendicular = XMVectorSubtract(V, Parallel);
-}
-
-//------------------------------------------------------------------------------
-// Transform a vector using a rotation expressed as a unit quaternion
-
-inline XMVECTOR XM_CALLCONV XMVector3Rotate
-        (
-                FXMVECTOR V,
-                FXMVECTOR RotationQuaternion
-        ) noexcept
-{
-    XMVECTOR A = XMVectorSelect(g_XMSelect1110.v, V, g_XMSelect1110.v);
-    XMVECTOR Q = XMQuaternionConjugate(RotationQuaternion);
-    XMVECTOR Result = XMQuaternionMultiply(Q, A);
-    return XMQuaternionMultiply(Result, RotationQuaternion);
-}
-
-//------------------------------------------------------------------------------
-// Transform a vector using the inverse of a rotation expressed as a unit quaternion
-
-inline XMVECTOR XM_CALLCONV XMVector3InverseRotate
-        (
-                FXMVECTOR V,
-                FXMVECTOR RotationQuaternion
-        ) noexcept
-{
-    XMVECTOR A = XMVectorSelect(g_XMSelect1110.v, V, g_XMSelect1110.v);
-    XMVECTOR Result = XMQuaternionMultiply(RotationQuaternion, A);
-    XMVECTOR Q = XMQuaternionConjugate(RotationQuaternion);
-    return XMQuaternionMultiply(Result, Q);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Transform
-        (
-                FXMVECTOR V,
-                FXMMATRIX M
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Z = XMVectorSplatZ(V);
-    XMVECTOR Y = XMVectorSplatY(V);
-    XMVECTOR X = XMVectorSplatX(V);
-
-    XMVECTOR Result = XMVectorMultiplyAdd(Z, M.r[2], M.r[3]);
-    Result = XMVectorMultiplyAdd(Y, M.r[1], Result);
-    Result = XMVectorMultiplyAdd(X, M.r[0], Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    XMVECTOR vResult = vmlaq_lane_f32(M.r[3], M.r[0], VL, 0); // X
-    vResult = vmlaq_lane_f32(vResult, M.r[1], VL, 1); // Y
-    return vmlaq_lane_f32(vResult, M.r[2], vget_high_f32(V), 0); // Z
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2)); // Z
-    vResult = XM_FMADD_PS(vResult, M.r[2], M.r[3]);
-    XMVECTOR vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1)); // Y
-    vResult = XM_FMADD_PS(vTemp, M.r[1], vResult);
-    vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0)); // X
-    vResult = XM_FMADD_PS(vTemp, M.r[0], vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015 26019, "PREfast noise: Esp:1307" )
-#endif
-
-    _Use_decl_annotations_
-inline XMFLOAT4* XM_CALLCONV XMVector3TransformStream
-        (
-                XMFLOAT4* pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT3* pInputStream,
-                size_t          InputStride,
-                size_t          VectorCount,
-                FXMMATRIX       M
-        ) noexcept
-{
-    assert(pOutputStream != nullptr);
-    assert(pInputStream != nullptr);
-
-    assert(InputStride >= sizeof(XMFLOAT3));
-    _Analysis_assume_(InputStride >= sizeof(XMFLOAT3));
-
-    assert(OutputStride >= sizeof(XMFLOAT4));
-    _Analysis_assume_(OutputStride >= sizeof(XMFLOAT4));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-    const XMVECTOR row3 = M.r[3];
-
-    for (size_t i = 0; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-        XMVECTOR Z = XMVectorSplatZ(V);
-        XMVECTOR Y = XMVectorSplatY(V);
-        XMVECTOR X = XMVectorSplatX(V);
-
-        XMVECTOR Result = XMVectorMultiplyAdd(Z, row2, row3);
-        Result = XMVectorMultiplyAdd(Y, row1, Result);
-        Result = XMVectorMultiplyAdd(X, row0, Result);
-
-        XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(pOutputVector), Result);
-
-        pInputVector += InputStride;
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-    const XMVECTOR row3 = M.r[3];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if ((InputStride == sizeof(XMFLOAT3)) && (OutputStride == sizeof(XMFLOAT4)))
-        {
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4x3_t V = vld3q_f32(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += sizeof(XMFLOAT3) * 4;
-
-                float32x2_t r3 = vget_low_f32(row3);
-                float32x2_t r = vget_low_f32(row0);
-                XMVECTOR vResult0 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), V.val[0], r, 0); // Ax+M
-                XMVECTOR vResult1 = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Bx+N
-
-                XM_PREFETCH(pInputVector);
-
-                r3 = vget_high_f32(row3);
-                r = vget_high_f32(row0);
-                XMVECTOR vResult2 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), V.val[0], r, 0); // Cx+O
-                XMVECTOR vResult3 = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Dx+P
-
-                XM_PREFETCH(pInputVector + XM_CACHE_LINE_SIZE);
-
-                r = vget_low_f32(row1);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[1], r, 0); // Ax+Ey+M
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[1], r, 1); // Bx+Fy+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 2));
-
-                r = vget_high_f32(row1);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[1], r, 0); // Cx+Gy+O
-                vResult3 = vmlaq_lane_f32(vResult3, V.val[1], r, 1); // Dx+Hy+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 3));
-
-                r = vget_low_f32(row2);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[2], r, 0); // Ax+Ey+Iz+M
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[2], r, 1); // Bx+Fy+Jz+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 4));
-
-                r = vget_high_f32(row2);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[2], r, 0); // Cx+Gy+Kz+O
-                vResult3 = vmlaq_lane_f32(vResult3, V.val[2], r, 1); // Dx+Hy+Lz+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 5));
-
-                float32x4x4_t R;
-                R.val[0] = vResult0;
-                R.val[1] = vResult1;
-                R.val[2] = vResult2;
-                R.val[3] = vResult3;
-
-                vst4q_f32(reinterpret_cast<float*>(pOutputVector), R);
-                pOutputVector += sizeof(XMFLOAT4) * 4;
-
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        float32x2_t VL = vld1_f32(reinterpret_cast<const float*>(pInputVector));
-        float32x2_t zero = vdup_n_f32(0);
-        float32x2_t VH = vld1_lane_f32(reinterpret_cast<const float*>(pInputVector) + 2, zero, 0);
-        pInputVector += InputStride;
-
-        XMVECTOR vResult = vmlaq_lane_f32(row3, row0, VL, 0); // X
-        vResult = vmlaq_lane_f32(vResult, row1, VL, 1); // Y
-        vResult = vmlaq_lane_f32(vResult, row2, VH, 0); // Z
-
-        vst1q_f32(reinterpret_cast<float*>(pOutputVector), vResult);
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-#elif defined(_XM_SSE_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-    const XMVECTOR row3 = M.r[3];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if (InputStride == sizeof(XMFLOAT3))
-        {
-            if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF))
-            {
-                // Packed input, aligned output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                    __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                    pInputVector += sizeof(XMFLOAT3) * 4;
-
-                    // Unpack the 4 vectors (.w components are junk)
-                    XM3UNPACK3INTO4(V1, L2, L3);
-
-                    // Result 1
-                    XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                    XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = XM_FMADD_PS(Z, row2, row3);
-                    XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-                    XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-                    XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 2
-                    Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, row2, row3);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-                    XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 3
-                    Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, row2, row3);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-                    XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 4
-                    Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, row2, row3);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-                    XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    i += 4;
-                }
-            }
-            else
-            {
-                // Packed input, unaligned output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                    __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                    pInputVector += sizeof(XMFLOAT3) * 4;
-
-                    // Unpack the 4 vectors (.w components are junk)
-                    XM3UNPACK3INTO4(V1, L2, L3);
-
-                    // Result 1
-                    XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                    XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = XM_FMADD_PS(Z, row2, row3);
-                    XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-                    XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 2
-                    Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, row2, row3);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 3
-                    Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, row2, row3);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 4
-                    Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, row2, row3);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    i += 4;
-                }
-            }
-        }
-    }
-
-    if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF))
-    {
-        // Aligned output
-        for (; i < VectorCount; ++i)
-        {
-            XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-            pInputVector += InputStride;
-
-            XMVECTOR Z = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-            XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = XM_FMADD_PS(Z, row2, row3);
-            XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-            XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-            vTemp = _mm_add_ps(vTemp, vTemp2);
-            vTemp = _mm_add_ps(vTemp, vTemp3);
-
-            XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
-            pOutputVector += OutputStride;
-        }
-    }
-    else
-    {
-        // Unaligned output
-        for (; i < VectorCount; ++i)
-        {
-            XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-            pInputVector += InputStride;
-
-            XMVECTOR Z = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-            XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-            XMVECTOR vTemp = XM_FMADD_PS(Z, row2, row3);
-            XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-            XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-            vTemp = _mm_add_ps(vTemp, vTemp2);
-            vTemp = _mm_add_ps(vTemp, vTemp3);
-
-            _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
-            pOutputVector += OutputStride;
-        }
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#endif
-}
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3TransformCoord
-        (
-                FXMVECTOR V,
-                FXMMATRIX M
-        ) noexcept
-{
-    XMVECTOR Z = XMVectorSplatZ(V);
-    XMVECTOR Y = XMVectorSplatY(V);
-    XMVECTOR X = XMVectorSplatX(V);
-
-    XMVECTOR Result = XMVectorMultiplyAdd(Z, M.r[2], M.r[3]);
-    Result = XMVectorMultiplyAdd(Y, M.r[1], Result);
-    Result = XMVectorMultiplyAdd(X, M.r[0], Result);
-
-    XMVECTOR W = XMVectorSplatW(Result);
-    return XMVectorDivide(Result, W);
-}
-
-//------------------------------------------------------------------------------
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015 26019, "PREfast noise: Esp:1307" )
-#endif
-
-    _Use_decl_annotations_
-inline XMFLOAT3* XM_CALLCONV XMVector3TransformCoordStream
-        (
-                XMFLOAT3* pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT3* pInputStream,
-                size_t          InputStride,
-                size_t          VectorCount,
-                FXMMATRIX       M
-        ) noexcept
-{
-    assert(pOutputStream != nullptr);
-    assert(pInputStream != nullptr);
-
-    assert(InputStride >= sizeof(XMFLOAT3));
-    _Analysis_assume_(InputStride >= sizeof(XMFLOAT3));
-
-    assert(OutputStride >= sizeof(XMFLOAT3));
-    _Analysis_assume_(OutputStride >= sizeof(XMFLOAT3));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-    const XMVECTOR row3 = M.r[3];
-
-    for (size_t i = 0; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-        XMVECTOR Z = XMVectorSplatZ(V);
-        XMVECTOR Y = XMVectorSplatY(V);
-        XMVECTOR X = XMVectorSplatX(V);
-
-        XMVECTOR Result = XMVectorMultiplyAdd(Z, row2, row3);
-        Result = XMVectorMultiplyAdd(Y, row1, Result);
-        Result = XMVectorMultiplyAdd(X, row0, Result);
-
-        XMVECTOR W = XMVectorSplatW(Result);
-
-        Result = XMVectorDivide(Result, W);
-
-        XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), Result);
-
-        pInputVector += InputStride;
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-    const XMVECTOR row3 = M.r[3];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if ((InputStride == sizeof(XMFLOAT3)) && (OutputStride == sizeof(XMFLOAT3)))
-        {
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4x3_t V = vld3q_f32(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += sizeof(XMFLOAT3) * 4;
-
-                float32x2_t r3 = vget_low_f32(row3);
-                float32x2_t r = vget_low_f32(row0);
-                XMVECTOR vResult0 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), V.val[0], r, 0); // Ax+M
-                XMVECTOR vResult1 = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Bx+N
-
-                XM_PREFETCH(pInputVector);
-
-                r3 = vget_high_f32(row3);
-                r = vget_high_f32(row0);
-                XMVECTOR vResult2 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), V.val[0], r, 0); // Cx+O
-                XMVECTOR W = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Dx+P
-
-                XM_PREFETCH(pInputVector + XM_CACHE_LINE_SIZE);
-
-                r = vget_low_f32(row1);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[1], r, 0); // Ax+Ey+M
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[1], r, 1); // Bx+Fy+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 2));
-
-                r = vget_high_f32(row1);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[1], r, 0); // Cx+Gy+O
-                W = vmlaq_lane_f32(W, V.val[1], r, 1); // Dx+Hy+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 3));
-
-                r = vget_low_f32(row2);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[2], r, 0); // Ax+Ey+Iz+M
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[2], r, 1); // Bx+Fy+Jz+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 4));
-
-                r = vget_high_f32(row2);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[2], r, 0); // Cx+Gy+Kz+O
-                W = vmlaq_lane_f32(W, V.val[2], r, 1); // Dx+Hy+Lz+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 5));
-
-#if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-                V.val[0] = vdivq_f32(vResult0, W);
-                V.val[1] = vdivq_f32(vResult1, W);
-                V.val[2] = vdivq_f32(vResult2, W);
-#else
-                // 2 iterations of Newton-Raphson refinement of reciprocal
-                float32x4_t Reciprocal = vrecpeq_f32(W);
-                float32x4_t S = vrecpsq_f32(Reciprocal, W);
-                Reciprocal = vmulq_f32(S, Reciprocal);
-                S = vrecpsq_f32(Reciprocal, W);
-                Reciprocal = vmulq_f32(S, Reciprocal);
-
-                V.val[0] = vmulq_f32(vResult0, Reciprocal);
-                V.val[1] = vmulq_f32(vResult1, Reciprocal);
-                V.val[2] = vmulq_f32(vResult2, Reciprocal);
-#endif
-
-                vst3q_f32(reinterpret_cast<float*>(pOutputVector), V);
-                pOutputVector += sizeof(XMFLOAT3) * 4;
-
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        float32x2_t VL = vld1_f32(reinterpret_cast<const float*>(pInputVector));
-        float32x2_t zero = vdup_n_f32(0);
-        float32x2_t VH = vld1_lane_f32(reinterpret_cast<const float*>(pInputVector) + 2, zero, 0);
-        pInputVector += InputStride;
-
-        XMVECTOR vResult = vmlaq_lane_f32(row3, row0, VL, 0); // X
-        vResult = vmlaq_lane_f32(vResult, row1, VL, 1); // Y
-        vResult = vmlaq_lane_f32(vResult, row2, VH, 0); // Z
-
-        VH = vget_high_f32(vResult);
-        XMVECTOR W = vdupq_lane_f32(VH, 1);
-
-#if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-        vResult = vdivq_f32(vResult, W);
-#else
-        // 2 iterations of Newton-Raphson refinement of reciprocal for W
-        float32x4_t Reciprocal = vrecpeq_f32(W);
-        float32x4_t S = vrecpsq_f32(Reciprocal, W);
-        Reciprocal = vmulq_f32(S, Reciprocal);
-        S = vrecpsq_f32(Reciprocal, W);
-        Reciprocal = vmulq_f32(S, Reciprocal);
-
-        vResult = vmulq_f32(vResult, Reciprocal);
-#endif
-
-        VL = vget_low_f32(vResult);
-        vst1_f32(reinterpret_cast<float*>(pOutputVector), VL);
-        vst1q_lane_f32(reinterpret_cast<float*>(pOutputVector) + 2, vResult, 2);
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-#elif defined(_XM_SSE_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-    const XMVECTOR row3 = M.r[3];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if (InputStride == sizeof(XMFLOAT3))
-        {
-            if (OutputStride == sizeof(XMFLOAT3))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                        __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                        pInputVector += sizeof(XMFLOAT3) * 4;
-
-                        // Unpack the 4 vectors (.w components are junk)
-                        XM3UNPACK3INTO4(V1, L2, L3);
-
-                        // Result 1
-                        XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                        XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = XM_FMADD_PS(Z, row2, row3);
-                        XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-                        XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        V1 = _mm_div_ps(vTemp, W);
-
-                        // Result 2
-                        Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, row2, row3);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        V2 = _mm_div_ps(vTemp, W);
-
-                        // Result 3
-                        Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, row2, row3);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        V3 = _mm_div_ps(vTemp, W);
-
-                        // Result 4
-                        Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, row2, row3);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        V4 = _mm_div_ps(vTemp, W);
-
-                        // Pack and store the vectors
-                        XM3PACK4INTO3(vTemp);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), V1);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector + 16), vTemp);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector + 32), V3);
-                        pOutputVector += sizeof(XMFLOAT3) * 4;
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, unaligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                        __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                        pInputVector += sizeof(XMFLOAT3) * 4;
-
-                        // Unpack the 4 vectors (.w components are junk)
-                        XM3UNPACK3INTO4(V1, L2, L3);
-
-                        // Result 1
-                        XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                        XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = XM_FMADD_PS(Z, row2, row3);
-                        XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-                        XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        V1 = _mm_div_ps(vTemp, W);
-
-                        // Result 2
-                        Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, row2, row3);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        V2 = _mm_div_ps(vTemp, W);
-
-                        // Result 3
-                        Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, row2, row3);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        V3 = _mm_div_ps(vTemp, W);
-
-                        // Result 4
-                        Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, row2, row3);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        V4 = _mm_div_ps(vTemp, W);
-
-                        // Pack and store the vectors
-                        XM3PACK4INTO3(vTemp);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), V1);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector + 16), vTemp);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector + 32), V3);
-                        pOutputVector += sizeof(XMFLOAT3) * 4;
-                        i += 4;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                    __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                    pInputVector += sizeof(XMFLOAT3) * 4;
-
-                    // Unpack the 4 vectors (.w components are junk)
-                    XM3UNPACK3INTO4(V1, L2, L3);
-
-                    // Result 1
-                    XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                    XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = XM_FMADD_PS(Z, row2, row3);
-                    XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-                    XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                    vTemp = _mm_div_ps(vTemp, W);
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 2
-                    Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, row2, row3);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                    vTemp = _mm_div_ps(vTemp, W);
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 3
-                    Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, row2, row3);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                    vTemp = _mm_div_ps(vTemp, W);
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 4
-                    Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, row2, row3);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-                    vTemp = _mm_div_ps(vTemp, W);
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    i += 4;
-                }
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-        pInputVector += InputStride;
-
-        XMVECTOR Z = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-        XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-        XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-        XMVECTOR vTemp = XM_FMADD_PS(Z, row2, row3);
-        XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-        XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-        vTemp = _mm_add_ps(vTemp, vTemp2);
-        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-
-        vTemp = _mm_div_ps(vTemp, W);
-
-        XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-        pOutputVector += OutputStride;
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#endif
-}
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3TransformNormal
-        (
-                FXMVECTOR V,
-                FXMMATRIX M
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Z = XMVectorSplatZ(V);
-    XMVECTOR Y = XMVectorSplatY(V);
-    XMVECTOR X = XMVectorSplatX(V);
-
-    XMVECTOR Result = XMVectorMultiply(Z, M.r[2]);
-    Result = XMVectorMultiplyAdd(Y, M.r[1], Result);
-    Result = XMVectorMultiplyAdd(X, M.r[0], Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    XMVECTOR vResult = vmulq_lane_f32(M.r[0], VL, 0); // X
-    vResult = vmlaq_lane_f32(vResult, M.r[1], VL, 1); // Y
-    return vmlaq_lane_f32(vResult, M.r[2], vget_high_f32(V), 0); // Z
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2)); // Z
-    vResult = _mm_mul_ps(vResult, M.r[2]);
-    XMVECTOR vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1)); // Y
-    vResult = XM_FMADD_PS(vTemp, M.r[1], vResult);
-    vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0)); // X
-    vResult = XM_FMADD_PS(vTemp, M.r[0], vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015 26019, "PREfast noise: Esp:1307" )
-#endif
-
-    _Use_decl_annotations_
-inline XMFLOAT3* XM_CALLCONV XMVector3TransformNormalStream
-        (
-                XMFLOAT3* pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT3* pInputStream,
-                size_t          InputStride,
-                size_t          VectorCount,
-                FXMMATRIX       M
-        ) noexcept
-{
-    assert(pOutputStream != nullptr);
-    assert(pInputStream != nullptr);
-
-    assert(InputStride >= sizeof(XMFLOAT3));
-    _Analysis_assume_(InputStride >= sizeof(XMFLOAT3));
-
-    assert(OutputStride >= sizeof(XMFLOAT3));
-    _Analysis_assume_(OutputStride >= sizeof(XMFLOAT3));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-
-    for (size_t i = 0; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-        XMVECTOR Z = XMVectorSplatZ(V);
-        XMVECTOR Y = XMVectorSplatY(V);
-        XMVECTOR X = XMVectorSplatX(V);
-
-        XMVECTOR Result = XMVectorMultiply(Z, row2);
-        Result = XMVectorMultiplyAdd(Y, row1, Result);
-        Result = XMVectorMultiplyAdd(X, row0, Result);
-
-        XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), Result);
-
-        pInputVector += InputStride;
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if ((InputStride == sizeof(XMFLOAT3)) && (OutputStride == sizeof(XMFLOAT3)))
-        {
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4x3_t V = vld3q_f32(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += sizeof(XMFLOAT3) * 4;
-
-                float32x2_t r = vget_low_f32(row0);
-                XMVECTOR vResult0 = vmulq_lane_f32(V.val[0], r, 0); // Ax
-                XMVECTOR vResult1 = vmulq_lane_f32(V.val[0], r, 1); // Bx
-
-                XM_PREFETCH(pInputVector);
-
-                r = vget_high_f32(row0);
-                XMVECTOR vResult2 = vmulq_lane_f32(V.val[0], r, 0); // Cx
-
-                XM_PREFETCH(pInputVector + XM_CACHE_LINE_SIZE);
-
-                r = vget_low_f32(row1);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[1], r, 0); // Ax+Ey
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[1], r, 1); // Bx+Fy
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 2));
-
-                r = vget_high_f32(row1);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[1], r, 0); // Cx+Gy
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 3));
-
-                r = vget_low_f32(row2);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[2], r, 0); // Ax+Ey+Iz
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[2], r, 1); // Bx+Fy+Jz
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 4));
-
-                r = vget_high_f32(row2);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[2], r, 0); // Cx+Gy+Kz
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 5));
-
-                V.val[0] = vResult0;
-                V.val[1] = vResult1;
-                V.val[2] = vResult2;
-
-                vst3q_f32(reinterpret_cast<float*>(pOutputVector), V);
-                pOutputVector += sizeof(XMFLOAT3) * 4;
-
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        float32x2_t VL = vld1_f32(reinterpret_cast<const float*>(pInputVector));
-        float32x2_t zero = vdup_n_f32(0);
-        float32x2_t VH = vld1_lane_f32(reinterpret_cast<const float*>(pInputVector) + 2, zero, 0);
-        pInputVector += InputStride;
-
-        XMVECTOR vResult = vmulq_lane_f32(row0, VL, 0); // X
-        vResult = vmlaq_lane_f32(vResult, row1, VL, 1); // Y
-        vResult = vmlaq_lane_f32(vResult, row2, VH, 0); // Z
-
-        VL = vget_low_f32(vResult);
-        vst1_f32(reinterpret_cast<float*>(pOutputVector), VL);
-        vst1q_lane_f32(reinterpret_cast<float*>(pOutputVector) + 2, vResult, 2);
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-#elif defined(_XM_SSE_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if (InputStride == sizeof(XMFLOAT3))
-        {
-            if (OutputStride == sizeof(XMFLOAT3))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                        __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                        pInputVector += sizeof(XMFLOAT3) * 4;
-
-                        // Unpack the 4 vectors (.w components are junk)
-                        XM3UNPACK3INTO4(V1, L2, L3);
-
-                        // Result 1
-                        XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                        XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = _mm_mul_ps(Z, row2);
-                        XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-                        XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        V1 = _mm_add_ps(vTemp, vTemp3);
-
-                        // Result 2
-                        Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = _mm_mul_ps(Z, row2);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        V2 = _mm_add_ps(vTemp, vTemp3);
-
-                        // Result 3
-                        Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = _mm_mul_ps(Z, row2);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        V3 = _mm_add_ps(vTemp, vTemp3);
-
-                        // Result 4
-                        Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = _mm_mul_ps(Z, row2);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        V4 = _mm_add_ps(vTemp, vTemp3);
-
-                        // Pack and store the vectors
-                        XM3PACK4INTO3(vTemp);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), V1);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector + 16), vTemp);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector + 32), V3);
-                        pOutputVector += sizeof(XMFLOAT3) * 4;
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, unaligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                        __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                        pInputVector += sizeof(XMFLOAT3) * 4;
-
-                        // Unpack the 4 vectors (.w components are junk)
-                        XM3UNPACK3INTO4(V1, L2, L3);
-
-                        // Result 1
-                        XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                        XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = _mm_mul_ps(Z, row2);
-                        XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-                        XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        V1 = _mm_add_ps(vTemp, vTemp3);
-
-                        // Result 2
-                        Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = _mm_mul_ps(Z, row2);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        V2 = _mm_add_ps(vTemp, vTemp3);
-
-                        // Result 3
-                        Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = _mm_mul_ps(Z, row2);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        V3 = _mm_add_ps(vTemp, vTemp3);
-
-                        // Result 4
-                        Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = _mm_mul_ps(Z, row2);
-                        vTemp2 = _mm_mul_ps(Y, row1);
-                        vTemp3 = _mm_mul_ps(X, row0);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        V4 = _mm_add_ps(vTemp, vTemp3);
-
-                        // Pack and store the vectors
-                        XM3PACK4INTO3(vTemp);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), V1);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector + 16), vTemp);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector + 32), V3);
-                        pOutputVector += sizeof(XMFLOAT3) * 4;
-                        i += 4;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                    __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                    pInputVector += sizeof(XMFLOAT3) * 4;
-
-                    // Unpack the 4 vectors (.w components are junk)
-                    XM3UNPACK3INTO4(V1, L2, L3);
-
-                    // Result 1
-                    XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                    XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = _mm_mul_ps(Z, row2);
-                    XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-                    XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 2
-                    Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = _mm_mul_ps(Z, row2);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 3
-                    Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = _mm_mul_ps(Z, row2);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 4
-                    Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = _mm_mul_ps(Z, row2);
-                    vTemp2 = _mm_mul_ps(Y, row1);
-                    vTemp3 = _mm_mul_ps(X, row0);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    i += 4;
-                }
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-        pInputVector += InputStride;
-
-        XMVECTOR Z = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-        XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-        XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-        XMVECTOR vTemp = _mm_mul_ps(Z, row2);
-        XMVECTOR vTemp2 = _mm_mul_ps(Y, row1);
-        XMVECTOR vTemp3 = _mm_mul_ps(X, row0);
-        vTemp = _mm_add_ps(vTemp, vTemp2);
-        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-        XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-        pOutputVector += OutputStride;
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#endif
-}
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Project
-        (
-                FXMVECTOR V,
-                float    ViewportX,
-                float    ViewportY,
-                float    ViewportWidth,
-                float    ViewportHeight,
-                float    ViewportMinZ,
-                float    ViewportMaxZ,
-                FXMMATRIX Projection,
-                CXMMATRIX View,
-                CXMMATRIX World
-        ) noexcept
-{
-    const float HalfViewportWidth = ViewportWidth * 0.5f;
-    const float HalfViewportHeight = ViewportHeight * 0.5f;
-
-    XMVECTOR Scale = XMVectorSet(HalfViewportWidth, -HalfViewportHeight, ViewportMaxZ - ViewportMinZ, 0.0f);
-    XMVECTOR Offset = XMVectorSet(ViewportX + HalfViewportWidth, ViewportY + HalfViewportHeight, ViewportMinZ, 0.0f);
-
-    XMMATRIX Transform = XMMatrixMultiply(World, View);
-    Transform = XMMatrixMultiply(Transform, Projection);
-
-    XMVECTOR Result = XMVector3TransformCoord(V, Transform);
-
-    Result = XMVectorMultiplyAdd(Result, Scale, Offset);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015 26019, "PREfast noise: Esp:1307" )
-#endif
-
-    _Use_decl_annotations_
-inline XMFLOAT3* XM_CALLCONV XMVector3ProjectStream
-        (
-                XMFLOAT3* pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT3* pInputStream,
-                size_t          InputStride,
-                size_t          VectorCount,
-                float           ViewportX,
-                float           ViewportY,
-                float           ViewportWidth,
-                float           ViewportHeight,
-                float           ViewportMinZ,
-                float           ViewportMaxZ,
-                FXMMATRIX     Projection,
-                CXMMATRIX     View,
-                CXMMATRIX     World
-        ) noexcept
-{
-    assert(pOutputStream != nullptr);
-    assert(pInputStream != nullptr);
-
-    assert(InputStride >= sizeof(XMFLOAT3));
-    _Analysis_assume_(InputStride >= sizeof(XMFLOAT3));
-
-    assert(OutputStride >= sizeof(XMFLOAT3));
-    _Analysis_assume_(OutputStride >= sizeof(XMFLOAT3));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    const float HalfViewportWidth = ViewportWidth * 0.5f;
-    const float HalfViewportHeight = ViewportHeight * 0.5f;
-
-    XMVECTOR Scale = XMVectorSet(HalfViewportWidth, -HalfViewportHeight, ViewportMaxZ - ViewportMinZ, 1.0f);
-    XMVECTOR Offset = XMVectorSet(ViewportX + HalfViewportWidth, ViewportY + HalfViewportHeight, ViewportMinZ, 0.0f);
-
-    XMMATRIX Transform = XMMatrixMultiply(World, View);
-    Transform = XMMatrixMultiply(Transform, Projection);
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    for (size_t i = 0; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-
-        XMVECTOR Result = XMVector3TransformCoord(V, Transform);
-        Result = XMVectorMultiplyAdd(Result, Scale, Offset);
-
-        XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), Result);
-
-        pInputVector += InputStride;
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    const float HalfViewportWidth = ViewportWidth * 0.5f;
-    const float HalfViewportHeight = ViewportHeight * 0.5f;
-
-    XMMATRIX Transform = XMMatrixMultiply(World, View);
-    Transform = XMMatrixMultiply(Transform, Projection);
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if ((InputStride == sizeof(XMFLOAT3)) && (OutputStride == sizeof(XMFLOAT3)))
-        {
-            XMVECTOR ScaleX = vdupq_n_f32(HalfViewportWidth);
-            XMVECTOR ScaleY = vdupq_n_f32(-HalfViewportHeight);
-            XMVECTOR ScaleZ = vdupq_n_f32(ViewportMaxZ - ViewportMinZ);
-
-            XMVECTOR OffsetX = vdupq_n_f32(ViewportX + HalfViewportWidth);
-            XMVECTOR OffsetY = vdupq_n_f32(ViewportY + HalfViewportHeight);
-            XMVECTOR OffsetZ = vdupq_n_f32(ViewportMinZ);
-
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4x3_t V = vld3q_f32(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += sizeof(XMFLOAT3) * 4;
-
-                float32x2_t r3 = vget_low_f32(Transform.r[3]);
-                float32x2_t r = vget_low_f32(Transform.r[0]);
-                XMVECTOR vResult0 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), V.val[0], r, 0); // Ax+M
-                XMVECTOR vResult1 = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Bx+N
-
-                XM_PREFETCH(pInputVector);
-
-                r3 = vget_high_f32(Transform.r[3]);
-                r = vget_high_f32(Transform.r[0]);
-                XMVECTOR vResult2 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), V.val[0], r, 0); // Cx+O
-                XMVECTOR W = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), V.val[0], r, 1); // Dx+P
-
-                XM_PREFETCH(pInputVector + XM_CACHE_LINE_SIZE);
-
-                r = vget_low_f32(Transform.r[1]);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[1], r, 0); // Ax+Ey+M
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[1], r, 1); // Bx+Fy+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 2));
-
-                r = vget_high_f32(Transform.r[1]);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[1], r, 0); // Cx+Gy+O
-                W = vmlaq_lane_f32(W, V.val[1], r, 1); // Dx+Hy+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 3));
-
-                r = vget_low_f32(Transform.r[2]);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[2], r, 0); // Ax+Ey+Iz+M
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[2], r, 1); // Bx+Fy+Jz+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 4));
-
-                r = vget_high_f32(Transform.r[2]);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[2], r, 0); // Cx+Gy+Kz+O
-                W = vmlaq_lane_f32(W, V.val[2], r, 1); // Dx+Hy+Lz+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 5));
-
-#if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-                vResult0 = vdivq_f32(vResult0, W);
-                vResult1 = vdivq_f32(vResult1, W);
-                vResult2 = vdivq_f32(vResult2, W);
-#else
-                // 2 iterations of Newton-Raphson refinement of reciprocal
-                float32x4_t Reciprocal = vrecpeq_f32(W);
-                float32x4_t S = vrecpsq_f32(Reciprocal, W);
-                Reciprocal = vmulq_f32(S, Reciprocal);
-                S = vrecpsq_f32(Reciprocal, W);
-                Reciprocal = vmulq_f32(S, Reciprocal);
-
-                vResult0 = vmulq_f32(vResult0, Reciprocal);
-                vResult1 = vmulq_f32(vResult1, Reciprocal);
-                vResult2 = vmulq_f32(vResult2, Reciprocal);
-#endif
-
-                V.val[0] = vmlaq_f32(OffsetX, vResult0, ScaleX);
-                V.val[1] = vmlaq_f32(OffsetY, vResult1, ScaleY);
-                V.val[2] = vmlaq_f32(OffsetZ, vResult2, ScaleZ);
-
-                vst3q_f32(reinterpret_cast<float*>(pOutputVector), V);
-                pOutputVector += sizeof(XMFLOAT3) * 4;
-
-                i += 4;
-            }
-        }
-    }
-
-    if (i < VectorCount)
-    {
-        XMVECTOR Scale = XMVectorSet(HalfViewportWidth, -HalfViewportHeight, ViewportMaxZ - ViewportMinZ, 1.0f);
-        XMVECTOR Offset = XMVectorSet(ViewportX + HalfViewportWidth, ViewportY + HalfViewportHeight, ViewportMinZ, 0.0f);
-
-        for (; i < VectorCount; i++)
-        {
-            float32x2_t VL = vld1_f32(reinterpret_cast<const float*>(pInputVector));
-            float32x2_t zero = vdup_n_f32(0);
-            float32x2_t VH = vld1_lane_f32(reinterpret_cast<const float*>(pInputVector) + 2, zero, 0);
-            pInputVector += InputStride;
-
-            XMVECTOR vResult = vmlaq_lane_f32(Transform.r[3], Transform.r[0], VL, 0); // X
-            vResult = vmlaq_lane_f32(vResult, Transform.r[1], VL, 1); // Y
-            vResult = vmlaq_lane_f32(vResult, Transform.r[2], VH, 0); // Z
-
-            VH = vget_high_f32(vResult);
-            XMVECTOR W = vdupq_lane_f32(VH, 1);
-
-#if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-            vResult = vdivq_f32(vResult, W);
-#else
-            // 2 iterations of Newton-Raphson refinement of reciprocal for W
-            float32x4_t Reciprocal = vrecpeq_f32(W);
-            float32x4_t S = vrecpsq_f32(Reciprocal, W);
-            Reciprocal = vmulq_f32(S, Reciprocal);
-            S = vrecpsq_f32(Reciprocal, W);
-            Reciprocal = vmulq_f32(S, Reciprocal);
-
-            vResult = vmulq_f32(vResult, Reciprocal);
-#endif
-
-            vResult = vmlaq_f32(Offset, vResult, Scale);
-
-            VL = vget_low_f32(vResult);
-            vst1_f32(reinterpret_cast<float*>(pOutputVector), VL);
-            vst1q_lane_f32(reinterpret_cast<float*>(pOutputVector) + 2, vResult, 2);
-            pOutputVector += OutputStride;
-        }
-    }
-
-    return pOutputStream;
-#elif defined(_XM_SSE_INTRINSICS_)
-    const float HalfViewportWidth = ViewportWidth * 0.5f;
-    const float HalfViewportHeight = ViewportHeight * 0.5f;
-
-    XMVECTOR Scale = XMVectorSet(HalfViewportWidth, -HalfViewportHeight, ViewportMaxZ - ViewportMinZ, 1.0f);
-    XMVECTOR Offset = XMVectorSet(ViewportX + HalfViewportWidth, ViewportY + HalfViewportHeight, ViewportMinZ, 0.0f);
-
-    XMMATRIX Transform = XMMatrixMultiply(World, View);
-    Transform = XMMatrixMultiply(Transform, Projection);
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if (InputStride == sizeof(XMFLOAT3))
-        {
-            if (OutputStride == sizeof(XMFLOAT3))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                        __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                        pInputVector += sizeof(XMFLOAT3) * 4;
-
-                        // Unpack the 4 vectors (.w components are junk)
-                        XM3UNPACK3INTO4(V1, L2, L3);
-
-                        // Result 1
-                        XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                        XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        XMVECTOR vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        XMVECTOR vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTemp = _mm_div_ps(vTemp, W);
-                        V1 = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                        // Result 2
-                        Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTemp = _mm_div_ps(vTemp, W);
-                        V2 = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                        // Result 3
-                        Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTemp = _mm_div_ps(vTemp, W);
-                        V3 = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                        // Result 4
-                        Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTemp = _mm_div_ps(vTemp, W);
-                        V4 = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                        // Pack and store the vectors
-                        XM3PACK4INTO3(vTemp);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), V1);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector + 16), vTemp);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector + 32), V3);
-                        pOutputVector += sizeof(XMFLOAT3) * 4;
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, unaligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                        __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                        pInputVector += sizeof(XMFLOAT3) * 4;
-
-                        // Unpack the 4 vectors (.w components are junk)
-                        XM3UNPACK3INTO4(V1, L2, L3);
-
-                        // Result 1
-                        XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                        XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        XMVECTOR vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        XMVECTOR vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTemp = _mm_div_ps(vTemp, W);
-                        V1 = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                        // Result 2
-                        Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTemp = _mm_div_ps(vTemp, W);
-                        V2 = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                        // Result 3
-                        Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTemp = _mm_div_ps(vTemp, W);
-                        V3 = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                        // Result 4
-                        Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        vTemp = _mm_div_ps(vTemp, W);
-                        V4 = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                        // Pack and store the vectors
-                        XM3PACK4INTO3(vTemp);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), V1);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector + 16), vTemp);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector + 32), V3);
-                        pOutputVector += sizeof(XMFLOAT3) * 4;
-                        i += 4;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                    __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                    pInputVector += sizeof(XMFLOAT3) * 4;
-
-                    // Unpack the 4 vectors (.w components are junk)
-                    XM3UNPACK3INTO4(V1, L2, L3);
-
-                    // Result 1
-                    XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                    XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                    XMVECTOR vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                    XMVECTOR vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTemp = _mm_div_ps(vTemp, W);
-                    vTemp = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 2
-                    Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                    vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                    vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTemp = _mm_div_ps(vTemp, W);
-                    vTemp = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 3
-                    Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                    vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                    vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTemp = _mm_div_ps(vTemp, W);
-                    vTemp = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 4
-                    Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                    vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                    vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTemp = _mm_div_ps(vTemp, W);
-                    vTemp = XM_FMADD_PS(vTemp, Scale, Offset);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    i += 4;
-                }
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-        pInputVector += InputStride;
-
-        XMVECTOR Z = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-        XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-        XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-        XMVECTOR vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-        XMVECTOR vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-        XMVECTOR vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-        vTemp = _mm_add_ps(vTemp, vTemp2);
-        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-        vTemp = _mm_div_ps(vTemp, W);
-        vTemp = XM_FMADD_PS(vTemp, Scale, Offset);
-
-        XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-        pOutputVector += OutputStride;
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#endif
-}
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector3Unproject
-        (
-                FXMVECTOR V,
-                float     ViewportX,
-                float     ViewportY,
-                float     ViewportWidth,
-                float     ViewportHeight,
-                float     ViewportMinZ,
-                float     ViewportMaxZ,
-                FXMMATRIX Projection,
-                CXMMATRIX View,
-                CXMMATRIX World
-        ) noexcept
-{
-    static const XMVECTORF32 D = { { { -1.0f, 1.0f, 0.0f, 0.0f } } };
-
-    XMVECTOR Scale = XMVectorSet(ViewportWidth * 0.5f, -ViewportHeight * 0.5f, ViewportMaxZ - ViewportMinZ, 1.0f);
-    Scale = XMVectorReciprocal(Scale);
-
-    XMVECTOR Offset = XMVectorSet(-ViewportX, -ViewportY, -ViewportMinZ, 0.0f);
-    Offset = XMVectorMultiplyAdd(Scale, Offset, D.v);
-
-    XMMATRIX Transform = XMMatrixMultiply(World, View);
-    Transform = XMMatrixMultiply(Transform, Projection);
-    Transform = XMMatrixInverse(nullptr, Transform);
-
-    XMVECTOR Result = XMVectorMultiplyAdd(V, Scale, Offset);
-
-    return XMVector3TransformCoord(Result, Transform);
-}
-
-//------------------------------------------------------------------------------
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015 26019, "PREfast noise: Esp:1307" )
-#endif
-
-    _Use_decl_annotations_
-inline XMFLOAT3* XM_CALLCONV XMVector3UnprojectStream
-        (
-                XMFLOAT3* pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT3* pInputStream,
-                size_t          InputStride,
-                size_t          VectorCount,
-                float           ViewportX,
-                float           ViewportY,
-                float           ViewportWidth,
-                float           ViewportHeight,
-                float           ViewportMinZ,
-                float           ViewportMaxZ,
-                FXMMATRIX       Projection,
-                CXMMATRIX       View,
-                CXMMATRIX       World
-        ) noexcept
-{
-    assert(pOutputStream != nullptr);
-    assert(pInputStream != nullptr);
-
-    assert(InputStride >= sizeof(XMFLOAT3));
-    _Analysis_assume_(InputStride >= sizeof(XMFLOAT3));
-
-    assert(OutputStride >= sizeof(XMFLOAT3));
-    _Analysis_assume_(OutputStride >= sizeof(XMFLOAT3));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    static const XMVECTORF32 D = { { { -1.0f, 1.0f, 0.0f, 0.0f } } };
-
-    XMVECTOR Scale = XMVectorSet(ViewportWidth * 0.5f, -ViewportHeight * 0.5f, ViewportMaxZ - ViewportMinZ, 1.0f);
-    Scale = XMVectorReciprocal(Scale);
-
-    XMVECTOR Offset = XMVectorSet(-ViewportX, -ViewportY, -ViewportMinZ, 0.0f);
-    Offset = XMVectorMultiplyAdd(Scale, Offset, D.v);
-
-    XMMATRIX Transform = XMMatrixMultiply(World, View);
-    Transform = XMMatrixMultiply(Transform, Projection);
-    Transform = XMMatrixInverse(nullptr, Transform);
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    for (size_t i = 0; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-
-        XMVECTOR Result = XMVectorMultiplyAdd(V, Scale, Offset);
-
-        Result = XMVector3TransformCoord(Result, Transform);
-
-        XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), Result);
-
-        pInputVector += InputStride;
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMMATRIX Transform = XMMatrixMultiply(World, View);
-    Transform = XMMatrixMultiply(Transform, Projection);
-    Transform = XMMatrixInverse(nullptr, Transform);
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    float sx = 1.f / (ViewportWidth * 0.5f);
-    float sy = 1.f / (-ViewportHeight * 0.5f);
-    float sz = 1.f / (ViewportMaxZ - ViewportMinZ);
-
-    float ox = (-ViewportX * sx) - 1.f;
-    float oy = (-ViewportY * sy) + 1.f;
-    float oz = (-ViewportMinZ * sz);
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if ((InputStride == sizeof(XMFLOAT3)) && (OutputStride == sizeof(XMFLOAT3)))
-        {
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4x3_t V = vld3q_f32(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += sizeof(XMFLOAT3) * 4;
-
-                XMVECTOR ScaleX = vdupq_n_f32(sx);
-                XMVECTOR OffsetX = vdupq_n_f32(ox);
-                XMVECTOR VX = vmlaq_f32(OffsetX, ScaleX, V.val[0]);
-
-                float32x2_t r3 = vget_low_f32(Transform.r[3]);
-                float32x2_t r = vget_low_f32(Transform.r[0]);
-                XMVECTOR vResult0 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), VX, r, 0); // Ax+M
-                XMVECTOR vResult1 = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), VX, r, 1); // Bx+N
-
-                XM_PREFETCH(pInputVector);
-
-                r3 = vget_high_f32(Transform.r[3]);
-                r = vget_high_f32(Transform.r[0]);
-                XMVECTOR vResult2 = vmlaq_lane_f32(vdupq_lane_f32(r3, 0), VX, r, 0); // Cx+O
-                XMVECTOR W = vmlaq_lane_f32(vdupq_lane_f32(r3, 1), VX, r, 1); // Dx+P
-
-                XM_PREFETCH(pInputVector + XM_CACHE_LINE_SIZE);
-
-                XMVECTOR ScaleY = vdupq_n_f32(sy);
-                XMVECTOR OffsetY = vdupq_n_f32(oy);
-                XMVECTOR VY = vmlaq_f32(OffsetY, ScaleY, V.val[1]);
-
-                r = vget_low_f32(Transform.r[1]);
-                vResult0 = vmlaq_lane_f32(vResult0, VY, r, 0); // Ax+Ey+M
-                vResult1 = vmlaq_lane_f32(vResult1, VY, r, 1); // Bx+Fy+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 2));
-
-                r = vget_high_f32(Transform.r[1]);
-                vResult2 = vmlaq_lane_f32(vResult2, VY, r, 0); // Cx+Gy+O
-                W = vmlaq_lane_f32(W, VY, r, 1); // Dx+Hy+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 3));
-
-                XMVECTOR ScaleZ = vdupq_n_f32(sz);
-                XMVECTOR OffsetZ = vdupq_n_f32(oz);
-                XMVECTOR VZ = vmlaq_f32(OffsetZ, ScaleZ, V.val[2]);
-
-                r = vget_low_f32(Transform.r[2]);
-                vResult0 = vmlaq_lane_f32(vResult0, VZ, r, 0); // Ax+Ey+Iz+M
-                vResult1 = vmlaq_lane_f32(vResult1, VZ, r, 1); // Bx+Fy+Jz+N
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 4));
-
-                r = vget_high_f32(Transform.r[2]);
-                vResult2 = vmlaq_lane_f32(vResult2, VZ, r, 0); // Cx+Gy+Kz+O
-                W = vmlaq_lane_f32(W, VZ, r, 1); // Dx+Hy+Lz+P
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 5));
-
-#if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-                V.val[0] = vdivq_f32(vResult0, W);
-                V.val[1] = vdivq_f32(vResult1, W);
-                V.val[2] = vdivq_f32(vResult2, W);
-#else
-                // 2 iterations of Newton-Raphson refinement of reciprocal
-                float32x4_t Reciprocal = vrecpeq_f32(W);
-                float32x4_t S = vrecpsq_f32(Reciprocal, W);
-                Reciprocal = vmulq_f32(S, Reciprocal);
-                S = vrecpsq_f32(Reciprocal, W);
-                Reciprocal = vmulq_f32(S, Reciprocal);
-
-                V.val[0] = vmulq_f32(vResult0, Reciprocal);
-                V.val[1] = vmulq_f32(vResult1, Reciprocal);
-                V.val[2] = vmulq_f32(vResult2, Reciprocal);
-#endif
-
-                vst3q_f32(reinterpret_cast<float*>(pOutputVector), V);
-                pOutputVector += sizeof(XMFLOAT3) * 4;
-
-                i += 4;
-            }
-        }
-    }
-
-    if (i < VectorCount)
-    {
-        float32x2_t ScaleL = vcreate_f32(
-            static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&sx))
-            | (static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&sy)) << 32));
-        float32x2_t ScaleH = vcreate_f32(static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&sz)));
-
-        float32x2_t OffsetL = vcreate_f32(
-            static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&ox))
-            | (static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&oy)) << 32));
-        float32x2_t OffsetH = vcreate_f32(static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&oz)));
-
-        for (; i < VectorCount; i++)
-        {
-            float32x2_t VL = vld1_f32(reinterpret_cast<const float*>(pInputVector));
-            float32x2_t zero = vdup_n_f32(0);
-            float32x2_t VH = vld1_lane_f32(reinterpret_cast<const float*>(pInputVector) + 2, zero, 0);
-            pInputVector += InputStride;
-
-            VL = vmla_f32(OffsetL, VL, ScaleL);
-            VH = vmla_f32(OffsetH, VH, ScaleH);
-
-            XMVECTOR vResult = vmlaq_lane_f32(Transform.r[3], Transform.r[0], VL, 0); // X
-            vResult = vmlaq_lane_f32(vResult, Transform.r[1], VL, 1); // Y
-            vResult = vmlaq_lane_f32(vResult, Transform.r[2], VH, 0); // Z
-
-            VH = vget_high_f32(vResult);
-            XMVECTOR W = vdupq_lane_f32(VH, 1);
-
-#if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__
-            vResult = vdivq_f32(vResult, W);
-#else
-            // 2 iterations of Newton-Raphson refinement of reciprocal for W
-            float32x4_t Reciprocal = vrecpeq_f32(W);
-            float32x4_t S = vrecpsq_f32(Reciprocal, W);
-            Reciprocal = vmulq_f32(S, Reciprocal);
-            S = vrecpsq_f32(Reciprocal, W);
-            Reciprocal = vmulq_f32(S, Reciprocal);
-
-            vResult = vmulq_f32(vResult, Reciprocal);
-#endif
-
-            VL = vget_low_f32(vResult);
-            vst1_f32(reinterpret_cast<float*>(pOutputVector), VL);
-            vst1q_lane_f32(reinterpret_cast<float*>(pOutputVector) + 2, vResult, 2);
-            pOutputVector += OutputStride;
-        }
-    }
-
-    return pOutputStream;
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 D = { { { -1.0f, 1.0f, 0.0f, 0.0f } } };
-
-    XMVECTOR Scale = XMVectorSet(ViewportWidth * 0.5f, -ViewportHeight * 0.5f, ViewportMaxZ - ViewportMinZ, 1.0f);
-    Scale = XMVectorReciprocal(Scale);
-
-    XMVECTOR Offset = XMVectorSet(-ViewportX, -ViewportY, -ViewportMinZ, 0.0f);
-    Offset = _mm_mul_ps(Scale, Offset);
-    Offset = _mm_add_ps(Offset, D);
-
-    XMMATRIX Transform = XMMatrixMultiply(World, View);
-    Transform = XMMatrixMultiply(Transform, Projection);
-    Transform = XMMatrixInverse(nullptr, Transform);
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if (InputStride == sizeof(XMFLOAT3))
-        {
-            if (OutputStride == sizeof(XMFLOAT3))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                        __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                        pInputVector += sizeof(XMFLOAT3) * 4;
-
-                        // Unpack the 4 vectors (.w components are junk)
-                        XM3UNPACK3INTO4(V1, L2, L3);
-
-                        // Result 1
-                        V1 = XM_FMADD_PS(V1, Scale, Offset);
-
-                        XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                        XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        XMVECTOR vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        XMVECTOR vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        V1 = _mm_div_ps(vTemp, W);
-
-                        // Result 2
-                        V2 = XM_FMADD_PS(V2, Scale, Offset);
-
-                        Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        V2 = _mm_div_ps(vTemp, W);
-
-                        // Result 3
-                        V3 = XM_FMADD_PS(V3, Scale, Offset);
-
-                        Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        V3 = _mm_div_ps(vTemp, W);
-
-                        // Result 4
-                        V4 = XM_FMADD_PS(V4, Scale, Offset);
-
-                        Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        V4 = _mm_div_ps(vTemp, W);
-
-                        // Pack and store the vectors
-                        XM3PACK4INTO3(vTemp);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), V1);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector + 16), vTemp);
-                        XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector + 32), V3);
-                        pOutputVector += sizeof(XMFLOAT3) * 4;
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, unaligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                        __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                        pInputVector += sizeof(XMFLOAT3) * 4;
-
-                        // Unpack the 4 vectors (.w components are junk)
-                        XM3UNPACK3INTO4(V1, L2, L3);
-
-                        // Result 1
-                        V1 = XM_FMADD_PS(V1, Scale, Offset);
-
-                        XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                        XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                        XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        XMVECTOR vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        XMVECTOR vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        XMVECTOR vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        V1 = _mm_div_ps(vTemp, W);
-
-                        // Result 2
-                        V2 = XM_FMADD_PS(V2, Scale, Offset);
-
-                        Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        V2 = _mm_div_ps(vTemp, W);
-
-                        // Result 3
-                        V3 = XM_FMADD_PS(V3, Scale, Offset);
-
-                        Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        V3 = _mm_div_ps(vTemp, W);
-
-                        // Result 4
-                        V4 = XM_FMADD_PS(V4, Scale, Offset);
-
-                        Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                        Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                        X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                        vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                        vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                        vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                        vTemp = _mm_add_ps(vTemp, vTemp2);
-                        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                        W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                        V4 = _mm_div_ps(vTemp, W);
-
-                        // Pack and store the vectors
-                        XM3PACK4INTO3(vTemp);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), V1);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector + 16), vTemp);
-                        _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector + 32), V3);
-                        pOutputVector += sizeof(XMFLOAT3) * 4;
-                        i += 4;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
-                    __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
-                    pInputVector += sizeof(XMFLOAT3) * 4;
-
-                    // Unpack the 4 vectors (.w components are junk)
-                    XM3UNPACK3INTO4(V1, L2, L3);
-
-                    // Result 1
-                    V1 = XM_FMADD_PS(V1, Scale, Offset);
-
-                    XMVECTOR Z = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
-                    XMVECTOR Y = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
-                    XMVECTOR X = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    XMVECTOR vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                    XMVECTOR vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                    XMVECTOR vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTemp = _mm_div_ps(vTemp, W);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 2
-                    V2 = XM_FMADD_PS(V2, Scale, Offset);
-
-                    Z = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                    vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                    vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTemp = _mm_div_ps(vTemp, W);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 3
-                    V3 = XM_FMADD_PS(V3, Scale, Offset);
-
-                    Z = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                    vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                    vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTemp = _mm_div_ps(vTemp, W);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    // Result 4
-                    V4 = XM_FMADD_PS(V4, Scale, Offset);
-
-                    Z = XM_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
-                    Y = XM_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
-                    X = XM_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
-
-                    vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-                    vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-                    vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-                    vTemp = _mm_add_ps(vTemp, vTemp2);
-                    vTemp = _mm_add_ps(vTemp, vTemp3);
-
-                    W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-                    vTemp = _mm_div_ps(vTemp, W);
-
-                    XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-                    pOutputVector += OutputStride;
-
-                    i += 4;
-                }
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
-        pInputVector += InputStride;
-
-        V = _mm_mul_ps(V, Scale);
-        V = _mm_add_ps(V, Offset);
-
-        XMVECTOR Z = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-        XMVECTOR Y = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-        XMVECTOR X = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-
-        XMVECTOR vTemp = XM_FMADD_PS(Z, Transform.r[2], Transform.r[3]);
-        XMVECTOR vTemp2 = _mm_mul_ps(Y, Transform.r[1]);
-        XMVECTOR vTemp3 = _mm_mul_ps(X, Transform.r[0]);
-        vTemp = _mm_add_ps(vTemp, vTemp2);
-        vTemp = _mm_add_ps(vTemp, vTemp3);
-
-        XMVECTOR W = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 3, 3, 3));
-        vTemp = _mm_div_ps(vTemp, W);
-
-        XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), vTemp);
-        pOutputVector += OutputStride;
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#endif
-}
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-/****************************************************************************
- *
- * 4D Vector
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-// Comparison operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4Equal
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] == V2.vector4_f32[0]) && (V1.vector4_f32[1] == V2.vector4_f32[1]) && (V1.vector4_f32[2] == V2.vector4_f32[2]) && (V1.vector4_f32[3] == V2.vector4_f32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) == 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpeq_ps(V1, V2);
-    return ((_mm_movemask_ps(vTemp) == 0x0f) != 0);
-#else
-    return XMComparisonAllTrue(XMVector4EqualR(V1, V2));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector4EqualR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t CR = 0;
-
-    if ((V1.vector4_f32[0] == V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] == V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] == V2.vector4_f32[2]) &&
-        (V1.vector4_f32[3] == V2.vector4_f32[3]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_f32[0] != V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] != V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] != V2.vector4_f32[2]) &&
-        (V1.vector4_f32[3] != V2.vector4_f32[3]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpeq_ps(V1, V2);
-    int iTest = _mm_movemask_ps(vTemp);
-    uint32_t CR = 0;
-    if (iTest == 0xf)     // All equal?
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (iTest == 0)  // All not equal?
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4EqualInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_u32[0] == V2.vector4_u32[0]) && (V1.vector4_u32[1] == V2.vector4_u32[1]) && (V1.vector4_u32[2] == V2.vector4_u32[2]) && (V1.vector4_u32[3] == V2.vector4_u32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2));
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) == 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return ((_mm_movemask_ps(_mm_castsi128_ps(vTemp)) == 0xf) != 0);
-#else
-    return XMComparisonAllTrue(XMVector4EqualIntR(V1, V2));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector4EqualIntR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    uint32_t CR = 0;
-    if (V1.vector4_u32[0] == V2.vector4_u32[0] &&
-        V1.vector4_u32[1] == V2.vector4_u32[1] &&
-        V1.vector4_u32[2] == V2.vector4_u32[2] &&
-        V1.vector4_u32[3] == V2.vector4_u32[3])
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (V1.vector4_u32[0] != V2.vector4_u32[0] &&
-        V1.vector4_u32[1] != V2.vector4_u32[1] &&
-        V1.vector4_u32[2] != V2.vector4_u32[2] &&
-        V1.vector4_u32[3] != V2.vector4_u32[3])
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2));
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    int iTest = _mm_movemask_ps(_mm_castsi128_ps(vTemp));
-    uint32_t CR = 0;
-    if (iTest == 0xf)     // All equal?
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (iTest == 0)  // All not equal?
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-inline bool XM_CALLCONV XMVector4NearEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2,
-                FXMVECTOR Epsilon
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float dx, dy, dz, dw;
-
-    dx = fabsf(V1.vector4_f32[0] - V2.vector4_f32[0]);
-    dy = fabsf(V1.vector4_f32[1] - V2.vector4_f32[1]);
-    dz = fabsf(V1.vector4_f32[2] - V2.vector4_f32[2]);
-    dw = fabsf(V1.vector4_f32[3] - V2.vector4_f32[3]);
-    return (((dx <= Epsilon.vector4_f32[0]) &&
-        (dy <= Epsilon.vector4_f32[1]) &&
-        (dz <= Epsilon.vector4_f32[2]) &&
-        (dw <= Epsilon.vector4_f32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t vDelta = vsubq_f32(V1, V2);
-#if defined(_MSC_VER) && !defined(__clang__)
-    uint32x4_t vResult = vacleq_f32(vDelta, Epsilon);
-#else
-    uint32x4_t vResult = vcleq_f32(vabsq_f32(vDelta), Epsilon);
-#endif
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) == 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Get the difference
-    XMVECTOR vDelta = _mm_sub_ps(V1, V2);
-    // Get the absolute value of the difference
-    XMVECTOR vTemp = _mm_setzero_ps();
-    vTemp = _mm_sub_ps(vTemp, vDelta);
-    vTemp = _mm_max_ps(vTemp, vDelta);
-    vTemp = _mm_cmple_ps(vTemp, Epsilon);
-    return ((_mm_movemask_ps(vTemp) == 0xf) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4NotEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] != V2.vector4_f32[0]) || (V1.vector4_f32[1] != V2.vector4_f32[1]) || (V1.vector4_f32[2] != V2.vector4_f32[2]) || (V1.vector4_f32[3] != V2.vector4_f32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) != 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpneq_ps(V1, V2);
-    return ((_mm_movemask_ps(vTemp)) != 0);
-#else
-    return XMComparisonAnyFalse(XMVector4EqualR(V1, V2));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4NotEqualInt
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_u32[0] != V2.vector4_u32[0]) || (V1.vector4_u32[1] != V2.vector4_u32[1]) || (V1.vector4_u32[2] != V2.vector4_u32[2]) || (V1.vector4_u32[3] != V2.vector4_u32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vceqq_u32(vreinterpretq_u32_f32(V1), vreinterpretq_u32_f32(V2));
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) != 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1), _mm_castps_si128(V2));
-    return ((_mm_movemask_ps(_mm_castsi128_ps(vTemp)) != 0xF) != 0);
-#else
-    return XMComparisonAnyFalse(XMVector4EqualIntR(V1, V2));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4Greater
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] > V2.vector4_f32[0]) && (V1.vector4_f32[1] > V2.vector4_f32[1]) && (V1.vector4_f32[2] > V2.vector4_f32[2]) && (V1.vector4_f32[3] > V2.vector4_f32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgtq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) == 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpgt_ps(V1, V2);
-    return ((_mm_movemask_ps(vTemp) == 0x0f) != 0);
-#else
-    return XMComparisonAllTrue(XMVector4GreaterR(V1, V2));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector4GreaterR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    uint32_t CR = 0;
-    if (V1.vector4_f32[0] > V2.vector4_f32[0] &&
-        V1.vector4_f32[1] > V2.vector4_f32[1] &&
-        V1.vector4_f32[2] > V2.vector4_f32[2] &&
-        V1.vector4_f32[3] > V2.vector4_f32[3])
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (V1.vector4_f32[0] <= V2.vector4_f32[0] &&
-        V1.vector4_f32[1] <= V2.vector4_f32[1] &&
-        V1.vector4_f32[2] <= V2.vector4_f32[2] &&
-        V1.vector4_f32[3] <= V2.vector4_f32[3])
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgtq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    uint32_t CR = 0;
-    XMVECTOR vTemp = _mm_cmpgt_ps(V1, V2);
-    int iTest = _mm_movemask_ps(vTemp);
-    if (iTest == 0xf)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4GreaterOrEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] >= V2.vector4_f32[0]) && (V1.vector4_f32[1] >= V2.vector4_f32[1]) && (V1.vector4_f32[2] >= V2.vector4_f32[2]) && (V1.vector4_f32[3] >= V2.vector4_f32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgeq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) == 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmpge_ps(V1, V2);
-    return ((_mm_movemask_ps(vTemp) == 0x0f) != 0);
-#else
-    return XMComparisonAllTrue(XMVector4GreaterOrEqualR(V1, V2));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline uint32_t XM_CALLCONV XMVector4GreaterOrEqualR
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    uint32_t CR = 0;
-    if ((V1.vector4_f32[0] >= V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] >= V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] >= V2.vector4_f32[2]) &&
-        (V1.vector4_f32[3] >= V2.vector4_f32[3]))
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if ((V1.vector4_f32[0] < V2.vector4_f32[0]) &&
-        (V1.vector4_f32[1] < V2.vector4_f32[1]) &&
-        (V1.vector4_f32[2] < V2.vector4_f32[2]) &&
-        (V1.vector4_f32[3] < V2.vector4_f32[3]))
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcgeq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    uint32_t r = vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1);
-
-    uint32_t CR = 0;
-    if (r == 0xFFFFFFFFU)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!r)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#elif defined(_XM_SSE_INTRINSICS_)
-    uint32_t CR = 0;
-    XMVECTOR vTemp = _mm_cmpge_ps(V1, V2);
-    int iTest = _mm_movemask_ps(vTemp);
-    if (iTest == 0x0f)
-    {
-        CR = XM_CRMASK_CR6TRUE;
-    }
-    else if (!iTest)
-    {
-        CR = XM_CRMASK_CR6FALSE;
-    }
-    return CR;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4Less
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] < V2.vector4_f32[0]) && (V1.vector4_f32[1] < V2.vector4_f32[1]) && (V1.vector4_f32[2] < V2.vector4_f32[2]) && (V1.vector4_f32[3] < V2.vector4_f32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcltq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) == 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmplt_ps(V1, V2);
-    return ((_mm_movemask_ps(vTemp) == 0x0f) != 0);
-#else
-    return XMComparisonAllTrue(XMVector4GreaterR(V2, V1));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4LessOrEqual
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V1.vector4_f32[0] <= V2.vector4_f32[0]) && (V1.vector4_f32[1] <= V2.vector4_f32[1]) && (V1.vector4_f32[2] <= V2.vector4_f32[2]) && (V1.vector4_f32[3] <= V2.vector4_f32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vResult = vcleq_f32(V1, V2);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vResult)), vget_high_u8(vreinterpretq_u8_u32(vResult)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) == 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp = _mm_cmple_ps(V1, V2);
-    return ((_mm_movemask_ps(vTemp) == 0x0f) != 0);
-#else
-    return XMComparisonAllTrue(XMVector4GreaterOrEqualR(V2, V1));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4InBounds
-        (
-                FXMVECTOR V,
-                FXMVECTOR Bounds
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (((V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) &&
-        (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1]) &&
-        (V.vector4_f32[2] <= Bounds.vector4_f32[2] && V.vector4_f32[2] >= -Bounds.vector4_f32[2]) &&
-        (V.vector4_f32[3] <= Bounds.vector4_f32[3] && V.vector4_f32[3] >= -Bounds.vector4_f32[3])) != 0);
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Test if less than or equal
-    uint32x4_t ivTemp1 = vcleq_f32(V, Bounds);
-    // Negate the bounds
-    float32x4_t vTemp2 = vnegq_f32(Bounds);
-    // Test if greater or equal (Reversed)
-    uint32x4_t ivTemp2 = vcleq_f32(vTemp2, V);
-    // Blend answers
-    ivTemp1 = vandq_u32(ivTemp1, ivTemp2);
-    // in bounds?
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(ivTemp1)), vget_high_u8(vreinterpretq_u8_u32(ivTemp1)));
-    uint16x4x2_t vTemp3 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp3.val[1]), 1) == 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Test if less than or equal
-    XMVECTOR vTemp1 = _mm_cmple_ps(V, Bounds);
-    // Negate the bounds
-    XMVECTOR vTemp2 = _mm_mul_ps(Bounds, g_XMNegativeOne);
-    // Test if greater or equal (Reversed)
-    vTemp2 = _mm_cmple_ps(vTemp2, V);
-    // Blend answers
-    vTemp1 = _mm_and_ps(vTemp1, vTemp2);
-    // All in bounds?
-    return ((_mm_movemask_ps(vTemp1) == 0x0f) != 0);
-#else
-    return XMComparisonAllInBounds(XMVector4InBoundsR(V, Bounds));
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(push)
-#pragma float_control(precise, on)
-#endif
-
-inline bool XM_CALLCONV XMVector4IsNaN(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    return (XMISNAN(V.vector4_f32[0]) ||
-        XMISNAN(V.vector4_f32[1]) ||
-        XMISNAN(V.vector4_f32[2]) ||
-        XMISNAN(V.vector4_f32[3]));
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Test against itself. NaN is always not equal
-    uint32x4_t vTempNan = vceqq_f32(V, V);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vTempNan)), vget_high_u8(vreinterpretq_u8_u32(vTempNan)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    // If any are NaN, the mask is zero
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) != 0xFFFFFFFFU);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Test against itself. NaN is always not equal
-    XMVECTOR vTempNan = _mm_cmpneq_ps(V, V);
-    // If any are NaN, the mask is non-zero
-    return (_mm_movemask_ps(vTempNan) != 0);
-#endif
-}
-
-#if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma float_control(pop)
-#endif
-
-//------------------------------------------------------------------------------
-
-inline bool XM_CALLCONV XMVector4IsInfinite(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    return (XMISINF(V.vector4_f32[0]) ||
-        XMISINF(V.vector4_f32[1]) ||
-        XMISINF(V.vector4_f32[2]) ||
-        XMISINF(V.vector4_f32[3]));
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Mask off the sign bit
-    uint32x4_t vTempInf = vandq_u32(vreinterpretq_u32_f32(V), g_XMAbsMask);
-    // Compare to infinity
-    vTempInf = vceqq_f32(vreinterpretq_f32_u32(vTempInf), g_XMInfinity);
-    // If any are infinity, the signs are true.
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(vTempInf)), vget_high_u8(vreinterpretq_u8_u32(vTempInf)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-    return (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) != 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Mask off the sign bit
-    XMVECTOR vTemp = _mm_and_ps(V, g_XMAbsMask);
-    // Compare to infinity
-    vTemp = _mm_cmpeq_ps(vTemp, g_XMInfinity);
-    // If any are infinity, the signs are true.
-    return (_mm_movemask_ps(vTemp) != 0);
-#endif
-}
-
-//------------------------------------------------------------------------------
-// Computation operations
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4Dot
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result;
-    Result.f[0] =
-        Result.f[1] =
-        Result.f[2] =
-        Result.f[3] = V1.vector4_f32[0] * V2.vector4_f32[0] + V1.vector4_f32[1] * V2.vector4_f32[1] + V1.vector4_f32[2] * V2.vector4_f32[2] + V1.vector4_f32[3] * V2.vector4_f32[3];
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x4_t vTemp = vmulq_f32(V1, V2);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vadd_f32(v1, v2);
-    v1 = vpadd_f32(v1, v1);
-    return vcombine_f32(v1, v1);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    return _mm_dp_ps(V1, V2, 0xff);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vTemp = _mm_mul_ps(V1, V2);
-    vTemp = _mm_hadd_ps(vTemp, vTemp);
-    return _mm_hadd_ps(vTemp, vTemp);
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vTemp2 = V2;
-    XMVECTOR vTemp = _mm_mul_ps(V1, vTemp2);
-    vTemp2 = _mm_shuffle_ps(vTemp2, vTemp, _MM_SHUFFLE(1, 0, 0, 0)); // Copy X to the Z position and Y to the W position
-    vTemp2 = _mm_add_ps(vTemp2, vTemp);          // Add Z = X+Z; W = Y+W;
-    vTemp = _mm_shuffle_ps(vTemp, vTemp2, _MM_SHUFFLE(0, 3, 0, 0));  // Copy W to the Z position
-    vTemp = _mm_add_ps(vTemp, vTemp2);           // Add Z and W together
-    return XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(2, 2, 2, 2));    // Splat Z and return
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4Cross
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2,
-                FXMVECTOR V3
-        ) noexcept
-{
-    // [ ((v2.z*v3.w-v2.w*v3.z)*v1.y)-((v2.y*v3.w-v2.w*v3.y)*v1.z)+((v2.y*v3.z-v2.z*v3.y)*v1.w),
-    //   ((v2.w*v3.z-v2.z*v3.w)*v1.x)-((v2.w*v3.x-v2.x*v3.w)*v1.z)+((v2.z*v3.x-v2.x*v3.z)*v1.w),
-    //   ((v2.y*v3.w-v2.w*v3.y)*v1.x)-((v2.x*v3.w-v2.w*v3.x)*v1.y)+((v2.x*v3.y-v2.y*v3.x)*v1.w),
-    //   ((v2.z*v3.y-v2.y*v3.z)*v1.x)-((v2.z*v3.x-v2.x*v3.z)*v1.y)+((v2.y*v3.x-v2.x*v3.y)*v1.z) ]
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            (((V2.vector4_f32[2] * V3.vector4_f32[3]) - (V2.vector4_f32[3] * V3.vector4_f32[2])) * V1.vector4_f32[1]) - (((V2.vector4_f32[1] * V3.vector4_f32[3]) - (V2.vector4_f32[3] * V3.vector4_f32[1])) * V1.vector4_f32[2]) + (((V2.vector4_f32[1] * V3.vector4_f32[2]) - (V2.vector4_f32[2] * V3.vector4_f32[1])) * V1.vector4_f32[3]),
-            (((V2.vector4_f32[3] * V3.vector4_f32[2]) - (V2.vector4_f32[2] * V3.vector4_f32[3])) * V1.vector4_f32[0]) - (((V2.vector4_f32[3] * V3.vector4_f32[0]) - (V2.vector4_f32[0] * V3.vector4_f32[3])) * V1.vector4_f32[2]) + (((V2.vector4_f32[2] * V3.vector4_f32[0]) - (V2.vector4_f32[0] * V3.vector4_f32[2])) * V1.vector4_f32[3]),
-            (((V2.vector4_f32[1] * V3.vector4_f32[3]) - (V2.vector4_f32[3] * V3.vector4_f32[1])) * V1.vector4_f32[0]) - (((V2.vector4_f32[0] * V3.vector4_f32[3]) - (V2.vector4_f32[3] * V3.vector4_f32[0])) * V1.vector4_f32[1]) + (((V2.vector4_f32[0] * V3.vector4_f32[1]) - (V2.vector4_f32[1] * V3.vector4_f32[0])) * V1.vector4_f32[3]),
-            (((V2.vector4_f32[2] * V3.vector4_f32[1]) - (V2.vector4_f32[1] * V3.vector4_f32[2])) * V1.vector4_f32[0]) - (((V2.vector4_f32[2] * V3.vector4_f32[0]) - (V2.vector4_f32[0] * V3.vector4_f32[2])) * V1.vector4_f32[1]) + (((V2.vector4_f32[1] * V3.vector4_f32[0]) - (V2.vector4_f32[0] * V3.vector4_f32[1])) * V1.vector4_f32[2]),
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    const uint32x2_t select = vget_low_u32(g_XMMaskX);
-
-    // Term1: V2zwyz * V3wzwy
-    const float32x2_t v2xy = vget_low_f32(V2);
-    const float32x2_t v2zw = vget_high_f32(V2);
-    const float32x2_t v2yx = vrev64_f32(v2xy);
-    const float32x2_t v2wz = vrev64_f32(v2zw);
-    const float32x2_t v2yz = vbsl_f32(select, v2yx, v2wz);
-
-    const float32x2_t v3zw = vget_high_f32(V3);
-    const float32x2_t v3wz = vrev64_f32(v3zw);
-    const float32x2_t v3xy = vget_low_f32(V3);
-    const float32x2_t v3wy = vbsl_f32(select, v3wz, v3xy);
-
-    float32x4_t vTemp1 = vcombine_f32(v2zw, v2yz);
-    float32x4_t vTemp2 = vcombine_f32(v3wz, v3wy);
-    XMVECTOR vResult = vmulq_f32(vTemp1, vTemp2);
-
-    // - V2wzwy * V3zwyz
-    const float32x2_t v2wy = vbsl_f32(select, v2wz, v2xy);
-
-    const float32x2_t v3yx = vrev64_f32(v3xy);
-    const float32x2_t v3yz = vbsl_f32(select, v3yx, v3wz);
-
-    vTemp1 = vcombine_f32(v2wz, v2wy);
-    vTemp2 = vcombine_f32(v3zw, v3yz);
-    vResult = vmlsq_f32(vResult, vTemp1, vTemp2);
-
-    // term1 * V1yxxx
-    const float32x2_t v1xy = vget_low_f32(V1);
-    const float32x2_t v1yx = vrev64_f32(v1xy);
-
-    vTemp1 = vcombine_f32(v1yx, vdup_lane_f32(v1yx, 1));
-    vResult = vmulq_f32(vResult, vTemp1);
-
-    // Term2: V2ywxz * V3wxwx
-    const float32x2_t v2yw = vrev64_f32(v2wy);
-    const float32x2_t v2xz = vbsl_f32(select, v2xy, v2wz);
-
-    const float32x2_t v3wx = vbsl_f32(select, v3wz, v3yx);
-
-    vTemp1 = vcombine_f32(v2yw, v2xz);
-    vTemp2 = vcombine_f32(v3wx, v3wx);
-    float32x4_t vTerm = vmulq_f32(vTemp1, vTemp2);
-
-    // - V2wxwx * V3ywxz
-    const float32x2_t v2wx = vbsl_f32(select, v2wz, v2yx);
-
-    const float32x2_t v3yw = vrev64_f32(v3wy);
-    const float32x2_t v3xz = vbsl_f32(select, v3xy, v3wz);
-
-    vTemp1 = vcombine_f32(v2wx, v2wx);
-    vTemp2 = vcombine_f32(v3yw, v3xz);
-    vTerm = vmlsq_f32(vTerm, vTemp1, vTemp2);
-
-    // vResult - term2 * V1zzyy
-    const float32x2_t v1zw = vget_high_f32(V1);
-
-    vTemp1 = vcombine_f32(vdup_lane_f32(v1zw, 0), vdup_lane_f32(v1yx, 0));
-    vResult = vmlsq_f32(vResult, vTerm, vTemp1);
-
-    // Term3: V2yzxy * V3zxyx
-    const float32x2_t v3zx = vrev64_f32(v3xz);
-
-    vTemp1 = vcombine_f32(v2yz, v2xy);
-    vTemp2 = vcombine_f32(v3zx, v3yx);
-    vTerm = vmulq_f32(vTemp1, vTemp2);
-
-    // - V2zxyx * V3yzxy
-    const float32x2_t v2zx = vrev64_f32(v2xz);
-
-    vTemp1 = vcombine_f32(v2zx, v2yx);
-    vTemp2 = vcombine_f32(v3yz, v3xy);
-    vTerm = vmlsq_f32(vTerm, vTemp1, vTemp2);
-
-    // vResult + term3 * V1wwwz
-    const float32x2_t v1wz = vrev64_f32(v1zw);
-
-    vTemp1 = vcombine_f32(vdup_lane_f32(v1wz, 0), v1wz);
-    return vmlaq_f32(vResult, vTerm, vTemp1);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // V2zwyz * V3wzwy
-    XMVECTOR vResult = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 1, 3, 2));
-    XMVECTOR vTemp3 = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 3, 2, 3));
-    vResult = _mm_mul_ps(vResult, vTemp3);
-    // - V2wzwy * V3zwyz
-    XMVECTOR vTemp2 = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 3, 2, 3));
-    vTemp3 = XM_PERMUTE_PS(vTemp3, _MM_SHUFFLE(1, 3, 0, 1));
-    vResult = XM_FNMADD_PS(vTemp2, vTemp3, vResult);
-    // term1 * V1yxxx
-    XMVECTOR vTemp1 = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 1));
-    vResult = _mm_mul_ps(vResult, vTemp1);
-
-    // V2ywxz * V3wxwx
-    vTemp2 = XM_PERMUTE_PS(V2, _MM_SHUFFLE(2, 0, 3, 1));
-    vTemp3 = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 3, 0, 3));
-    vTemp3 = _mm_mul_ps(vTemp3, vTemp2);
-    // - V2wxwx * V3ywxz
-    vTemp2 = XM_PERMUTE_PS(vTemp2, _MM_SHUFFLE(2, 1, 2, 1));
-    vTemp1 = XM_PERMUTE_PS(V3, _MM_SHUFFLE(2, 0, 3, 1));
-    vTemp3 = XM_FNMADD_PS(vTemp2, vTemp1, vTemp3);
-    // vResult - temp * V1zzyy
-    vTemp1 = XM_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 2, 2));
-    vResult = XM_FNMADD_PS(vTemp1, vTemp3, vResult);
-
-    // V2yzxy * V3zxyx
-    vTemp2 = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 0, 2, 1));
-    vTemp3 = XM_PERMUTE_PS(V3, _MM_SHUFFLE(0, 1, 0, 2));
-    vTemp3 = _mm_mul_ps(vTemp3, vTemp2);
-    // - V2zxyx * V3yzxy
-    vTemp2 = XM_PERMUTE_PS(vTemp2, _MM_SHUFFLE(2, 0, 2, 1));
-    vTemp1 = XM_PERMUTE_PS(V3, _MM_SHUFFLE(1, 0, 2, 1));
-    vTemp3 = XM_FNMADD_PS(vTemp1, vTemp2, vTemp3);
-    // vResult + term * V1wwwz
-    vTemp1 = XM_PERMUTE_PS(V1, _MM_SHUFFLE(2, 3, 3, 3));
-    vResult = XM_FMADD_PS(vTemp3, vTemp1, vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4LengthSq(FXMVECTOR V) noexcept
-{
-    return XMVector4Dot(V, V);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4ReciprocalLengthEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-
-    Result = XMVector4LengthSq(V);
-    Result = XMVectorReciprocalSqrtEst(Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot4
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vadd_f32(v1, v2);
-    v1 = vpadd_f32(v1, v1);
-    // Reciprocal sqrt (estimate)
-    v2 = vrsqrte_f32(v1);
-    return vcombine_f32(v2, v2);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0xff);
-    return _mm_rsqrt_ps(vTemp);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_rsqrt_ps(vLengthSq);
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y,z and w
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has z and w
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(3, 2, 3, 2));
-    // x+z, y+w
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // x+z,x+z,x+z,y+w
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 0, 0, 0));
-    // ??,??,y+w,y+w
-    vTemp = _mm_shuffle_ps(vTemp, vLengthSq, _MM_SHUFFLE(3, 3, 0, 0));
-    // ??,??,x+z+y+w,??
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // Splat the length
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(2, 2, 2, 2));
-    // Get the reciprocal
-    vLengthSq = _mm_rsqrt_ps(vLengthSq);
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4ReciprocalLength(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-
-    Result = XMVector4LengthSq(V);
-    Result = XMVectorReciprocalSqrt(Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot4
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vadd_f32(v1, v2);
-    v1 = vpadd_f32(v1, v1);
-    // Reciprocal sqrt
-    float32x2_t  S0 = vrsqrte_f32(v1);
-    float32x2_t  P0 = vmul_f32(v1, S0);
-    float32x2_t  R0 = vrsqrts_f32(P0, S0);
-    float32x2_t  S1 = vmul_f32(S0, R0);
-    float32x2_t  P1 = vmul_f32(v1, S1);
-    float32x2_t  R1 = vrsqrts_f32(P1, S1);
-    float32x2_t Result = vmul_f32(S1, R1);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0xff);
-    XMVECTOR vLengthSq = _mm_sqrt_ps(vTemp);
-    return _mm_div_ps(g_XMOne, vLengthSq);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    vLengthSq = _mm_div_ps(g_XMOne, vLengthSq);
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y,z and w
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has z and w
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(3, 2, 3, 2));
-    // x+z, y+w
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // x+z,x+z,x+z,y+w
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 0, 0, 0));
-    // ??,??,y+w,y+w
-    vTemp = _mm_shuffle_ps(vTemp, vLengthSq, _MM_SHUFFLE(3, 3, 0, 0));
-    // ??,??,x+z+y+w,??
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // Splat the length
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(2, 2, 2, 2));
-    // Get the reciprocal
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    // Accurate!
-    vLengthSq = _mm_div_ps(g_XMOne, vLengthSq);
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4LengthEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-
-    Result = XMVector4LengthSq(V);
-    Result = XMVectorSqrtEst(Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot4
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vadd_f32(v1, v2);
-    v1 = vpadd_f32(v1, v1);
-    const float32x2_t zero = vdup_n_f32(0);
-    uint32x2_t VEqualsZero = vceq_f32(v1, zero);
-    // Sqrt (estimate)
-    float32x2_t Result = vrsqrte_f32(v1);
-    Result = vmul_f32(v1, Result);
-    Result = vbsl_f32(VEqualsZero, zero, Result);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0xff);
-    return _mm_sqrt_ps(vTemp);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y,z and w
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has z and w
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(3, 2, 3, 2));
-    // x+z, y+w
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // x+z,x+z,x+z,y+w
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 0, 0, 0));
-    // ??,??,y+w,y+w
-    vTemp = _mm_shuffle_ps(vTemp, vLengthSq, _MM_SHUFFLE(3, 3, 0, 0));
-    // ??,??,x+z+y+w,??
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // Splat the length
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(2, 2, 2, 2));
-    // Get the length
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4Length(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-
-    Result = XMVector4LengthSq(V);
-    Result = XMVectorSqrt(Result);
-
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot4
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vadd_f32(v1, v2);
-    v1 = vpadd_f32(v1, v1);
-    const float32x2_t zero = vdup_n_f32(0);
-    uint32x2_t VEqualsZero = vceq_f32(v1, zero);
-    // Sqrt
-    float32x2_t S0 = vrsqrte_f32(v1);
-    float32x2_t P0 = vmul_f32(v1, S0);
-    float32x2_t R0 = vrsqrts_f32(P0, S0);
-    float32x2_t S1 = vmul_f32(S0, R0);
-    float32x2_t P1 = vmul_f32(v1, S1);
-    float32x2_t R1 = vrsqrts_f32(P1, S1);
-    float32x2_t Result = vmul_f32(S1, R1);
-    Result = vmul_f32(v1, Result);
-    Result = vbsl_f32(VEqualsZero, zero, Result);
-    return vcombine_f32(Result, Result);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0xff);
-    return _mm_sqrt_ps(vTemp);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    return vLengthSq;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y,z and w
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has z and w
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(3, 2, 3, 2));
-    // x+z, y+w
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // x+z,x+z,x+z,y+w
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 0, 0, 0));
-    // ??,??,y+w,y+w
-    vTemp = _mm_shuffle_ps(vTemp, vLengthSq, _MM_SHUFFLE(3, 3, 0, 0));
-    // ??,??,x+z+y+w,??
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // Splat the length
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(2, 2, 2, 2));
-    // Get the length
-    vLengthSq = _mm_sqrt_ps(vLengthSq);
-    return vLengthSq;
-#endif
-}
-
-//------------------------------------------------------------------------------
-// XMVector4NormalizeEst uses a reciprocal estimate and
-// returns QNaN on zero and infinite vectors.
-
-inline XMVECTOR XM_CALLCONV XMVector4NormalizeEst(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR Result;
-    Result = XMVector4ReciprocalLength(V);
-    Result = XMVectorMultiply(V, Result);
-    return Result;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot4
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vadd_f32(v1, v2);
-    v1 = vpadd_f32(v1, v1);
-    // Reciprocal sqrt (estimate)
-    v2 = vrsqrte_f32(v1);
-    // Normalize
-    return vmulq_f32(V, vcombine_f32(v2, v2));
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vTemp = _mm_dp_ps(V, V, 0xff);
-    XMVECTOR vResult = _mm_rsqrt_ps(vTemp);
-    return _mm_mul_ps(vResult, V);
-#elif defined(_XM_SSE3_INTRINSICS_)
-    XMVECTOR vDot = _mm_mul_ps(V, V);
-    vDot = _mm_hadd_ps(vDot, vDot);
-    vDot = _mm_hadd_ps(vDot, vDot);
-    vDot = _mm_rsqrt_ps(vDot);
-    vDot = _mm_mul_ps(vDot, V);
-    return vDot;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y,z and w
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has z and w
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(3, 2, 3, 2));
-    // x+z, y+w
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // x+z,x+z,x+z,y+w
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 0, 0, 0));
-    // ??,??,y+w,y+w
-    vTemp = _mm_shuffle_ps(vTemp, vLengthSq, _MM_SHUFFLE(3, 3, 0, 0));
-    // ??,??,x+z+y+w,??
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // Splat the length
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(2, 2, 2, 2));
-    // Get the reciprocal
-    XMVECTOR vResult = _mm_rsqrt_ps(vLengthSq);
-    // Reciprocal mul to perform the normalization
-    vResult = _mm_mul_ps(vResult, V);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4Normalize(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-    float fLength;
-    XMVECTOR vResult;
-
-    vResult = XMVector4Length(V);
-    fLength = vResult.vector4_f32[0];
-
-    // Prevent divide by zero
-    if (fLength > 0)
-    {
-        fLength = 1.0f / fLength;
-    }
-
-    vResult.vector4_f32[0] = V.vector4_f32[0] * fLength;
-    vResult.vector4_f32[1] = V.vector4_f32[1] * fLength;
-    vResult.vector4_f32[2] = V.vector4_f32[2] * fLength;
-    vResult.vector4_f32[3] = V.vector4_f32[3] * fLength;
-    return vResult;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    // Dot4
-    float32x4_t vTemp = vmulq_f32(V, V);
-    float32x2_t v1 = vget_low_f32(vTemp);
-    float32x2_t v2 = vget_high_f32(vTemp);
-    v1 = vadd_f32(v1, v2);
-    v1 = vpadd_f32(v1, v1);
-    uint32x2_t VEqualsZero = vceq_f32(v1, vdup_n_f32(0));
-    uint32x2_t VEqualsInf = vceq_f32(v1, vget_low_f32(g_XMInfinity));
-    // Reciprocal sqrt (2 iterations of Newton-Raphson)
-    float32x2_t S0 = vrsqrte_f32(v1);
-    float32x2_t P0 = vmul_f32(v1, S0);
-    float32x2_t R0 = vrsqrts_f32(P0, S0);
-    float32x2_t S1 = vmul_f32(S0, R0);
-    float32x2_t P1 = vmul_f32(v1, S1);
-    float32x2_t R1 = vrsqrts_f32(P1, S1);
-    v2 = vmul_f32(S1, R1);
-    // Normalize
-    XMVECTOR vResult = vmulq_f32(V, vcombine_f32(v2, v2));
-    vResult = vbslq_f32(vcombine_u32(VEqualsZero, VEqualsZero), vdupq_n_f32(0), vResult);
-    return vbslq_f32(vcombine_u32(VEqualsInf, VEqualsInf), g_XMQNaN, vResult);
-#elif defined(_XM_SSE4_INTRINSICS_)
-    XMVECTOR vLengthSq = _mm_dp_ps(V, V, 0xff);
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Create zero with a single instruction
-    XMVECTOR vZeroMask = _mm_setzero_ps();
-    // Test for a divide by zero (Must be FP to detect -0.0)
-    vZeroMask = _mm_cmpneq_ps(vZeroMask, vResult);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Divide to perform the normalization
-    vResult = _mm_div_ps(V, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vZeroMask);
-    // Select qnan or result based on infinite length
-    XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq, g_XMQNaN);
-    XMVECTOR vTemp2 = _mm_and_ps(vResult, vLengthSq);
-    vResult = _mm_or_ps(vTemp1, vTemp2);
-    return vResult;
-#elif defined(_XM_SSE3_INTRINSICS_)
-    // Perform the dot product on x,y,z and w
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    vLengthSq = _mm_hadd_ps(vLengthSq, vLengthSq);
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Create zero with a single instruction
-    XMVECTOR vZeroMask = _mm_setzero_ps();
-    // Test for a divide by zero (Must be FP to detect -0.0)
-    vZeroMask = _mm_cmpneq_ps(vZeroMask, vResult);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Divide to perform the normalization
-    vResult = _mm_div_ps(V, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vZeroMask);
-    // Select qnan or result based on infinite length
-    XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq, g_XMQNaN);
-    XMVECTOR vTemp2 = _mm_and_ps(vResult, vLengthSq);
-    vResult = _mm_or_ps(vTemp1, vTemp2);
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Perform the dot product on x,y,z and w
-    XMVECTOR vLengthSq = _mm_mul_ps(V, V);
-    // vTemp has z and w
-    XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(3, 2, 3, 2));
-    // x+z, y+w
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // x+z,x+z,x+z,y+w
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(1, 0, 0, 0));
-    // ??,??,y+w,y+w
-    vTemp = _mm_shuffle_ps(vTemp, vLengthSq, _MM_SHUFFLE(3, 3, 0, 0));
-    // ??,??,x+z+y+w,??
-    vLengthSq = _mm_add_ps(vLengthSq, vTemp);
-    // Splat the length
-    vLengthSq = XM_PERMUTE_PS(vLengthSq, _MM_SHUFFLE(2, 2, 2, 2));
-    // Prepare for the division
-    XMVECTOR vResult = _mm_sqrt_ps(vLengthSq);
-    // Create zero with a single instruction
-    XMVECTOR vZeroMask = _mm_setzero_ps();
-    // Test for a divide by zero (Must be FP to detect -0.0)
-    vZeroMask = _mm_cmpneq_ps(vZeroMask, vResult);
-    // Failsafe on zero (Or epsilon) length planes
-    // If the length is infinity, set the elements to zero
-    vLengthSq = _mm_cmpneq_ps(vLengthSq, g_XMInfinity);
-    // Divide to perform the normalization
-    vResult = _mm_div_ps(V, vResult);
-    // Any that are infinity, set to zero
-    vResult = _mm_and_ps(vResult, vZeroMask);
-    // Select qnan or result based on infinite length
-    XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq, g_XMQNaN);
-    XMVECTOR vTemp2 = _mm_and_ps(vResult, vLengthSq);
-    vResult = _mm_or_ps(vTemp1, vTemp2);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4ClampLength
-        (
-                FXMVECTOR V,
-                float    LengthMin,
-                float    LengthMax
-        ) noexcept
-{
-    XMVECTOR ClampMax = XMVectorReplicate(LengthMax);
-    XMVECTOR ClampMin = XMVectorReplicate(LengthMin);
-
-    return XMVector4ClampLengthV(V, ClampMin, ClampMax);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4ClampLengthV
-        (
-                FXMVECTOR V,
-                FXMVECTOR LengthMin,
-                FXMVECTOR LengthMax
-        ) noexcept
-{
-    assert((XMVectorGetY(LengthMin) == XMVectorGetX(LengthMin)) && (XMVectorGetZ(LengthMin) == XMVectorGetX(LengthMin)) && (XMVectorGetW(LengthMin) == XMVectorGetX(LengthMin)));
-    assert((XMVectorGetY(LengthMax) == XMVectorGetX(LengthMax)) && (XMVectorGetZ(LengthMax) == XMVectorGetX(LengthMax)) && (XMVectorGetW(LengthMax) == XMVectorGetX(LengthMax)));
-    assert(XMVector4GreaterOrEqual(LengthMin, XMVectorZero()));
-    assert(XMVector4GreaterOrEqual(LengthMax, XMVectorZero()));
-    assert(XMVector4GreaterOrEqual(LengthMax, LengthMin));
-
-    XMVECTOR LengthSq = XMVector4LengthSq(V);
-
-    const XMVECTOR Zero = XMVectorZero();
-
-    XMVECTOR RcpLength = XMVectorReciprocalSqrt(LengthSq);
-
-    XMVECTOR InfiniteLength = XMVectorEqualInt(LengthSq, g_XMInfinity.v);
-    XMVECTOR ZeroLength = XMVectorEqual(LengthSq, Zero);
-
-    XMVECTOR Normal = XMVectorMultiply(V, RcpLength);
-
-    XMVECTOR Length = XMVectorMultiply(LengthSq, RcpLength);
-
-    XMVECTOR Select = XMVectorEqualInt(InfiniteLength, ZeroLength);
-    Length = XMVectorSelect(LengthSq, Length, Select);
-    Normal = XMVectorSelect(LengthSq, Normal, Select);
-
-    XMVECTOR ControlMax = XMVectorGreater(Length, LengthMax);
-    XMVECTOR ControlMin = XMVectorLess(Length, LengthMin);
-
-    XMVECTOR ClampLength = XMVectorSelect(Length, LengthMax, ControlMax);
-    ClampLength = XMVectorSelect(ClampLength, LengthMin, ControlMin);
-
-    XMVECTOR Result = XMVectorMultiply(Normal, ClampLength);
-
-    // Preserve the original vector (with no precision loss) if the length falls within the given range
-    XMVECTOR Control = XMVectorEqualInt(ControlMax, ControlMin);
-    Result = XMVectorSelect(Result, V, Control);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4Reflect
-        (
-                FXMVECTOR Incident,
-                FXMVECTOR Normal
-        ) noexcept
-{
-    // Result = Incident - (2 * dot(Incident, Normal)) * Normal
-
-    XMVECTOR Result = XMVector4Dot(Incident, Normal);
-    Result = XMVectorAdd(Result, Result);
-    Result = XMVectorNegativeMultiplySubtract(Result, Normal, Incident);
-
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4Refract
-        (
-                FXMVECTOR Incident,
-                FXMVECTOR Normal,
-                float    RefractionIndex
-        ) noexcept
-{
-    XMVECTOR Index = XMVectorReplicate(RefractionIndex);
-    return XMVector4RefractV(Incident, Normal, Index);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4RefractV
-        (
-                FXMVECTOR Incident,
-                FXMVECTOR Normal,
-                FXMVECTOR RefractionIndex
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTOR        IDotN;
-    XMVECTOR        R;
-    const XMVECTOR  Zero = XMVectorZero();
-
-    // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) +
-    // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal))))
-
-    IDotN = XMVector4Dot(Incident, Normal);
-
-    // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN)
-    R = XMVectorNegativeMultiplySubtract(IDotN, IDotN, g_XMOne.v);
-    R = XMVectorMultiply(R, RefractionIndex);
-    R = XMVectorNegativeMultiplySubtract(R, RefractionIndex, g_XMOne.v);
-
-    if (XMVector4LessOrEqual(R, Zero))
-    {
-        // Total internal reflection
-        return Zero;
-    }
-    else
-    {
-        XMVECTOR Result;
-
-        // R = RefractionIndex * IDotN + sqrt(R)
-        R = XMVectorSqrt(R);
-        R = XMVectorMultiplyAdd(RefractionIndex, IDotN, R);
-
-        // Result = RefractionIndex * Incident - Normal * R
-        Result = XMVectorMultiply(RefractionIndex, Incident);
-        Result = XMVectorNegativeMultiplySubtract(Normal, R, Result);
-
-        return Result;
-    }
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    XMVECTOR IDotN = XMVector4Dot(Incident, Normal);
-
-    // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN)
-    float32x4_t R = vmlsq_f32(g_XMOne, IDotN, IDotN);
-    R = vmulq_f32(R, RefractionIndex);
-    R = vmlsq_f32(g_XMOne, R, RefractionIndex);
-
-    uint32x4_t isrzero = vcleq_f32(R, g_XMZero);
-    uint8x8x2_t vTemp = vzip_u8(vget_low_u8(vreinterpretq_u8_u32(isrzero)), vget_high_u8(vreinterpretq_u8_u32(isrzero)));
-    uint16x4x2_t vTemp2 = vzip_u16(vreinterpret_u16_u8(vTemp.val[0]), vreinterpret_u16_u8(vTemp.val[1]));
-
-    float32x4_t vResult;
-    if (vget_lane_u32(vreinterpret_u32_u16(vTemp2.val[1]), 1) == 0xFFFFFFFFU)
-    {
-        // Total internal reflection
-        vResult = g_XMZero;
-    }
-    else
-    {
-        // Sqrt(R)
-        float32x4_t S0 = vrsqrteq_f32(R);
-        float32x4_t P0 = vmulq_f32(R, S0);
-        float32x4_t R0 = vrsqrtsq_f32(P0, S0);
-        float32x4_t S1 = vmulq_f32(S0, R0);
-        float32x4_t P1 = vmulq_f32(R, S1);
-        float32x4_t R1 = vrsqrtsq_f32(P1, S1);
-        float32x4_t S2 = vmulq_f32(S1, R1);
-        R = vmulq_f32(R, S2);
-        // R = RefractionIndex * IDotN + sqrt(R)
-        R = vmlaq_f32(R, RefractionIndex, IDotN);
-        // Result = RefractionIndex * Incident - Normal * R
-        vResult = vmulq_f32(RefractionIndex, Incident);
-        vResult = vmlsq_f32(vResult, R, Normal);
-    }
-    return vResult;
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR IDotN = XMVector4Dot(Incident, Normal);
-
-    // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN)
-    XMVECTOR R = XM_FNMADD_PS(IDotN, IDotN, g_XMOne);
-    XMVECTOR R2 = _mm_mul_ps(RefractionIndex, RefractionIndex);
-    R = XM_FNMADD_PS(R, R2, g_XMOne);
-
-    XMVECTOR vResult = _mm_cmple_ps(R, g_XMZero);
-    if (_mm_movemask_ps(vResult) == 0x0f)
-    {
-        // Total internal reflection
-        vResult = g_XMZero;
-    }
-    else
-    {
-        // R = RefractionIndex * IDotN + sqrt(R)
-        R = _mm_sqrt_ps(R);
-        R = XM_FMADD_PS(RefractionIndex, IDotN, R);
-        // Result = RefractionIndex * Incident - Normal * R
-        vResult = _mm_mul_ps(RefractionIndex, Incident);
-        vResult = XM_FNMADD_PS(R, Normal, vResult);
-    }
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4Orthogonal(FXMVECTOR V) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    XMVECTORF32 Result = { { {
-            V.vector4_f32[2],
-            V.vector4_f32[3],
-            -V.vector4_f32[0],
-            -V.vector4_f32[1]
-        } } };
-    return Result.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 Negate = { { { 1.f, 1.f, -1.f, -1.f } } };
-
-    float32x4_t Result = vcombine_f32(vget_high_f32(V), vget_low_f32(V));
-    return vmulq_f32(Result, Negate);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 FlipZW = { { { 1.0f, 1.0f, -1.0f, -1.0f } } };
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 0, 3, 2));
-    vResult = _mm_mul_ps(vResult, FlipZW);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4AngleBetweenNormalsEst
-        (
-                FXMVECTOR N1,
-                FXMVECTOR N2
-        ) noexcept
-{
-    XMVECTOR Result = XMVector4Dot(N1, N2);
-    Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v);
-    Result = XMVectorACosEst(Result);
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4AngleBetweenNormals
-        (
-                FXMVECTOR N1,
-                FXMVECTOR N2
-        ) noexcept
-{
-    XMVECTOR Result = XMVector4Dot(N1, N2);
-    Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v);
-    Result = XMVectorACos(Result);
-    return Result;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4AngleBetweenVectors
-        (
-                FXMVECTOR V1,
-                FXMVECTOR V2
-        ) noexcept
-{
-    XMVECTOR L1 = XMVector4ReciprocalLength(V1);
-    XMVECTOR L2 = XMVector4ReciprocalLength(V2);
-
-    XMVECTOR Dot = XMVector4Dot(V1, V2);
-
-    L1 = XMVectorMultiply(L1, L2);
-
-    XMVECTOR CosAngle = XMVectorMultiply(Dot, L1);
-    CosAngle = XMVectorClamp(CosAngle, g_XMNegativeOne.v, g_XMOne.v);
-
-    return XMVectorACos(CosAngle);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV XMVector4Transform
-        (
-                FXMVECTOR V,
-                FXMMATRIX M
-        ) noexcept
-{
-#if defined(_XM_NO_INTRINSICS_)
-
-    float fX = (M.m[0][0] * V.vector4_f32[0]) + (M.m[1][0] * V.vector4_f32[1]) + (M.m[2][0] * V.vector4_f32[2]) + (M.m[3][0] * V.vector4_f32[3]);
-    float fY = (M.m[0][1] * V.vector4_f32[0]) + (M.m[1][1] * V.vector4_f32[1]) + (M.m[2][1] * V.vector4_f32[2]) + (M.m[3][1] * V.vector4_f32[3]);
-    float fZ = (M.m[0][2] * V.vector4_f32[0]) + (M.m[1][2] * V.vector4_f32[1]) + (M.m[2][2] * V.vector4_f32[2]) + (M.m[3][2] * V.vector4_f32[3]);
-    float fW = (M.m[0][3] * V.vector4_f32[0]) + (M.m[1][3] * V.vector4_f32[1]) + (M.m[2][3] * V.vector4_f32[2]) + (M.m[3][3] * V.vector4_f32[3]);
-    XMVECTORF32 vResult = { { { fX, fY, fZ, fW } } };
-    return vResult.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    float32x2_t VL = vget_low_f32(V);
-    XMVECTOR vResult = vmulq_lane_f32(M.r[0], VL, 0); // X
-    vResult = vmlaq_lane_f32(vResult, M.r[1], VL, 1); // Y
-    float32x2_t VH = vget_high_f32(V);
-    vResult = vmlaq_lane_f32(vResult, M.r[2], VH, 0); // Z
-    return vmlaq_lane_f32(vResult, M.r[3], VH, 1); // W
-#elif defined(_XM_SSE_INTRINSICS_)
-    XMVECTOR vResult = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3)); // W
-    vResult = _mm_mul_ps(vResult, M.r[3]);
-    XMVECTOR vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2)); // Z
-    vResult = XM_FMADD_PS(vTemp, M.r[2], vResult);
-    vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1)); // Y
-    vResult = XM_FMADD_PS(vTemp, M.r[1], vResult);
-    vTemp = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0)); // X
-    vResult = XM_FMADD_PS(vTemp, M.r[0], vResult);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-    _Use_decl_annotations_
-inline XMFLOAT4* XM_CALLCONV XMVector4TransformStream
-        (
-                XMFLOAT4* pOutputStream,
-                size_t          OutputStride,
-                const XMFLOAT4* pInputStream,
-                size_t          InputStride,
-                size_t          VectorCount,
-                FXMMATRIX       M
-        ) noexcept
-{
-    assert(pOutputStream != nullptr);
-    assert(pInputStream != nullptr);
-
-    assert(InputStride >= sizeof(XMFLOAT4));
-    _Analysis_assume_(InputStride >= sizeof(XMFLOAT4));
-
-    assert(OutputStride >= sizeof(XMFLOAT4));
-    _Analysis_assume_(OutputStride >= sizeof(XMFLOAT4));
-
-#if defined(_XM_NO_INTRINSICS_)
-
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-    const XMVECTOR row3 = M.r[3];
-
-    for (size_t i = 0; i < VectorCount; i++)
-    {
-        XMVECTOR V = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pInputVector));
-        XMVECTOR W = XMVectorSplatW(V);
-        XMVECTOR Z = XMVectorSplatZ(V);
-        XMVECTOR Y = XMVectorSplatY(V);
-        XMVECTOR X = XMVectorSplatX(V);
-
-        XMVECTOR Result = XMVectorMultiply(W, row3);
-        Result = XMVectorMultiplyAdd(Z, row2, Result);
-        Result = XMVectorMultiplyAdd(Y, row1, Result);
-        Result = XMVectorMultiplyAdd(X, row0, Result);
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015, "PREfast noise: Esp:1307" )
-#endif
-
-        XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(pOutputVector), Result);
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-        pInputVector += InputStride;
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-    const XMVECTOR row3 = M.r[3];
-
-    size_t i = 0;
-    size_t four = VectorCount >> 2;
-    if (four > 0)
-    {
-        if ((InputStride == sizeof(XMFLOAT4)) && (OutputStride == sizeof(XMFLOAT4)))
-        {
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4x4_t V = vld4q_f32(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += sizeof(XMFLOAT4) * 4;
-
-                float32x2_t r = vget_low_f32(row0);
-                XMVECTOR vResult0 = vmulq_lane_f32(V.val[0], r, 0); // Ax
-                XMVECTOR vResult1 = vmulq_lane_f32(V.val[0], r, 1); // Bx
-
-                XM_PREFETCH(pInputVector);
-
-                r = vget_high_f32(row0);
-                XMVECTOR vResult2 = vmulq_lane_f32(V.val[0], r, 0); // Cx
-                XMVECTOR vResult3 = vmulq_lane_f32(V.val[0], r, 1); // Dx
-
-                XM_PREFETCH(pInputVector + XM_CACHE_LINE_SIZE);
-
-                r = vget_low_f32(row1);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[1], r, 0); // Ax+Ey
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[1], r, 1); // Bx+Fy
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 2));
-
-                r = vget_high_f32(row1);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[1], r, 0); // Cx+Gy
-                vResult3 = vmlaq_lane_f32(vResult3, V.val[1], r, 1); // Dx+Hy
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 3));
-
-                r = vget_low_f32(row2);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[2], r, 0); // Ax+Ey+Iz
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[2], r, 1); // Bx+Fy+Jz
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 4));
-
-                r = vget_high_f32(row2);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[2], r, 0); // Cx+Gy+Kz
-                vResult3 = vmlaq_lane_f32(vResult3, V.val[2], r, 1); // Dx+Hy+Lz
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 5));
-
-                r = vget_low_f32(row3);
-                vResult0 = vmlaq_lane_f32(vResult0, V.val[3], r, 0); // Ax+Ey+Iz+Mw
-                vResult1 = vmlaq_lane_f32(vResult1, V.val[3], r, 1); // Bx+Fy+Jz+Nw
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 6));
-
-                r = vget_high_f32(row3);
-                vResult2 = vmlaq_lane_f32(vResult2, V.val[3], r, 0); // Cx+Gy+Kz+Ow
-                vResult3 = vmlaq_lane_f32(vResult3, V.val[3], r, 1); // Dx+Hy+Lz+Pw
-
-                XM_PREFETCH(pInputVector + (XM_CACHE_LINE_SIZE * 7));
-
-                V.val[0] = vResult0;
-                V.val[1] = vResult1;
-                V.val[2] = vResult2;
-                V.val[3] = vResult3;
-
-                vst4q_f32(reinterpret_cast<float*>(pOutputVector), V);
-                pOutputVector += sizeof(XMFLOAT4) * 4;
-
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < VectorCount; i++)
-    {
-        XMVECTOR V = vld1q_f32(reinterpret_cast<const float*>(pInputVector));
-        pInputVector += InputStride;
-
-        float32x2_t VL = vget_low_f32(V);
-        XMVECTOR vResult = vmulq_lane_f32(row0, VL, 0); // X
-        vResult = vmlaq_lane_f32(vResult, row1, VL, 1); // Y
-        float32x2_t VH = vget_high_f32(V);
-        vResult = vmlaq_lane_f32(vResult, row2, VH, 0); // Z
-        vResult = vmlaq_lane_f32(vResult, row3, VH, 1); // W
-
-        vst1q_f32(reinterpret_cast<float*>(pOutputVector), vResult);
-        pOutputVector += OutputStride;
-    }
-
-    return pOutputStream;
-#elif defined(_XM_AVX2_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t two = VectorCount >> 1;
-    if (two > 0)
-    {
-        __m256 row0 = _mm256_broadcast_ps(&M.r[0]);
-        __m256 row1 = _mm256_broadcast_ps(&M.r[1]);
-        __m256 row2 = _mm256_broadcast_ps(&M.r[2]);
-        __m256 row3 = _mm256_broadcast_ps(&M.r[3]);
-
-        if (InputStride == sizeof(XMFLOAT4))
-        {
-            if (OutputStride == sizeof(XMFLOAT4))
-            {
-                if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0x1F))
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < two; ++j)
-                    {
-                        __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT4) * 2;
-
-                        __m256 vTempX = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-                        __m256 vTempY = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                        __m256 vTempZ = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                        __m256 vTempW = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        vTempX = _mm256_mul_ps(vTempX, row0);
-                        vTempY = _mm256_mul_ps(vTempY, row1);
-                        vTempZ = _mm256_fmadd_ps(vTempZ, row2, vTempX);
-                        vTempW = _mm256_fmadd_ps(vTempW, row3, vTempY);
-                        vTempX = _mm256_add_ps(vTempZ, vTempW);
-
-                        XM256_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTempX);
-                        pOutputVector += sizeof(XMFLOAT4) * 2;
-
-                        i += 2;
-                    }
-                }
-                else
-                {
-                    // Packed input, packed output
-                    for (size_t j = 0; j < two; ++j)
-                    {
-                        __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                        pInputVector += sizeof(XMFLOAT4) * 2;
-
-                        __m256 vTempX = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-                        __m256 vTempY = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                        __m256 vTempZ = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                        __m256 vTempW = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-
-                        vTempX = _mm256_mul_ps(vTempX, row0);
-                        vTempY = _mm256_mul_ps(vTempY, row1);
-                        vTempZ = _mm256_fmadd_ps(vTempZ, row2, vTempX);
-                        vTempW = _mm256_fmadd_ps(vTempW, row3, vTempY);
-                        vTempX = _mm256_add_ps(vTempZ, vTempW);
-
-                        _mm256_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTempX);
-                        pOutputVector += sizeof(XMFLOAT4) * 2;
-
-                        i += 2;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, unpacked output
-                for (size_t j = 0; j < two; ++j)
-                {
-                    __m256 VV = _mm256_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                    pInputVector += sizeof(XMFLOAT4) * 2;
-
-                    __m256 vTempX = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(0, 0, 0, 0));
-                    __m256 vTempY = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(1, 1, 1, 1));
-                    __m256 vTempZ = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(2, 2, 2, 2));
-                    __m256 vTempW = _mm256_shuffle_ps(VV, VV, _MM_SHUFFLE(3, 3, 3, 3));
-
-                    vTempX = _mm256_mul_ps(vTempX, row0);
-                    vTempY = _mm256_mul_ps(vTempY, row1);
-                    vTempZ = _mm256_fmadd_ps(vTempZ, row2, vTempX);
-                    vTempW = _mm256_fmadd_ps(vTempW, row3, vTempY);
-                    vTempX = _mm256_add_ps(vTempZ, vTempW);
-
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), _mm256_castps256_ps128(vTempX));
-                    pOutputVector += OutputStride;
-
-                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), _mm256_extractf128_ps(vTempX, 1));
-                    pOutputVector += OutputStride;
-                    i += 2;
-                }
-            }
-        }
-    }
-
-    if (i < VectorCount)
-    {
-        const XMVECTOR row0 = M.r[0];
-        const XMVECTOR row1 = M.r[1];
-        const XMVECTOR row2 = M.r[2];
-        const XMVECTOR row3 = M.r[3];
-
-        for (; i < VectorCount; i++)
-        {
-            __m128 V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-            pInputVector += InputStride;
-
-            XMVECTOR vTempX = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-            XMVECTOR vTempY = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-            XMVECTOR vTempZ = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-            XMVECTOR vTempW = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-
-            vTempX = _mm_mul_ps(vTempX, row0);
-            vTempY = _mm_mul_ps(vTempY, row1);
-            vTempZ = XM_FMADD_PS(vTempZ, row2, vTempX);
-            vTempW = XM_FMADD_PS(vTempW, row3, vTempY);
-            vTempX = _mm_add_ps(vTempZ, vTempW);
-
-            _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTempX);
-            pOutputVector += OutputStride;
-        }
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#elif defined(_XM_SSE_INTRINSICS_)
-    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    const XMVECTOR row0 = M.r[0];
-    const XMVECTOR row1 = M.r[1];
-    const XMVECTOR row2 = M.r[2];
-    const XMVECTOR row3 = M.r[3];
-
-    if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF))
-    {
-        if (!(reinterpret_cast<uintptr_t>(pInputStream) & 0xF) && !(InputStride & 0xF))
-        {
-            // Aligned input, aligned output
-            for (size_t i = 0; i < VectorCount; i++)
-            {
-                __m128 V = _mm_load_ps(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += InputStride;
-
-                XMVECTOR vTempX = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-                XMVECTOR vTempY = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                XMVECTOR vTempZ = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-                XMVECTOR vTempW = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-
-                vTempX = _mm_mul_ps(vTempX, row0);
-                vTempY = _mm_mul_ps(vTempY, row1);
-                vTempZ = XM_FMADD_PS(vTempZ, row2, vTempX);
-                vTempW = XM_FMADD_PS(vTempW, row3, vTempY);
-                vTempX = _mm_add_ps(vTempZ, vTempW);
-
-                XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTempX);
-                pOutputVector += OutputStride;
-            }
-        }
-        else
-        {
-            // Unaligned input, aligned output
-            for (size_t i = 0; i < VectorCount; i++)
-            {
-                __m128 V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += InputStride;
-
-                XMVECTOR vTempX = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-                XMVECTOR vTempY = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                XMVECTOR vTempZ = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-                XMVECTOR vTempW = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-
-                vTempX = _mm_mul_ps(vTempX, row0);
-                vTempY = _mm_mul_ps(vTempY, row1);
-                vTempZ = XM_FMADD_PS(vTempZ, row2, vTempX);
-                vTempW = XM_FMADD_PS(vTempW, row3, vTempY);
-                vTempX = _mm_add_ps(vTempZ, vTempW);
-
-                XM_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTempX);
-                pOutputVector += OutputStride;
-            }
-        }
-    }
-    else
-    {
-        if (!(reinterpret_cast<uintptr_t>(pInputStream) & 0xF) && !(InputStride & 0xF))
-        {
-            // Aligned input, unaligned output
-            for (size_t i = 0; i < VectorCount; i++)
-            {
-                __m128 V = _mm_load_ps(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += InputStride;
-
-                XMVECTOR vTempX = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-                XMVECTOR vTempY = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                XMVECTOR vTempZ = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-                XMVECTOR vTempW = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-
-                vTempX = _mm_mul_ps(vTempX, row0);
-                vTempY = _mm_mul_ps(vTempY, row1);
-                vTempZ = XM_FMADD_PS(vTempZ, row2, vTempX);
-                vTempW = XM_FMADD_PS(vTempW, row3, vTempY);
-                vTempX = _mm_add_ps(vTempZ, vTempW);
-
-                _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTempX);
-                pOutputVector += OutputStride;
-            }
-        }
-        else
-        {
-            // Unaligned input, unaligned output
-            for (size_t i = 0; i < VectorCount; i++)
-            {
-                __m128 V = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
-                pInputVector += InputStride;
-
-                XMVECTOR vTempX = XM_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
-                XMVECTOR vTempY = XM_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
-                XMVECTOR vTempZ = XM_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
-                XMVECTOR vTempW = XM_PERMUTE_PS(V, _MM_SHUFFLE(3, 3, 3, 3));
-
-                vTempX = _mm_mul_ps(vTempX, row0);
-                vTempY = _mm_mul_ps(vTempY, row1);
-                vTempZ = XM_FMADD_PS(vTempZ, row2, vTempX);
-                vTempW = XM_FMADD_PS(vTempW, row3, vTempY);
-                vTempX = _mm_add_ps(vTempZ, vTempW);
-
-                _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTempX);
-                pOutputVector += OutputStride;
-            }
-        }
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#endif
-}
-
-/****************************************************************************
- *
- * XMVECTOR operators
- *
- ****************************************************************************/
-
-#ifndef _XM_NO_XMVECTOR_OVERLOADS_
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV operator+ (FXMVECTOR V) noexcept
-{
-    return V;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV operator- (FXMVECTOR V) noexcept
-{
-    return XMVectorNegate(V);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR& XM_CALLCONV operator+=
-(
-    XMVECTOR& V1,
-    FXMVECTOR       V2
-) noexcept
-{
-    V1 = XMVectorAdd(V1, V2);
-    return V1;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR& XM_CALLCONV operator-=
-(
-    XMVECTOR& V1,
-    FXMVECTOR       V2
-) noexcept
-{
-    V1 = XMVectorSubtract(V1, V2);
-    return V1;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR& XM_CALLCONV operator*=
-(
-    XMVECTOR& V1,
-    FXMVECTOR       V2
-) noexcept
-{
-    V1 = XMVectorMultiply(V1, V2);
-    return V1;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR& XM_CALLCONV operator/=
-(
-    XMVECTOR& V1,
-    FXMVECTOR       V2
-) noexcept
-{
-    V1 = XMVectorDivide(V1, V2);
-    return V1;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR& operator*=
-(
-    XMVECTOR& V,
-    const float S
-) noexcept
-{
-    V = XMVectorScale(V, S);
-    return V;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR& operator/=
-(
-    XMVECTOR& V,
-    const float S
-) noexcept
-{
-    XMVECTOR vS = XMVectorReplicate(S);
-    V = XMVectorDivide(V, vS);
-    return V;
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV operator+
-(
-    FXMVECTOR V1,
-    FXMVECTOR V2
-) noexcept
-{
-    return XMVectorAdd(V1, V2);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV operator-
-(
-    FXMVECTOR V1,
-    FXMVECTOR V2
-) noexcept
-{
-    return XMVectorSubtract(V1, V2);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV operator*
-(
-    FXMVECTOR V1,
-    FXMVECTOR V2
-) noexcept
-{
-    return XMVectorMultiply(V1, V2);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV operator/
-(
-    FXMVECTOR V1,
-    FXMVECTOR V2
-) noexcept
-{
-    return XMVectorDivide(V1, V2);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV operator*
-(
-    FXMVECTOR      V,
-    const float    S
-) noexcept
-{
-    return XMVectorScale(V, S);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV operator/
-(
-    FXMVECTOR      V,
-    const float    S
-) noexcept
-{
-    XMVECTOR vS = XMVectorReplicate(S);
-    return XMVectorDivide(V, vS);
-}
-
-//------------------------------------------------------------------------------
-
-inline XMVECTOR XM_CALLCONV operator*
-(
-    float           S,
-    FXMVECTOR       V
-) noexcept
-{
-    return XMVectorScale(V, S);
-}
-
-#endif /* !_XM_NO_XMVECTOR_OVERLOADS_ */
-
-#if defined(_XM_NO_INTRINSICS_)
-#undef XMISNAN
-#undef XMISINF
-#endif
-
-#if defined(_XM_SSE_INTRINSICS_)
-#undef XM3UNPACK3INTO4
-#undef XM3PACK4INTO3
-#endif
-
diff --git a/thirdparty/directxmath/DirectXPackedVector.h b/thirdparty/directxmath/DirectXPackedVector.h
deleted file mode 100644
index 354caca..0000000
--- a/thirdparty/directxmath/DirectXPackedVector.h
+++ /dev/null
@@ -1,1224 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXPackedVector.h -- SIMD C++ Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-#include "./DirectXMath.h"
-
-namespace DirectX
-{
-
-    namespace PackedVector
-    {
-#ifdef _MSC_VER
-        #pragma warning(push)
-#pragma warning(disable:4201 4365 4324 4996)
-        // C4201: nonstandard extension used
-        // C4365: Off by default noise
-        // C4324: alignment padding warnings
-        // C4996: deprecation warnings
-#endif
-
-#ifdef __clang__
-        #pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
-#pragma clang diagnostic ignored "-Wnested-anon-types"
-#endif
-
-        //------------------------------------------------------------------------------
-        // ARGB Color; 8-8-8-8 bit unsigned normalized integer components packed into
-        // a 32 bit integer.  The normalized color is packed into 32 bits using 8 bit
-        // unsigned, normalized integers for the alpha, red, green, and blue components.
-        // The alpha component is stored in the most significant bits and the blue
-        // component in the least significant bits (A8R8G8B8):
-        // [32] aaaaaaaa rrrrrrrr gggggggg bbbbbbbb [0]
-        struct XMCOLOR
-        {
-            union
-            {
-                struct
-                {
-                    uint8_t b;  // Blue:    0/255 to 255/255
-                    uint8_t g;  // Green:   0/255 to 255/255
-                    uint8_t r;  // Red:     0/255 to 255/255
-                    uint8_t a;  // Alpha:   0/255 to 255/255
-                };
-                uint32_t c;
-            };
-
-            XMCOLOR() = default;
-
-            XMCOLOR(const XMCOLOR&) = default;
-            XMCOLOR& operator=(const XMCOLOR&) = default;
-
-            XMCOLOR(XMCOLOR&&) = default;
-            XMCOLOR& operator=(XMCOLOR&&) = default;
-
-            constexpr XMCOLOR(uint32_t Color) noexcept : c(Color) {}
-            XMCOLOR(float _r, float _g, float _b, float _a) noexcept;
-            explicit XMCOLOR(_In_reads_(4) const float* pArray) noexcept;
-
-            operator uint32_t () const noexcept { return c; }
-
-            XMCOLOR& operator= (const uint32_t Color) noexcept { c = Color; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 16 bit floating point number consisting of a sign bit, a 5 bit biased
-        // exponent, and a 10 bit mantissa
-        using HALF = uint16_t;
-
-        //------------------------------------------------------------------------------
-        // 2D Vector; 16 bit floating point components
-        struct XMHALF2
-        {
-            union
-            {
-                struct
-                {
-                    HALF x;
-                    HALF y;
-                };
-                uint32_t v;
-            };
-
-            XMHALF2() = default;
-
-            XMHALF2(const XMHALF2&) = default;
-            XMHALF2& operator=(const XMHALF2&) = default;
-
-            XMHALF2(XMHALF2&&) = default;
-            XMHALF2& operator=(XMHALF2&&) = default;
-
-            explicit constexpr XMHALF2(uint32_t Packed) noexcept : v(Packed) {}
-            constexpr XMHALF2(HALF _x, HALF _y) noexcept : x(_x), y(_y) {}
-            explicit XMHALF2(_In_reads_(2) const HALF* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-            XMHALF2(float _x, float _y) noexcept;
-            explicit XMHALF2(_In_reads_(2) const float* pArray) noexcept;
-
-            XMHALF2& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 2D Vector; 16 bit signed normalized integer components
-        struct XMSHORTN2
-        {
-            union
-            {
-                struct
-                {
-                    int16_t x;
-                    int16_t y;
-                };
-                uint32_t v;
-            };
-
-            XMSHORTN2() = default;
-
-            XMSHORTN2(const XMSHORTN2&) = default;
-            XMSHORTN2& operator=(const XMSHORTN2&) = default;
-
-            XMSHORTN2(XMSHORTN2&&) = default;
-            XMSHORTN2& operator=(XMSHORTN2&&) = default;
-
-            explicit constexpr XMSHORTN2(uint32_t Packed) noexcept : v(Packed) {}
-            constexpr XMSHORTN2(int16_t _x, int16_t _y) noexcept : x(_x), y(_y) {}
-            explicit XMSHORTN2(_In_reads_(2) const int16_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-            XMSHORTN2(float _x, float _y) noexcept;
-            explicit XMSHORTN2(_In_reads_(2) const float* pArray) noexcept;
-
-            XMSHORTN2& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 2D Vector; 16 bit signed integer components
-        struct XMSHORT2
-        {
-            union
-            {
-                struct
-                {
-                    int16_t x;
-                    int16_t y;
-                };
-                uint32_t v;
-            };
-
-            XMSHORT2() = default;
-
-            XMSHORT2(const XMSHORT2&) = default;
-            XMSHORT2& operator=(const XMSHORT2&) = default;
-
-            XMSHORT2(XMSHORT2&&) = default;
-            XMSHORT2& operator=(XMSHORT2&&) = default;
-
-            explicit constexpr XMSHORT2(uint32_t Packed) noexcept : v(Packed) {}
-            constexpr XMSHORT2(int16_t _x, int16_t _y) noexcept : x(_x), y(_y) {}
-            explicit XMSHORT2(_In_reads_(2) const int16_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-            XMSHORT2(float _x, float _y) noexcept;
-            explicit XMSHORT2(_In_reads_(2) const float* pArray) noexcept;
-
-            XMSHORT2& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 2D Vector; 16 bit unsigned normalized integer components
-        struct XMUSHORTN2
-        {
-            union
-            {
-                struct
-                {
-                    uint16_t x;
-                    uint16_t y;
-                };
-                uint32_t v;
-            };
-
-            XMUSHORTN2() = default;
-
-            XMUSHORTN2(const XMUSHORTN2&) = default;
-            XMUSHORTN2& operator=(const XMUSHORTN2&) = default;
-
-            XMUSHORTN2(XMUSHORTN2&&) = default;
-            XMUSHORTN2& operator=(XMUSHORTN2&&) = default;
-
-            explicit constexpr XMUSHORTN2(uint32_t Packed) noexcept : v(Packed) {}
-            constexpr XMUSHORTN2(uint16_t _x, uint16_t _y) noexcept : x(_x), y(_y) {}
-            explicit XMUSHORTN2(_In_reads_(2) const uint16_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-            XMUSHORTN2(float _x, float _y) noexcept;
-            explicit XMUSHORTN2(_In_reads_(2) const float* pArray) noexcept;
-
-            XMUSHORTN2& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 2D Vector; 16 bit unsigned integer components
-        struct XMUSHORT2
-        {
-            union
-            {
-                struct
-                {
-                    uint16_t x;
-                    uint16_t y;
-                };
-                uint32_t v;
-            };
-
-            XMUSHORT2() = default;
-
-            XMUSHORT2(const XMUSHORT2&) = default;
-            XMUSHORT2& operator=(const XMUSHORT2&) = default;
-
-            XMUSHORT2(XMUSHORT2&&) = default;
-            XMUSHORT2& operator=(XMUSHORT2&&) = default;
-
-            explicit constexpr XMUSHORT2(uint32_t Packed) noexcept : v(Packed) {}
-            constexpr XMUSHORT2(uint16_t _x, uint16_t _y) noexcept : x(_x), y(_y) {}
-            explicit XMUSHORT2(_In_reads_(2) const uint16_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-            XMUSHORT2(float _x, float _y) noexcept;
-            explicit XMUSHORT2(_In_reads_(2) const float* pArray) noexcept;
-
-            XMUSHORT2& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 2D Vector; 8 bit signed normalized integer components
-        struct XMBYTEN2
-        {
-            union
-            {
-                struct
-                {
-                    int8_t x;
-                    int8_t y;
-                };
-                uint16_t v;
-            };
-
-            XMBYTEN2() = default;
-
-            XMBYTEN2(const XMBYTEN2&) = default;
-            XMBYTEN2& operator=(const XMBYTEN2&) = default;
-
-            XMBYTEN2(XMBYTEN2&&) = default;
-            XMBYTEN2& operator=(XMBYTEN2&&) = default;
-
-            explicit constexpr XMBYTEN2(uint16_t Packed) noexcept : v(Packed) {}
-            constexpr XMBYTEN2(int8_t _x, int8_t _y) noexcept : x(_x), y(_y) {}
-            explicit XMBYTEN2(_In_reads_(2) const int8_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-            XMBYTEN2(float _x, float _y) noexcept;
-            explicit XMBYTEN2(_In_reads_(2) const float* pArray) noexcept;
-
-            XMBYTEN2& operator= (uint16_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 2D Vector; 8 bit signed integer components
-        struct XMBYTE2
-        {
-            union
-            {
-                struct
-                {
-                    int8_t x;
-                    int8_t y;
-                };
-                uint16_t v;
-            };
-
-            XMBYTE2() = default;
-
-            XMBYTE2(const XMBYTE2&) = default;
-            XMBYTE2& operator=(const XMBYTE2&) = default;
-
-            XMBYTE2(XMBYTE2&&) = default;
-            XMBYTE2& operator=(XMBYTE2&&) = default;
-
-            explicit constexpr XMBYTE2(uint16_t Packed) noexcept : v(Packed) {}
-            constexpr XMBYTE2(int8_t _x, int8_t _y) noexcept : x(_x), y(_y) {}
-            explicit XMBYTE2(_In_reads_(2) const int8_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-            XMBYTE2(float _x, float _y) noexcept;
-            explicit XMBYTE2(_In_reads_(2) const float* pArray) noexcept;
-
-            XMBYTE2& operator= (uint16_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 2D Vector; 8 bit unsigned normalized integer components
-        struct XMUBYTEN2
-        {
-            union
-            {
-                struct
-                {
-                    uint8_t x;
-                    uint8_t y;
-                };
-                uint16_t v;
-            };
-
-            XMUBYTEN2() = default;
-
-            XMUBYTEN2(const XMUBYTEN2&) = default;
-            XMUBYTEN2& operator=(const XMUBYTEN2&) = default;
-
-            XMUBYTEN2(XMUBYTEN2&&) = default;
-            XMUBYTEN2& operator=(XMUBYTEN2&&) = default;
-
-            explicit constexpr XMUBYTEN2(uint16_t Packed) noexcept : v(Packed) {}
-            constexpr XMUBYTEN2(uint8_t _x, uint8_t _y) noexcept : x(_x), y(_y) {}
-            explicit XMUBYTEN2(_In_reads_(2) const uint8_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-            XMUBYTEN2(float _x, float _y) noexcept;
-            explicit XMUBYTEN2(_In_reads_(2) const float* pArray) noexcept;
-
-            XMUBYTEN2& operator= (uint16_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 2D Vector; 8 bit unsigned integer components
-        struct XMUBYTE2
-        {
-            union
-            {
-                struct
-                {
-                    uint8_t x;
-                    uint8_t y;
-                };
-                uint16_t v;
-            };
-
-            XMUBYTE2() = default;
-
-            XMUBYTE2(const XMUBYTE2&) = default;
-            XMUBYTE2& operator=(const XMUBYTE2&) = default;
-
-            XMUBYTE2(XMUBYTE2&&) = default;
-            XMUBYTE2& operator=(XMUBYTE2&&) = default;
-
-            explicit constexpr XMUBYTE2(uint16_t Packed) noexcept : v(Packed) {}
-            constexpr XMUBYTE2(uint8_t _x, uint8_t _y) noexcept : x(_x), y(_y) {}
-            explicit XMUBYTE2(_In_reads_(2) const uint8_t* pArray) noexcept : x(pArray[0]), y(pArray[1]) {}
-            XMUBYTE2(float _x, float _y) noexcept;
-            explicit XMUBYTE2(_In_reads_(2) const float* pArray) noexcept;
-
-            XMUBYTE2& operator= (uint16_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 3D vector: 5/6/5 unsigned integer components
-        struct XMU565
-        {
-            union
-            {
-                struct
-                {
-                    uint16_t x : 5;    // 0 to 31
-                    uint16_t y : 6;    // 0 to 63
-                    uint16_t z : 5;    // 0 to 31
-                };
-                uint16_t v;
-            };
-
-            XMU565() = default;
-
-            XMU565(const XMU565&) = default;
-            XMU565& operator=(const XMU565&) = default;
-
-            XMU565(XMU565&&) = default;
-            XMU565& operator=(XMU565&&) = default;
-
-            explicit constexpr XMU565(uint16_t Packed) noexcept : v(Packed) {}
-            constexpr XMU565(uint8_t _x, uint8_t _y, uint8_t _z) noexcept : x(_x), y(_y), z(_z) {}
-            explicit XMU565(_In_reads_(3) const uint8_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
-            XMU565(float _x, float _y, float _z) noexcept;
-            explicit XMU565(_In_reads_(3) const float* pArray) noexcept;
-
-            operator uint16_t () const noexcept { return v; }
-
-            XMU565& operator= (uint16_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 3D vector: 11/11/10 floating-point components
-        // The 3D vector is packed into 32 bits as follows: a 5-bit biased exponent
-        // and 6-bit mantissa for x component, a 5-bit biased exponent and
-        // 6-bit mantissa for y component, a 5-bit biased exponent and a 5-bit
-        // mantissa for z. The z component is stored in the most significant bits
-        // and the x component in the least significant bits. No sign bits so
-        // all partial-precision numbers are positive.
-        // (Z10Y11X11): [32] ZZZZZzzz zzzYYYYY yyyyyyXX XXXxxxxx [0]
-        struct XMFLOAT3PK
-        {
-            union
-            {
-                struct
-                {
-                    uint32_t xm : 6; // x-mantissa
-                    uint32_t xe : 5; // x-exponent
-                    uint32_t ym : 6; // y-mantissa
-                    uint32_t ye : 5; // y-exponent
-                    uint32_t zm : 5; // z-mantissa
-                    uint32_t ze : 5; // z-exponent
-                };
-                uint32_t v;
-            };
-
-            XMFLOAT3PK() = default;
-
-            XMFLOAT3PK(const XMFLOAT3PK&) = default;
-            XMFLOAT3PK& operator=(const XMFLOAT3PK&) = default;
-
-            XMFLOAT3PK(XMFLOAT3PK&&) = default;
-            XMFLOAT3PK& operator=(XMFLOAT3PK&&) = default;
-
-            explicit constexpr XMFLOAT3PK(uint32_t Packed) noexcept : v(Packed) {}
-            XMFLOAT3PK(float _x, float _y, float _z) noexcept;
-            explicit XMFLOAT3PK(_In_reads_(3) const float* pArray) noexcept;
-
-            operator uint32_t () const noexcept { return v; }
-
-            XMFLOAT3PK& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 3D vector: 9/9/9 floating-point components with shared 5-bit exponent
-        // The 3D vector is packed into 32 bits as follows: a 5-bit biased exponent
-        // with 9-bit mantissa for the x, y, and z component. The shared exponent
-        // is stored in the most significant bits and the x component mantissa is in
-        // the least significant bits. No sign bits so all partial-precision numbers
-        // are positive.
-        // (E5Z9Y9X9): [32] EEEEEzzz zzzzzzyy yyyyyyyx xxxxxxxx [0]
-        struct XMFLOAT3SE
-        {
-            union
-            {
-                struct
-                {
-                    uint32_t xm : 9; // x-mantissa
-                    uint32_t ym : 9; // y-mantissa
-                    uint32_t zm : 9; // z-mantissa
-                    uint32_t e : 5; // shared exponent
-                };
-                uint32_t v;
-            };
-
-            XMFLOAT3SE() = default;
-
-            XMFLOAT3SE(const XMFLOAT3SE&) = default;
-            XMFLOAT3SE& operator=(const XMFLOAT3SE&) = default;
-
-            XMFLOAT3SE(XMFLOAT3SE&&) = default;
-            XMFLOAT3SE& operator=(XMFLOAT3SE&&) = default;
-
-            explicit constexpr XMFLOAT3SE(uint32_t Packed) noexcept : v(Packed) {}
-            XMFLOAT3SE(float _x, float _y, float _z) noexcept;
-            explicit XMFLOAT3SE(_In_reads_(3) const float* pArray) noexcept;
-
-            operator uint32_t () const noexcept { return v; }
-
-            XMFLOAT3SE& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 4D Vector; 16 bit floating point components
-        struct XMHALF4
-        {
-            union
-            {
-                struct
-                {
-                    HALF x;
-                    HALF y;
-                    HALF z;
-                    HALF w;
-                };
-                uint64_t v;
-            };
-
-            XMHALF4() = default;
-
-            XMHALF4(const XMHALF4&) = default;
-            XMHALF4& operator=(const XMHALF4&) = default;
-
-            XMHALF4(XMHALF4&&) = default;
-            XMHALF4& operator=(XMHALF4&&) = default;
-
-            explicit constexpr XMHALF4(uint64_t Packed) noexcept : v(Packed) {}
-            constexpr XMHALF4(HALF _x, HALF _y, HALF _z, HALF _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit XMHALF4(_In_reads_(4) const HALF* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMHALF4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMHALF4(_In_reads_(4) const float* pArray) noexcept;
-
-            XMHALF4& operator= (uint64_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 4D Vector; 16 bit signed normalized integer components
-        struct XMSHORTN4
-        {
-            union
-            {
-                struct
-                {
-                    int16_t x;
-                    int16_t y;
-                    int16_t z;
-                    int16_t w;
-                };
-                uint64_t v;
-            };
-
-            XMSHORTN4() = default;
-
-            XMSHORTN4(const XMSHORTN4&) = default;
-            XMSHORTN4& operator=(const XMSHORTN4&) = default;
-
-            XMSHORTN4(XMSHORTN4&&) = default;
-            XMSHORTN4& operator=(XMSHORTN4&&) = default;
-
-            explicit constexpr XMSHORTN4(uint64_t Packed) noexcept : v(Packed) {}
-            constexpr XMSHORTN4(int16_t _x, int16_t _y, int16_t _z, int16_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit XMSHORTN4(_In_reads_(4) const int16_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMSHORTN4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMSHORTN4(_In_reads_(4) const float* pArray) noexcept;
-
-            XMSHORTN4& operator= (uint64_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 16 bit signed integer components
-        struct XMSHORT4
-        {
-            union
-            {
-                struct
-                {
-                    int16_t x;
-                    int16_t y;
-                    int16_t z;
-                    int16_t w;
-                };
-                uint64_t v;
-            };
-
-            XMSHORT4() = default;
-
-            XMSHORT4(const XMSHORT4&) = default;
-            XMSHORT4& operator=(const XMSHORT4&) = default;
-
-            XMSHORT4(XMSHORT4&&) = default;
-            XMSHORT4& operator=(XMSHORT4&&) = default;
-
-            explicit constexpr XMSHORT4(uint64_t Packed) noexcept : v(Packed) {}
-            constexpr XMSHORT4(int16_t _x, int16_t _y, int16_t _z, int16_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit XMSHORT4(_In_reads_(4) const int16_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMSHORT4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMSHORT4(_In_reads_(4) const float* pArray) noexcept;
-
-            XMSHORT4& operator= (uint64_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 16 bit unsigned normalized integer components
-        struct XMUSHORTN4
-        {
-            union
-            {
-                struct
-                {
-                    uint16_t x;
-                    uint16_t y;
-                    uint16_t z;
-                    uint16_t w;
-                };
-                uint64_t v;
-            };
-
-            XMUSHORTN4() = default;
-
-            XMUSHORTN4(const XMUSHORTN4&) = default;
-            XMUSHORTN4& operator=(const XMUSHORTN4&) = default;
-
-            XMUSHORTN4(XMUSHORTN4&&) = default;
-            XMUSHORTN4& operator=(XMUSHORTN4&&) = default;
-
-            explicit constexpr XMUSHORTN4(uint64_t Packed) noexcept : v(Packed) {}
-            constexpr XMUSHORTN4(uint16_t _x, uint16_t _y, uint16_t _z, uint16_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit XMUSHORTN4(_In_reads_(4) const uint16_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMUSHORTN4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMUSHORTN4(_In_reads_(4) const float* pArray) noexcept;
-
-            XMUSHORTN4& operator= (uint64_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 16 bit unsigned integer components
-        struct XMUSHORT4
-        {
-            union
-            {
-                struct
-                {
-                    uint16_t x;
-                    uint16_t y;
-                    uint16_t z;
-                    uint16_t w;
-                };
-                uint64_t v;
-            };
-
-            XMUSHORT4() = default;
-
-            XMUSHORT4(const XMUSHORT4&) = default;
-            XMUSHORT4& operator=(const XMUSHORT4&) = default;
-
-            XMUSHORT4(XMUSHORT4&&) = default;
-            XMUSHORT4& operator=(XMUSHORT4&&) = default;
-
-            explicit constexpr XMUSHORT4(uint64_t Packed) noexcept : v(Packed) {}
-            constexpr XMUSHORT4(uint16_t _x, uint16_t _y, uint16_t _z, uint16_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit XMUSHORT4(_In_reads_(4) const uint16_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMUSHORT4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMUSHORT4(_In_reads_(4) const float* pArray) noexcept;
-
-            XMUSHORT4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
-        // The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
-        // normalized integer for the w component and 10 bit signed, normalized
-        // integers for the z, y, and x components.  The w component is stored in the
-        // most significant bits and the x component in the least significant bits
-        // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
-        struct XMXDECN4
-        {
-            union
-            {
-                struct
-                {
-                    int32_t x : 10;    // -511/511 to 511/511
-                    int32_t y : 10;    // -511/511 to 511/511
-                    int32_t z : 10;    // -511/511 to 511/511
-                    uint32_t w : 2;     //      0/3 to     3/3
-                };
-                uint32_t v;
-            };
-
-            XMXDECN4() = default;
-
-            XMXDECN4(const XMXDECN4&) = default;
-            XMXDECN4& operator=(const XMXDECN4&) = default;
-
-            XMXDECN4(XMXDECN4&&) = default;
-            XMXDECN4& operator=(XMXDECN4&&) = default;
-
-            explicit constexpr XMXDECN4(uint32_t Packed) : v(Packed) {}
-            XMXDECN4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMXDECN4(_In_reads_(4) const float* pArray) noexcept;
-
-            operator uint32_t () const noexcept { return v; }
-
-            XMXDECN4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
-        // The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned
-        // integer for the w component and 10 bit signed integers for the
-        // z, y, and x components.  The w component is stored in the
-        // most significant bits and the x component in the least significant bits
-        // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
-        struct XM_DEPRECATED XMXDEC4
-        {
-            union
-            {
-                struct
-                {
-                    int32_t x : 10;    // -511 to 511
-                    int32_t y : 10;    // -511 to 511
-                    int32_t z : 10;    // -511 to 511
-                    uint32_t w : 2;     // 0 to 3
-                };
-                uint32_t v;
-            };
-
-            XMXDEC4() = default;
-
-            XMXDEC4(const XMXDEC4&) = default;
-            XMXDEC4& operator=(const XMXDEC4&) = default;
-
-            XMXDEC4(XMXDEC4&&) = default;
-            XMXDEC4& operator=(XMXDEC4&&) = default;
-
-            explicit constexpr XMXDEC4(uint32_t Packed) noexcept : v(Packed) {}
-            XMXDEC4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMXDEC4(_In_reads_(4) const float* pArray) noexcept;
-
-            operator uint32_t () const noexcept { return v; }
-
-            XMXDEC4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
-        // The normalized 4D Vector is packed into 32 bits as follows: a 2 bit signed,
-        // normalized integer for the w component and 10 bit signed, normalized
-        // integers for the z, y, and x components.  The w component is stored in the
-        // most significant bits and the x component in the least significant bits
-        // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
-        struct XM_DEPRECATED XMDECN4
-        {
-            union
-            {
-                struct
-                {
-                    int32_t x : 10;    // -511/511 to 511/511
-                    int32_t y : 10;    // -511/511 to 511/511
-                    int32_t z : 10;    // -511/511 to 511/511
-                    int32_t w : 2;     //     -1/1 to     1/1
-                };
-                uint32_t v;
-            };
-
-            XMDECN4() = default;
-
-            XMDECN4(const XMDECN4&) = default;
-            XMDECN4& operator=(const XMDECN4&) = default;
-
-            XMDECN4(XMDECN4&&) = default;
-            XMDECN4& operator=(XMDECN4&&) = default;
-
-            explicit constexpr XMDECN4(uint32_t Packed) noexcept : v(Packed) {}
-            XMDECN4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMDECN4(_In_reads_(4) const float* pArray) noexcept;
-
-            operator uint32_t () const noexcept { return v; }
-
-            XMDECN4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
-        // The 4D Vector is packed into 32 bits as follows: a 2 bit signed,
-        // integer for the w component and 10 bit signed integers for the
-        // z, y, and x components.  The w component is stored in the
-        // most significant bits and the x component in the least significant bits
-        // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
-        struct XM_DEPRECATED XMDEC4
-        {
-            union
-            {
-                struct
-                {
-                    int32_t  x : 10;    // -511 to 511
-                    int32_t  y : 10;    // -511 to 511
-                    int32_t  z : 10;    // -511 to 511
-                    int32_t  w : 2;     //   -1 to   1
-                };
-                uint32_t v;
-            };
-
-            XMDEC4() = default;
-
-            XMDEC4(const XMDEC4&) = default;
-            XMDEC4& operator=(const XMDEC4&) = default;
-
-            XMDEC4(XMDEC4&&) = default;
-            XMDEC4& operator=(XMDEC4&&) = default;
-
-            explicit constexpr XMDEC4(uint32_t Packed) noexcept : v(Packed) {}
-            XMDEC4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMDEC4(_In_reads_(4) const float* pArray) noexcept;
-
-            operator uint32_t () const noexcept { return v; }
-
-            XMDEC4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
-        // The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
-        // normalized integer for the w component and 10 bit unsigned, normalized
-        // integers for the z, y, and x components.  The w component is stored in the
-        // most significant bits and the x component in the least significant bits
-        // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
-        struct XMUDECN4
-        {
-            union
-            {
-                struct
-                {
-                    uint32_t x : 10;    // 0/1023 to 1023/1023
-                    uint32_t y : 10;    // 0/1023 to 1023/1023
-                    uint32_t z : 10;    // 0/1023 to 1023/1023
-                    uint32_t w : 2;     //    0/3 to       3/3
-                };
-                uint32_t v;
-            };
-
-            XMUDECN4() = default;
-
-            XMUDECN4(const XMUDECN4&) = default;
-            XMUDECN4& operator=(const XMUDECN4&) = default;
-
-            XMUDECN4(XMUDECN4&&) = default;
-            XMUDECN4& operator=(XMUDECN4&&) = default;
-
-            explicit constexpr XMUDECN4(uint32_t Packed) noexcept : v(Packed) {}
-            XMUDECN4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMUDECN4(_In_reads_(4) const float* pArray) noexcept;
-
-            operator uint32_t () const noexcept { return v; }
-
-            XMUDECN4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
-        // The 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
-        // integer for the w component and 10 bit unsigned integers
-        // for the z, y, and x components.  The w component is stored in the
-        // most significant bits and the x component in the least significant bits
-        // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
-        struct XMUDEC4
-        {
-            union
-            {
-                struct
-                {
-                    uint32_t x : 10;    // 0 to 1023
-                    uint32_t y : 10;    // 0 to 1023
-                    uint32_t z : 10;    // 0 to 1023
-                    uint32_t w : 2;     // 0 to    3
-                };
-                uint32_t v;
-            };
-
-            XMUDEC4() = default;
-
-            XMUDEC4(const XMUDEC4&) = default;
-            XMUDEC4& operator=(const XMUDEC4&) = default;
-
-            XMUDEC4(XMUDEC4&&) = default;
-            XMUDEC4& operator=(XMUDEC4&&) = default;
-
-            explicit constexpr XMUDEC4(uint32_t Packed) noexcept : v(Packed) {}
-            XMUDEC4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMUDEC4(_In_reads_(4) const float* pArray) noexcept;
-
-            operator uint32_t () const noexcept { return v; }
-
-            XMUDEC4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 4D Vector; 8 bit signed normalized integer components
-        struct XMBYTEN4
-        {
-            union
-            {
-                struct
-                {
-                    int8_t x;
-                    int8_t y;
-                    int8_t z;
-                    int8_t w;
-                };
-                uint32_t v;
-            };
-
-            XMBYTEN4() = default;
-
-            XMBYTEN4(const XMBYTEN4&) = default;
-            XMBYTEN4& operator=(const XMBYTEN4&) = default;
-
-            XMBYTEN4(XMBYTEN4&&) = default;
-            XMBYTEN4& operator=(XMBYTEN4&&) = default;
-
-            constexpr XMBYTEN4(int8_t _x, int8_t _y, int8_t _z, int8_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit constexpr XMBYTEN4(uint32_t Packed) noexcept : v(Packed) {}
-            explicit XMBYTEN4(_In_reads_(4) const int8_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMBYTEN4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMBYTEN4(_In_reads_(4) const float* pArray) noexcept;
-
-            XMBYTEN4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 8 bit signed integer components
-        struct XMBYTE4
-        {
-            union
-            {
-                struct
-                {
-                    int8_t x;
-                    int8_t y;
-                    int8_t z;
-                    int8_t w;
-                };
-                uint32_t v;
-            };
-
-            XMBYTE4() = default;
-
-            XMBYTE4(const XMBYTE4&) = default;
-            XMBYTE4& operator=(const XMBYTE4&) = default;
-
-            XMBYTE4(XMBYTE4&&) = default;
-            XMBYTE4& operator=(XMBYTE4&&) = default;
-
-            constexpr XMBYTE4(int8_t _x, int8_t _y, int8_t _z, int8_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit constexpr XMBYTE4(uint32_t Packed) noexcept : v(Packed) {}
-            explicit XMBYTE4(_In_reads_(4) const int8_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMBYTE4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMBYTE4(_In_reads_(4) const float* pArray) noexcept;
-
-            XMBYTE4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 8 bit unsigned normalized integer components
-        struct XMUBYTEN4
-        {
-            union
-            {
-                struct
-                {
-                    uint8_t x;
-                    uint8_t y;
-                    uint8_t z;
-                    uint8_t w;
-                };
-                uint32_t v;
-            };
-
-            XMUBYTEN4() = default;
-
-            XMUBYTEN4(const XMUBYTEN4&) = default;
-            XMUBYTEN4& operator=(const XMUBYTEN4&) = default;
-
-            XMUBYTEN4(XMUBYTEN4&&) = default;
-            XMUBYTEN4& operator=(XMUBYTEN4&&) = default;
-
-            constexpr XMUBYTEN4(uint8_t _x, uint8_t _y, uint8_t _z, uint8_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit constexpr XMUBYTEN4(uint32_t Packed) noexcept : v(Packed) {}
-            explicit XMUBYTEN4(_In_reads_(4) const uint8_t* pArray) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMUBYTEN4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMUBYTEN4(_In_reads_(4) const float* pArray) noexcept;
-
-            XMUBYTEN4& operator= (uint32_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        // 4D Vector; 8 bit unsigned integer components
-        struct XMUBYTE4
-        {
-            union
-            {
-                struct
-                {
-                    uint8_t x;
-                    uint8_t y;
-                    uint8_t z;
-                    uint8_t w;
-                };
-                uint32_t v;
-            };
-
-            XMUBYTE4() = default;
-
-            XMUBYTE4(const XMUBYTE4&) = default;
-            XMUBYTE4& operator=(const XMUBYTE4&) = default;
-
-            XMUBYTE4(XMUBYTE4&&) = default;
-            XMUBYTE4& operator=(XMUBYTE4&&) = default;
-
-            constexpr XMUBYTE4(uint8_t _x, uint8_t _y, uint8_t _z, uint8_t _w) noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit constexpr XMUBYTE4(uint32_t Packed)  noexcept : v(Packed) {}
-            explicit XMUBYTE4(_In_reads_(4) const uint8_t* pArray)  noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMUBYTE4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMUBYTE4(_In_reads_(4) const float* pArray) noexcept;
-
-            XMUBYTE4& operator= (uint32_t Packed)  noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 4D vector; 4 bit unsigned integer components
-        struct XMUNIBBLE4
-        {
-            union
-            {
-                struct
-                {
-                    uint16_t x : 4;    // 0 to 15
-                    uint16_t y : 4;    // 0 to 15
-                    uint16_t z : 4;    // 0 to 15
-                    uint16_t w : 4;    // 0 to 15
-                };
-                uint16_t v;
-            };
-
-            XMUNIBBLE4() = default;
-
-            XMUNIBBLE4(const XMUNIBBLE4&) = default;
-            XMUNIBBLE4& operator=(const XMUNIBBLE4&) = default;
-
-            XMUNIBBLE4(XMUNIBBLE4&&) = default;
-            XMUNIBBLE4& operator=(XMUNIBBLE4&&) = default;
-
-            explicit constexpr XMUNIBBLE4(uint16_t Packed)  noexcept : v(Packed) {}
-            constexpr XMUNIBBLE4(uint8_t _x, uint8_t _y, uint8_t _z, uint8_t _w)  noexcept : x(_x), y(_y), z(_z), w(_w) {}
-            explicit XMUNIBBLE4(_In_reads_(4) const uint8_t* pArray)  noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
-            XMUNIBBLE4(float _x, float _y, float _z, float _w) noexcept;
-            explicit XMUNIBBLE4(_In_reads_(4) const float* pArray) noexcept;
-
-            operator uint16_t () const  noexcept { return v; }
-
-            XMUNIBBLE4& operator= (uint16_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-        //------------------------------------------------------------------------------
-        // 4D vector: 5/5/5/1 unsigned integer components
-        struct XMU555
-        {
-            union
-            {
-                struct
-                {
-                    uint16_t x : 5;    // 0 to 31
-                    uint16_t y : 5;    // 0 to 31
-                    uint16_t z : 5;    // 0 to 31
-                    uint16_t w : 1;    // 0 or 1
-                };
-                uint16_t v;
-            };
-
-            XMU555() = default;
-
-            XMU555(const XMU555&) = default;
-            XMU555& operator=(const XMU555&) = default;
-
-            XMU555(XMU555&&) = default;
-            XMU555& operator=(XMU555&&) = default;
-
-            explicit constexpr XMU555(uint16_t Packed) noexcept : v(Packed) {}
-            constexpr XMU555(uint8_t _x, uint8_t _y, uint8_t _z, bool _w) noexcept : x(_x), y(_y), z(_z), w(_w ? 0x1 : 0) {}
-            XMU555(_In_reads_(3) const uint8_t* pArray, _In_ bool _w) noexcept : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(_w ? 0x1 : 0) {}
-            XMU555(float _x, float _y, float _z, bool _w) noexcept;
-            XMU555(_In_reads_(3) const float* pArray, _In_ bool _w) noexcept;
-
-            operator uint16_t () const noexcept { return v; }
-
-            XMU555& operator= (uint16_t Packed) noexcept { v = Packed; return *this; }
-        };
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-        /****************************************************************************
-         *
-         * Data conversion operations
-         *
-         ****************************************************************************/
-
-        float           XMConvertHalfToFloat(HALF Value) noexcept;
-        float* XMConvertHalfToFloatStream(_Out_writes_bytes_(sizeof(float) + OutputStride * (HalfCount - 1)) float* pOutputStream,
-                                          _In_ size_t OutputStride,
-                                          _In_reads_bytes_(sizeof(HALF) + InputStride * (HalfCount - 1)) const HALF* pInputStream,
-                                          _In_ size_t InputStride, _In_ size_t HalfCount) noexcept;
-        HALF            XMConvertFloatToHalf(float Value) noexcept;
-        HALF* XMConvertFloatToHalfStream(_Out_writes_bytes_(sizeof(HALF) + OutputStride * (FloatCount - 1)) HALF* pOutputStream,
-                                         _In_ size_t OutputStride,
-                                         _In_reads_bytes_(sizeof(float) + InputStride * (FloatCount - 1)) const float* pInputStream,
-                                         _In_ size_t InputStride, _In_ size_t FloatCount) noexcept;
-
-        /****************************************************************************
-         *
-         * Load operations
-         *
-         ****************************************************************************/
-
-        XMVECTOR    XM_CALLCONV     XMLoadColor(_In_ const XMCOLOR* pSource) noexcept;
-
-        XMVECTOR    XM_CALLCONV     XMLoadHalf2(_In_ const XMHALF2* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadShortN2(_In_ const XMSHORTN2* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadShort2(_In_ const XMSHORT2* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUShortN2(_In_ const XMUSHORTN2* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUShort2(_In_ const XMUSHORT2* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadByteN2(_In_ const XMBYTEN2* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadByte2(_In_ const XMBYTE2* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUByteN2(_In_ const XMUBYTEN2* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUByte2(_In_ const XMUBYTE2* pSource) noexcept;
-
-        XMVECTOR    XM_CALLCONV     XMLoadU565(_In_ const XMU565* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadFloat3PK(_In_ const XMFLOAT3PK* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadFloat3SE(_In_ const XMFLOAT3SE* pSource) noexcept;
-
-        XMVECTOR    XM_CALLCONV     XMLoadHalf4(_In_ const XMHALF4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadShortN4(_In_ const XMSHORTN4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadShort4(_In_ const XMSHORT4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUShortN4(_In_ const XMUSHORTN4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUShort4(_In_ const XMUSHORT4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadXDecN4(_In_ const XMXDECN4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUDecN4(_In_ const XMUDECN4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUDecN4_XR(_In_ const XMUDECN4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUDec4(_In_ const XMUDEC4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadByteN4(_In_ const XMBYTEN4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadByte4(_In_ const XMBYTE4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUByteN4(_In_ const XMUBYTEN4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUByte4(_In_ const XMUBYTE4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadUNibble4(_In_ const XMUNIBBLE4* pSource) noexcept;
-        XMVECTOR    XM_CALLCONV     XMLoadU555(_In_ const XMU555* pSource) noexcept;
-
-#ifdef _MSC_VER
-        #pragma warning(push)
-#pragma warning(disable : 4996)
-        // C4996: ignore deprecation warning
-#endif
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-        XMVECTOR    XM_DEPRECATED XM_CALLCONV XMLoadDecN4(_In_ const XMDECN4* pSource) noexcept;
-        XMVECTOR    XM_DEPRECATED XM_CALLCONV XMLoadDec4(_In_ const XMDEC4* pSource) noexcept;
-        XMVECTOR    XM_DEPRECATED XM_CALLCONV XMLoadXDec4(_In_ const XMXDEC4* pSource) noexcept;
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-        /****************************************************************************
-         *
-         * Store operations
-         *
-         ****************************************************************************/
-
-        void    XM_CALLCONV     XMStoreColor(_Out_ XMCOLOR* pDestination, _In_ FXMVECTOR V) noexcept;
-
-        void    XM_CALLCONV     XMStoreHalf2(_Out_ XMHALF2* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreShortN2(_Out_ XMSHORTN2* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreShort2(_Out_ XMSHORT2* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUShortN2(_Out_ XMUSHORTN2* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUShort2(_Out_ XMUSHORT2* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreByteN2(_Out_ XMBYTEN2* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreByte2(_Out_ XMBYTE2* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUByteN2(_Out_ XMUBYTEN2* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUByte2(_Out_ XMUBYTE2* pDestination, _In_ FXMVECTOR V) noexcept;
-
-        void    XM_CALLCONV     XMStoreU565(_Out_ XMU565* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreFloat3PK(_Out_ XMFLOAT3PK* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreFloat3SE(_Out_ XMFLOAT3SE* pDestination, _In_ FXMVECTOR V) noexcept;
-
-        void    XM_CALLCONV     XMStoreHalf4(_Out_ XMHALF4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreShortN4(_Out_ XMSHORTN4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreShort4(_Out_ XMSHORT4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUShortN4(_Out_ XMUSHORTN4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUShort4(_Out_ XMUSHORT4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreXDecN4(_Out_ XMXDECN4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUDecN4(_Out_ XMUDECN4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUDecN4_XR(_Out_ XMUDECN4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUDec4(_Out_ XMUDEC4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreByteN4(_Out_ XMBYTEN4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreByte4(_Out_ XMBYTE4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUByteN4(_Out_ XMUBYTEN4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUByte4(_Out_ XMUBYTE4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreUNibble4(_Out_ XMUNIBBLE4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_CALLCONV     XMStoreU555(_Out_ XMU555* pDestination, _In_ FXMVECTOR V) noexcept;
-
-#ifdef _MSC_VER
-        #pragma warning(push)
-#pragma warning(disable : 4996)
-        // C4996: ignore deprecation warning
-#endif
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-        void    XM_DEPRECATED XM_CALLCONV XMStoreDecN4(_Out_ XMDECN4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_DEPRECATED XM_CALLCONV XMStoreDec4(_Out_ XMDEC4* pDestination, _In_ FXMVECTOR V) noexcept;
-        void    XM_DEPRECATED XM_CALLCONV XMStoreXDec4(_Out_ XMXDEC4* pDestination, _In_ FXMVECTOR V) noexcept;
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-        /****************************************************************************
-         *
-         * Implementation
-         *
-         ****************************************************************************/
-#ifdef _MSC_VER
-        #pragma warning(push)
-#pragma warning(disable:4068 4214 4204 4365 4616 6001 6101)
-         // C4068/4616: ignore unknown pragmas
-         // C4214/4204: nonstandard extension used
-         // C4365: Off by default noise
-         // C6001/6101: False positives
-#endif
-
-#ifdef _PREFAST_
-        #pragma prefast(push)
-#pragma prefast(disable : 25000, "FXMVECTOR is 16 bytes")
-#pragma prefast(disable : 26495, "Union initialization confuses /analyze")
-#endif
-
-#include "DirectXPackedVector.inl"
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-    } // namespace PackedVector
-
-} // namespace DirectX
-
diff --git a/thirdparty/directxmath/DirectXPackedVector.inl b/thirdparty/directxmath/DirectXPackedVector.inl
deleted file mode 100644
index 93f8d0e..0000000
--- a/thirdparty/directxmath/DirectXPackedVector.inl
+++ /dev/null
@@ -1,4459 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXPackedVector.inl -- SIMD C++ Math library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkID=615560
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-/****************************************************************************
- *
- * Data conversion
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline float XMConvertHalfToFloat(HALF Value) noexcept
-{
-#if defined(_XM_F16C_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    __m128i V1 = _mm_cvtsi32_si128(static_cast<int>(Value));
-    __m128 V2 = _mm_cvtph_ps(V1);
-    return _mm_cvtss_f32(V2);
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && (defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__) && !defined(_XM_NO_INTRINSICS_) && (!defined(__GNUC__) || (__ARM_FP & 2))
-    uint16x4_t vHalf = vdup_n_u16(Value);
-    float32x4_t vFloat = vcvt_f32_f16(vreinterpret_f16_u16(vHalf));
-    return vgetq_lane_f32(vFloat, 0);
-#else
-    auto Mantissa = static_cast<uint32_t>(Value & 0x03FF);
-
-    uint32_t Exponent = (Value & 0x7C00);
-    if (Exponent == 0x7C00) // INF/NAN
-    {
-        Exponent = 0x8f;
-    }
-    else if (Exponent != 0)  // The value is normalized
-    {
-        Exponent = static_cast<uint32_t>((static_cast<int>(Value) >> 10) & 0x1F);
-    }
-    else if (Mantissa != 0)     // The value is denormalized
-    {
-        // Normalize the value in the resulting float
-        Exponent = 1;
-
-        do
-        {
-            Exponent--;
-            Mantissa <<= 1;
-        } while ((Mantissa & 0x0400) == 0);
-
-        Mantissa &= 0x03FF;
-    }
-    else                        // The value is zero
-    {
-        Exponent = static_cast<uint32_t>(-112);
-    }
-
-    uint32_t Result =
-            ((static_cast<uint32_t>(Value) & 0x8000) << 16) // Sign
-            | ((Exponent + 112) << 23)                      // Exponent
-            | (Mantissa << 13);                             // Mantissa
-
-    return reinterpret_cast<float*>(&Result)[0];
-#endif // !_XM_F16C_INTRINSICS_
-}
-
-//------------------------------------------------------------------------------
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable : 26015 26019, "PREfast noise: Esp:1307" )
-#endif
-
-_Use_decl_annotations_
-inline float* XMConvertHalfToFloatStream
-        (
-                float* pOutputStream,
-                size_t      OutputStride,
-                const HALF* pInputStream,
-                size_t      InputStride,
-                size_t      HalfCount
-        ) noexcept
-{
-    assert(pOutputStream);
-    assert(pInputStream);
-
-    assert(InputStride >= sizeof(HALF));
-    _Analysis_assume_(InputStride >= sizeof(HALF));
-
-    assert(OutputStride >= sizeof(float));
-    _Analysis_assume_(OutputStride >= sizeof(float));
-
-#if defined(_XM_F16C_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    auto pHalf = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pFloat = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = HalfCount >> 2;
-    if (four > 0)
-    {
-        if (InputStride == sizeof(HALF))
-        {
-            if (OutputStride == sizeof(float))
-            {
-                if ((reinterpret_cast<uintptr_t>(pFloat) & 0xF) == 0)
-                {
-                    // Packed input, aligned & packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128i HV = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(pHalf));
-                        pHalf += InputStride * 4;
-
-                        __m128 FV = _mm_cvtph_ps(HV);
-
-                        XM_STREAM_PS(reinterpret_cast<float*>(pFloat), FV);
-                        pFloat += OutputStride * 4;
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128i HV = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(pHalf));
-                        pHalf += InputStride * 4;
-
-                        __m128 FV = _mm_cvtph_ps(HV);
-
-                        _mm_storeu_ps(reinterpret_cast<float*>(pFloat), FV);
-                        pFloat += OutputStride * 4;
-                        i += 4;
-                    }
-                }
-            }
-            else
-            {
-                // Packed input, scattered output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    __m128i HV = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(pHalf));
-                    pHalf += InputStride * 4;
-
-                    __m128 FV = _mm_cvtph_ps(HV);
-
-                    _mm_store_ss(reinterpret_cast<float*>(pFloat), FV);
-                    pFloat += OutputStride;
-                    *reinterpret_cast<int*>(pFloat) = _mm_extract_ps(FV, 1);
-                    pFloat += OutputStride;
-                    *reinterpret_cast<int*>(pFloat) = _mm_extract_ps(FV, 2);
-                    pFloat += OutputStride;
-                    *reinterpret_cast<int*>(pFloat) = _mm_extract_ps(FV, 3);
-                    pFloat += OutputStride;
-                    i += 4;
-                }
-            }
-        }
-        else if (OutputStride == sizeof(float))
-        {
-            if ((reinterpret_cast<uintptr_t>(pFloat) & 0xF) == 0)
-            {
-                // Scattered input, aligned & packed output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    uint16_t H1 = *reinterpret_cast<const HALF*>(pHalf);
-                    pHalf += InputStride;
-                    uint16_t H2 = *reinterpret_cast<const HALF*>(pHalf);
-                    pHalf += InputStride;
-                    uint16_t H3 = *reinterpret_cast<const HALF*>(pHalf);
-                    pHalf += InputStride;
-                    uint16_t H4 = *reinterpret_cast<const HALF*>(pHalf);
-                    pHalf += InputStride;
-
-                    __m128i HV = _mm_setzero_si128();
-                    HV = _mm_insert_epi16(HV, H1, 0);
-                    HV = _mm_insert_epi16(HV, H2, 1);
-                    HV = _mm_insert_epi16(HV, H3, 2);
-                    HV = _mm_insert_epi16(HV, H4, 3);
-                    __m128 FV = _mm_cvtph_ps(HV);
-
-                    XM_STREAM_PS(reinterpret_cast<float*>(pFloat), FV);
-                    pFloat += OutputStride * 4;
-                    i += 4;
-                }
-            }
-            else
-            {
-                // Scattered input, packed output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    uint16_t H1 = *reinterpret_cast<const HALF*>(pHalf);
-                    pHalf += InputStride;
-                    uint16_t H2 = *reinterpret_cast<const HALF*>(pHalf);
-                    pHalf += InputStride;
-                    uint16_t H3 = *reinterpret_cast<const HALF*>(pHalf);
-                    pHalf += InputStride;
-                    uint16_t H4 = *reinterpret_cast<const HALF*>(pHalf);
-                    pHalf += InputStride;
-
-                    __m128i HV = _mm_setzero_si128();
-                    HV = _mm_insert_epi16(HV, H1, 0);
-                    HV = _mm_insert_epi16(HV, H2, 1);
-                    HV = _mm_insert_epi16(HV, H3, 2);
-                    HV = _mm_insert_epi16(HV, H4, 3);
-                    __m128 FV = _mm_cvtph_ps(HV);
-
-                    _mm_storeu_ps(reinterpret_cast<float*>(pFloat), FV);
-                    pFloat += OutputStride * 4;
-                    i += 4;
-                }
-            }
-        }
-        else
-        {
-            // Scattered input, scattered output
-            for (size_t j = 0; j < four; ++j)
-            {
-                uint16_t H1 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-                uint16_t H2 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-                uint16_t H3 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-                uint16_t H4 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-
-                __m128i HV = _mm_setzero_si128();
-                HV = _mm_insert_epi16(HV, H1, 0);
-                HV = _mm_insert_epi16(HV, H2, 1);
-                HV = _mm_insert_epi16(HV, H3, 2);
-                HV = _mm_insert_epi16(HV, H4, 3);
-                __m128 FV = _mm_cvtph_ps(HV);
-
-                _mm_store_ss(reinterpret_cast<float*>(pFloat), FV);
-                pFloat += OutputStride;
-                *reinterpret_cast<int*>(pFloat) = _mm_extract_ps(FV, 1);
-                pFloat += OutputStride;
-                *reinterpret_cast<int*>(pFloat) = _mm_extract_ps(FV, 2);
-                pFloat += OutputStride;
-                *reinterpret_cast<int*>(pFloat) = _mm_extract_ps(FV, 3);
-                pFloat += OutputStride;
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < HalfCount; ++i)
-    {
-        *reinterpret_cast<float*>(pFloat) = XMConvertHalfToFloat(reinterpret_cast<const HALF*>(pHalf)[0]);
-        pHalf += InputStride;
-        pFloat += OutputStride;
-    }
-
-    XM_SFENCE();
-
-    return pOutputStream;
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && (defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) ||__aarch64__) && !defined(_XM_NO_INTRINSICS_) && (!defined(__GNUC__) || (__ARM_FP & 2))
-    auto pHalf = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pFloat = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = HalfCount >> 2;
-    if (four > 0)
-    {
-        if (InputStride == sizeof(HALF))
-        {
-            if (OutputStride == sizeof(float))
-            {
-                // Packed input, packed output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    uint16x4_t vHalf = vld1_u16(reinterpret_cast<const uint16_t*>(pHalf));
-                    pHalf += InputStride * 4;
-
-                    float32x4_t vFloat = vcvt_f32_f16(vreinterpret_f16_u16(vHalf));
-
-                    vst1q_f32(reinterpret_cast<float*>(pFloat), vFloat);
-                    pFloat += OutputStride * 4;
-                    i += 4;
-                }
-            }
-            else
-            {
-                // Packed input, scattered output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    uint16x4_t vHalf = vld1_u16(reinterpret_cast<const uint16_t*>(pHalf));
-                    pHalf += InputStride * 4;
-
-                    float32x4_t vFloat = vcvt_f32_f16(vreinterpret_f16_u16(vHalf));
-
-                    vst1q_lane_f32(reinterpret_cast<float*>(pFloat), vFloat, 0);
-                    pFloat += OutputStride;
-                    vst1q_lane_f32(reinterpret_cast<float*>(pFloat), vFloat, 1);
-                    pFloat += OutputStride;
-                    vst1q_lane_f32(reinterpret_cast<float*>(pFloat), vFloat, 2);
-                    pFloat += OutputStride;
-                    vst1q_lane_f32(reinterpret_cast<float*>(pFloat), vFloat, 3);
-                    pFloat += OutputStride;
-                    i += 4;
-                }
-            }
-        }
-        else if (OutputStride == sizeof(float))
-        {
-            // Scattered input, packed output
-            for (size_t j = 0; j < four; ++j)
-            {
-                uint16_t H1 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-                uint16_t H2 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-                uint16_t H3 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-                uint16_t H4 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-
-                uint64_t iHalf = uint64_t(H1) | (uint64_t(H2) << 16) | (uint64_t(H3) << 32) | (uint64_t(H4) << 48);
-                uint16x4_t vHalf = vcreate_u16(iHalf);
-
-                float32x4_t vFloat = vcvt_f32_f16(vreinterpret_f16_u16(vHalf));
-
-                vst1q_f32(reinterpret_cast<float*>(pFloat), vFloat);
-                pFloat += OutputStride * 4;
-                i += 4;
-            }
-        }
-        else
-        {
-            // Scattered input, scattered output
-            for (size_t j = 0; j < four; ++j)
-            {
-                uint16_t H1 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-                uint16_t H2 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-                uint16_t H3 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-                uint16_t H4 = *reinterpret_cast<const HALF*>(pHalf);
-                pHalf += InputStride;
-
-                uint64_t iHalf = uint64_t(H1) | (uint64_t(H2) << 16) | (uint64_t(H3) << 32) | (uint64_t(H4) << 48);
-                uint16x4_t vHalf = vcreate_u16(iHalf);
-
-                float32x4_t vFloat = vcvt_f32_f16(vreinterpret_f16_u16(vHalf));
-
-                vst1q_lane_f32(reinterpret_cast<float*>(pFloat), vFloat, 0);
-                pFloat += OutputStride;
-                vst1q_lane_f32(reinterpret_cast<float*>(pFloat), vFloat, 1);
-                pFloat += OutputStride;
-                vst1q_lane_f32(reinterpret_cast<float*>(pFloat), vFloat, 2);
-                pFloat += OutputStride;
-                vst1q_lane_f32(reinterpret_cast<float*>(pFloat), vFloat, 3);
-                pFloat += OutputStride;
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < HalfCount; ++i)
-    {
-        *reinterpret_cast<float*>(pFloat) = XMConvertHalfToFloat(reinterpret_cast<const HALF*>(pHalf)[0]);
-        pHalf += InputStride;
-        pFloat += OutputStride;
-    }
-
-    return pOutputStream;
-#else
-    auto pHalf = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pFloat = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    for (size_t i = 0; i < HalfCount; i++)
-    {
-        *reinterpret_cast<float*>(pFloat) = XMConvertHalfToFloat(reinterpret_cast<const HALF*>(pHalf)[0]);
-        pHalf += InputStride;
-        pFloat += OutputStride;
-    }
-
-    return pOutputStream;
-#endif // !_XM_F16C_INTRINSICS_
-}
-
-//------------------------------------------------------------------------------
-
-inline HALF XMConvertFloatToHalf(float Value) noexcept
-{
-#if defined(_XM_F16C_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    __m128 V1 = _mm_set_ss(Value);
-    __m128i V2 = _mm_cvtps_ph(V1, _MM_FROUND_TO_NEAREST_INT);
-    return static_cast<HALF>(_mm_extract_epi16(V2, 0));
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && (defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__) && !defined(_XM_NO_INTRINSICS_) && (!defined(__GNUC__) || (__ARM_FP & 2))
-    float32x4_t vFloat = vdupq_n_f32(Value);
-    float16x4_t vHalf = vcvt_f16_f32(vFloat);
-    return vget_lane_u16(vreinterpret_u16_f16(vHalf), 0);
-#else
-    uint32_t Result;
-
-    auto IValue = reinterpret_cast<uint32_t*>(&Value)[0];
-    uint32_t Sign = (IValue & 0x80000000U) >> 16U;
-    IValue = IValue & 0x7FFFFFFFU;      // Hack off the sign
-    if (IValue >= 0x47800000 /*e+16*/)
-    {
-        // The number is too large to be represented as a half. Return infinity or NaN
-        Result = 0x7C00U | ((IValue > 0x7F800000) ? (0x200 | ((IValue >> 13U) & 0x3FFU)) : 0U);
-    }
-    else if (IValue <= 0x33000000U /*e-25*/)
-    {
-        Result = 0;
-    }
-    else if (IValue < 0x38800000U /*e-14*/)
-    {
-        // The number is too small to be represented as a normalized half.
-        // Convert it to a denormalized value.
-        uint32_t Shift = 125U - (IValue >> 23U);
-        IValue = 0x800000U | (IValue & 0x7FFFFFU);
-        Result = IValue >> (Shift + 1);
-        uint32_t s = (IValue & ((1U << Shift) - 1)) != 0;
-        Result += (Result | s) & ((IValue >> Shift) & 1U);
-    }
-    else
-    {
-        // Rebias the exponent to represent the value as a normalized half.
-        IValue += 0xC8000000U;
-        Result = ((IValue + 0x0FFFU + ((IValue >> 13U) & 1U)) >> 13U) & 0x7FFFU;
-    }
-    return static_cast<HALF>(Result | Sign);
-#endif // !_XM_F16C_INTRINSICS_
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline HALF* XMConvertFloatToHalfStream
-(
-        HALF* pOutputStream,
-size_t       OutputStride,
-const float* pInputStream,
-        size_t       InputStride,
-size_t       FloatCount
-) noexcept
-{
-assert(pOutputStream);
-assert(pInputStream);
-
-assert(InputStride >= sizeof(float));
-_Analysis_assume_(InputStride >= sizeof(float));
-
-assert(OutputStride >= sizeof(HALF));
-_Analysis_assume_(OutputStride >= sizeof(HALF));
-
-#if defined(_XM_F16C_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-auto pFloat = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pHalf = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = FloatCount >> 2;
-    if (four > 0)
-    {
-        if (InputStride == sizeof(float))
-        {
-            if (OutputStride == sizeof(HALF))
-            {
-                if ((reinterpret_cast<uintptr_t>(pFloat) & 0xF) == 0)
-                {
-                    // Aligned and packed input, packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 FV = _mm_load_ps(reinterpret_cast<const float*>(pFloat));
-                        pFloat += InputStride * 4;
-
-                        __m128i HV = _mm_cvtps_ph(FV, _MM_FROUND_TO_NEAREST_INT);
-
-                        _mm_storel_epi64(reinterpret_cast<__m128i*>(pHalf), HV);
-                        pHalf += OutputStride * 4;
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, packed output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 FV = _mm_loadu_ps(reinterpret_cast<const float*>(pFloat));
-                        pFloat += InputStride * 4;
-
-                        __m128i HV = _mm_cvtps_ph(FV, _MM_FROUND_TO_NEAREST_INT);
-
-                        _mm_storel_epi64(reinterpret_cast<__m128i*>(pHalf), HV);
-                        pHalf += OutputStride * 4;
-                        i += 4;
-                    }
-                }
-            }
-            else
-            {
-                if ((reinterpret_cast<uintptr_t>(pFloat) & 0xF) == 0)
-                {
-                    // Aligned & packed input, scattered output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 FV = _mm_load_ps(reinterpret_cast<const float*>(pFloat));
-                        pFloat += InputStride * 4;
-
-                        __m128i HV = _mm_cvtps_ph(FV, _MM_FROUND_TO_NEAREST_INT);
-
-                        *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 0));
-                        pHalf += OutputStride;
-                        *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 1));
-                        pHalf += OutputStride;
-                        *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 2));
-                        pHalf += OutputStride;
-                        *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 3));
-                        pHalf += OutputStride;
-                        i += 4;
-                    }
-                }
-                else
-                {
-                    // Packed input, scattered output
-                    for (size_t j = 0; j < four; ++j)
-                    {
-                        __m128 FV = _mm_loadu_ps(reinterpret_cast<const float*>(pFloat));
-                        pFloat += InputStride * 4;
-
-                        __m128i HV = _mm_cvtps_ph(FV, _MM_FROUND_TO_NEAREST_INT);
-
-                        *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 0));
-                        pHalf += OutputStride;
-                        *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 1));
-                        pHalf += OutputStride;
-                        *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 2));
-                        pHalf += OutputStride;
-                        *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 3));
-                        pHalf += OutputStride;
-                        i += 4;
-                    }
-                }
-            }
-        }
-        else if (OutputStride == sizeof(HALF))
-        {
-            // Scattered input, packed output
-            for (size_t j = 0; j < four; ++j)
-            {
-                __m128 FV1 = _mm_load_ss(reinterpret_cast<const float*>(pFloat));
-                pFloat += InputStride;
-
-                __m128 FV2 = _mm_broadcast_ss(reinterpret_cast<const float*>(pFloat));
-                pFloat += InputStride;
-
-                __m128 FV3 = _mm_broadcast_ss(reinterpret_cast<const float*>(pFloat));
-                pFloat += InputStride;
-
-                __m128 FV4 = _mm_broadcast_ss(reinterpret_cast<const float*>(pFloat));
-                pFloat += InputStride;
-
-                __m128 FV = _mm_blend_ps(FV1, FV2, 0x2);
-                __m128 FT = _mm_blend_ps(FV3, FV4, 0x8);
-                FV = _mm_blend_ps(FV, FT, 0xC);
-
-                __m128i HV = _mm_cvtps_ph(FV, _MM_FROUND_TO_NEAREST_INT);
-
-                _mm_storel_epi64(reinterpret_cast<__m128i*>(pHalf), HV);
-                pHalf += OutputStride * 4;
-                i += 4;
-            }
-        }
-        else
-        {
-            // Scattered input, scattered output
-            for (size_t j = 0; j < four; ++j)
-            {
-                __m128 FV1 = _mm_load_ss(reinterpret_cast<const float*>(pFloat));
-                pFloat += InputStride;
-
-                __m128 FV2 = _mm_broadcast_ss(reinterpret_cast<const float*>(pFloat));
-                pFloat += InputStride;
-
-                __m128 FV3 = _mm_broadcast_ss(reinterpret_cast<const float*>(pFloat));
-                pFloat += InputStride;
-
-                __m128 FV4 = _mm_broadcast_ss(reinterpret_cast<const float*>(pFloat));
-                pFloat += InputStride;
-
-                __m128 FV = _mm_blend_ps(FV1, FV2, 0x2);
-                __m128 FT = _mm_blend_ps(FV3, FV4, 0x8);
-                FV = _mm_blend_ps(FV, FT, 0xC);
-
-                __m128i HV = _mm_cvtps_ph(FV, _MM_FROUND_TO_NEAREST_INT);
-
-                *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 0));
-                pHalf += OutputStride;
-                *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 1));
-                pHalf += OutputStride;
-                *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 2));
-                pHalf += OutputStride;
-                *reinterpret_cast<HALF*>(pHalf) = static_cast<HALF>(_mm_extract_epi16(HV, 3));
-                pHalf += OutputStride;
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < FloatCount; ++i)
-    {
-        *reinterpret_cast<HALF*>(pHalf) = XMConvertFloatToHalf(reinterpret_cast<const float*>(pFloat)[0]);
-        pFloat += InputStride;
-        pHalf += OutputStride;
-    }
-
-    return pOutputStream;
-#elif defined(_XM_ARM_NEON_INTRINSICS_) && (defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __aarch64__) && !defined(_XM_NO_INTRINSICS_) && (!defined(__GNUC__) || (__ARM_FP & 2))
-auto pFloat = reinterpret_cast<const uint8_t*>(pInputStream);
-    auto pHalf = reinterpret_cast<uint8_t*>(pOutputStream);
-
-    size_t i = 0;
-    size_t four = FloatCount >> 2;
-    if (four > 0)
-    {
-        if (InputStride == sizeof(float))
-        {
-            if (OutputStride == sizeof(HALF))
-            {
-                // Packed input, packed output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    float32x4_t vFloat = vld1q_f32(reinterpret_cast<const float*>(pFloat));
-                    pFloat += InputStride * 4;
-
-                    uint16x4_t vHalf = vreinterpret_u16_f16(vcvt_f16_f32(vFloat));
-
-                    vst1_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf);
-                    pHalf += OutputStride * 4;
-                    i += 4;
-                }
-            }
-            else
-            {
-                // Packed input, scattered output
-                for (size_t j = 0; j < four; ++j)
-                {
-                    float32x4_t vFloat = vld1q_f32(reinterpret_cast<const float*>(pFloat));
-                    pFloat += InputStride * 4;
-
-                    uint16x4_t vHalf = vreinterpret_u16_f16(vcvt_f16_f32(vFloat));
-
-                    vst1_lane_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf, 0);
-                    pHalf += OutputStride;
-                    vst1_lane_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf, 1);
-                    pHalf += OutputStride;
-                    vst1_lane_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf, 2);
-                    pHalf += OutputStride;
-                    vst1_lane_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf, 3);
-                    pHalf += OutputStride;
-                    i += 4;
-                }
-            }
-        }
-        else if (OutputStride == sizeof(HALF))
-        {
-            // Scattered input, packed output
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4_t vFloat = vdupq_n_f32(0);
-                vFloat = vld1q_lane_f32(reinterpret_cast<const float*>(pFloat), vFloat, 0);
-                pFloat += InputStride;
-
-                vFloat = vld1q_lane_f32(reinterpret_cast<const float*>(pFloat), vFloat, 1);
-                pFloat += InputStride;
-
-                vFloat = vld1q_lane_f32(reinterpret_cast<const float*>(pFloat), vFloat, 2);
-                pFloat += InputStride;
-
-                vFloat = vld1q_lane_f32(reinterpret_cast<const float*>(pFloat), vFloat, 3);
-                pFloat += InputStride;
-
-                uint16x4_t vHalf = vreinterpret_u16_f16(vcvt_f16_f32(vFloat));
-
-                vst1_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf);
-                pHalf += OutputStride * 4;
-                i += 4;
-            }
-        }
-        else
-        {
-            // Scattered input, scattered output
-            for (size_t j = 0; j < four; ++j)
-            {
-                float32x4_t vFloat = vdupq_n_f32(0);
-                vFloat = vld1q_lane_f32(reinterpret_cast<const float*>(pFloat), vFloat, 0);
-                pFloat += InputStride;
-
-                vFloat = vld1q_lane_f32(reinterpret_cast<const float*>(pFloat), vFloat, 1);
-                pFloat += InputStride;
-
-                vFloat = vld1q_lane_f32(reinterpret_cast<const float*>(pFloat), vFloat, 2);
-                pFloat += InputStride;
-
-                vFloat = vld1q_lane_f32(reinterpret_cast<const float*>(pFloat), vFloat, 3);
-                pFloat += InputStride;
-
-                uint16x4_t vHalf = vreinterpret_u16_f16(vcvt_f16_f32(vFloat));
-
-                vst1_lane_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf, 0);
-                pHalf += OutputStride;
-                vst1_lane_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf, 1);
-                pHalf += OutputStride;
-                vst1_lane_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf, 2);
-                pHalf += OutputStride;
-                vst1_lane_u16(reinterpret_cast<uint16_t*>(pHalf), vHalf, 3);
-                pHalf += OutputStride;
-                i += 4;
-            }
-        }
-    }
-
-    for (; i < FloatCount; ++i)
-    {
-        *reinterpret_cast<HALF*>(pHalf) = XMConvertFloatToHalf(reinterpret_cast<const float*>(pFloat)[0]);
-        pFloat += InputStride;
-        pHalf += OutputStride;
-    }
-
-    return pOutputStream;
-#else
-auto pFloat = reinterpret_cast<const uint8_t*>(pInputStream);
-auto pHalf = reinterpret_cast<uint8_t*>(pOutputStream);
-
-for (size_t i = 0; i < FloatCount; i++)
-{
-*reinterpret_cast<HALF*>(pHalf) = XMConvertFloatToHalf(reinterpret_cast<const float*>(pFloat)[0]);
-pFloat += InputStride;
-pHalf += OutputStride;
-}
-return pOutputStream;
-#endif // !_XM_F16C_INTRINSICS_
-}
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-/****************************************************************************
- *
- * Vector and matrix load operations
- *
- ****************************************************************************/
-
-#ifdef _PREFAST_
-#pragma prefast(push)
-#pragma prefast(disable:28931, "PREfast noise: Esp:1266")
-#endif
-
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadColor(const XMCOLOR* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    // int32_t -> Float conversions are done in one instruction.
-    // uint32_t -> Float calls a runtime function. Keep in int32_t
-    auto iColor = static_cast<int32_t>(pSource->c);
-    XMVECTORF32 vColor = { { {
-            static_cast<float>((iColor >> 16) & 0xFF)* (1.0f / 255.0f),
-            static_cast<float>((iColor >> 8) & 0xFF)* (1.0f / 255.0f),
-            static_cast<float>(iColor & 0xFF)* (1.0f / 255.0f),
-            static_cast<float>((iColor >> 24) & 0xFF)* (1.0f / 255.0f)
-        } } };
-    return vColor.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32_t bgra = pSource->c;
-    uint32_t rgba = (bgra & 0xFF00FF00) | ((bgra >> 16) & 0xFF) | ((bgra << 16) & 0xFF0000);
-    uint32x2_t vInt8 = vdup_n_u32(rgba);
-    uint16x8_t vInt16 = vmovl_u8(vreinterpret_u8_u32(vInt8));
-    uint32x4_t vInt = vmovl_u16(vget_low_u16(vInt16));
-    float32x4_t R = vcvtq_f32_u32(vInt);
-    return vmulq_n_f32(R, 1.0f / 255.0f);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Splat the color in all four entries
-    __m128i vInt = _mm_set1_epi32(static_cast<int>(pSource->c));
-    // Shift R&0xFF0000, G&0xFF00, B&0xFF, A&0xFF000000
-    vInt = _mm_and_si128(vInt, g_XMMaskA8R8G8B8);
-    // a is unsigned! Flip the bit to convert the order to signed
-    vInt = _mm_xor_si128(vInt, g_XMFlipA8R8G8B8);
-    // Convert to floating point numbers
-    XMVECTOR vTemp = _mm_cvtepi32_ps(vInt);
-    // RGB + 0, A + 0x80000000.f to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, g_XMFixAA8R8G8B8);
-    // Convert 0-255 to 0.0f-1.0f
-    return _mm_mul_ps(vTemp, g_XMNormalizeA8R8G8B8);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadHalf2(const XMHALF2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_F16C_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    __m128 V = _mm_load_ss(reinterpret_cast<const float*>(pSource));
-    return _mm_cvtph_ps(_mm_castps_si128(V));
-#else
-    XMVECTORF32 vResult = { { {
-                                      XMConvertHalfToFloat(pSource->x),
-                                      XMConvertHalfToFloat(pSource->y),
-                                      0.0f,
-                                      0.0f
-                              } } };
-    return vResult.v;
-#endif // !_XM_F16C_INTRINSICS_
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadShortN2(const XMSHORTN2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            (pSource->x == -32768) ? -1.f : (static_cast<float>(pSource->x)* (1.0f / 32767.0f)),
-            (pSource->y == -32768) ? -1.f : (static_cast<float>(pSource->y)* (1.0f / 32767.0f)),
-            0.0f,
-            0.0f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vInt16 = vld1_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    int32x4_t vInt = vmovl_s16(vreinterpret_s16_u32(vInt16));
-    vInt = vandq_s32(vInt, g_XMMaskXY);
-    float32x4_t R = vcvtq_f32_s32(vInt);
-    R = vmulq_n_f32(R, 1.0f / 32767.0f);
-    return vmaxq_f32(R, vdupq_n_f32(-1.f));
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Splat the two shorts in all four entries (WORD alignment okay,
-    // DWORD alignment preferred)
-    __m128 vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->x));
-    // Mask x&0xFFFF, y&0xFFFF0000,z&0,w&0
-    vTemp = _mm_and_ps(vTemp, g_XMMaskX16Y16);
-    // x needs to be sign extended
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipX16Y16);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // x - 0x8000 to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, g_XMFixX16Y16);
-    // Convert -1.0f - 1.0f
-    vTemp = _mm_mul_ps(vTemp, g_XMNormalizeX16Y16);
-    // Clamp result (for case of -32768)
-    return _mm_max_ps(vTemp, g_XMNegativeOne);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadShort2(const XMSHORT2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x),
-            static_cast<float>(pSource->y),
-            0.f,
-            0.f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vInt16 = vld1_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    int32x4_t vInt = vmovl_s16(vreinterpret_s16_u32(vInt16));
-    vInt = vandq_s32(vInt, g_XMMaskXY);
-    return vcvtq_f32_s32(vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Splat the two shorts in all four entries (WORD alignment okay,
-    // DWORD alignment preferred)
-    __m128 vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->x));
-    // Mask x&0xFFFF, y&0xFFFF0000,z&0,w&0
-    vTemp = _mm_and_ps(vTemp, g_XMMaskX16Y16);
-    // x needs to be sign extended
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipX16Y16);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // x - 0x8000 to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, g_XMFixX16Y16);
-    // Y is 65536 too large
-    return _mm_mul_ps(vTemp, g_XMFixupY16);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUShortN2(const XMUSHORTN2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x) / 65535.0f,
-            static_cast<float>(pSource->y) / 65535.0f,
-            0.f,
-            0.f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vInt16 = vld1_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    uint32x4_t vInt = vmovl_u16(vreinterpret_u16_u32(vInt16));
-    vInt = vandq_u32(vInt, g_XMMaskXY);
-    float32x4_t R = vcvtq_f32_u32(vInt);
-    R = vmulq_n_f32(R, 1.0f / 65535.0f);
-    return vmaxq_f32(R, vdupq_n_f32(-1.f));
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 FixupY16 = { { { 1.0f / 65535.0f, 1.0f / (65535.0f * 65536.0f), 0.0f, 0.0f } } };
-    static const XMVECTORF32 FixaddY16 = { { { 0, 32768.0f * 65536.0f, 0, 0 } } };
-    // Splat the two shorts in all four entries (WORD alignment okay,
-    // DWORD alignment preferred)
-    __m128 vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->x));
-    // Mask x&0xFFFF, y&0xFFFF0000,z&0,w&0
-    vTemp = _mm_and_ps(vTemp, g_XMMaskX16Y16);
-    // y needs to be sign flipped
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipY);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // y + 0x8000 to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, FixaddY16);
-    // Y is 65536 times too large
-    vTemp = _mm_mul_ps(vTemp, FixupY16);
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUShort2(const XMUSHORT2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x),
-            static_cast<float>(pSource->y),
-            0.f,
-            0.f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vInt16 = vld1_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    uint32x4_t vInt = vmovl_u16(vreinterpret_u16_u32(vInt16));
-    vInt = vandq_u32(vInt, g_XMMaskXY);
-    return vcvtq_f32_u32(vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 FixaddY16 = { { { 0, 32768.0f, 0, 0 } } };
-    // Splat the two shorts in all four entries (WORD alignment okay,
-    // DWORD alignment preferred)
-    __m128 vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->x));
-    // Mask x&0xFFFF, y&0xFFFF0000,z&0,w&0
-    vTemp = _mm_and_ps(vTemp, g_XMMaskX16Y16);
-    // y needs to be sign flipped
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipY);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // Y is 65536 times too large
-    vTemp = _mm_mul_ps(vTemp, g_XMFixupY16);
-    // y + 0x8000 to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, FixaddY16);
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadByteN2(const XMBYTEN2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            (pSource->x == -128) ? -1.f : (static_cast<float>(pSource->x)* (1.0f / 127.0f)),
-            (pSource->y == -128) ? -1.f : (static_cast<float>(pSource->y)* (1.0f / 127.0f)),
-            0.0f,
-            0.0f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint16x4_t vInt8 = vld1_dup_u16(reinterpret_cast<const uint16_t*>(pSource));
-    int16x8_t vInt16 = vmovl_s8(vreinterpret_s8_u16(vInt8));
-    int32x4_t vInt = vmovl_s16(vget_low_s16(vInt16));
-    vInt = vandq_s32(vInt, g_XMMaskXY);
-    float32x4_t R = vcvtq_f32_s32(vInt);
-    R = vmulq_n_f32(R, 1.0f / 127.0f);
-    return vmaxq_f32(R, vdupq_n_f32(-1.f));
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 1.0f / 127.0f, 1.0f / (127.0f * 256.0f), 0, 0 } } };
-    static const XMVECTORU32 Mask = { { { 0xFF, 0xFF00, 0, 0 } } };
-    // Splat the color in all four entries (x,z,y,w)
-    __m128i vInt = XM_LOADU_SI16(&pSource->v);
-    XMVECTOR vTemp = XM_PERMUTE_PS(_mm_castsi128_ps(vInt), _MM_SHUFFLE(0, 0, 0, 0));
-    // Mask
-    vTemp = _mm_and_ps(vTemp, Mask);
-    // x,y and z are unsigned! Flip the bits to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMXorByte4);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // x, y and z - 0x80 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMAddByte4);
-    // Fix y, z and w because they are too large
-    vTemp = _mm_mul_ps(vTemp, Scale);
-    // Clamp result (for case of -128)
-    return _mm_max_ps(vTemp, g_XMNegativeOne);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadByte2(const XMBYTE2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x),
-            static_cast<float>(pSource->y),
-            0.0f,
-            0.0f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint16x4_t vInt8 = vld1_dup_u16(reinterpret_cast<const uint16_t*>(pSource));
-    int16x8_t vInt16 = vmovl_s8(vreinterpret_s8_u16(vInt8));
-    int32x4_t vInt = vmovl_s16(vget_low_s16(vInt16));
-    vInt = vandq_s32(vInt, g_XMMaskXY);
-    return vcvtq_f32_s32(vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 1.0f, 1.0f / 256.0f, 1.0f / 65536.0f, 1.0f / (65536.0f * 256.0f) } } };
-    static const XMVECTORU32 Mask = { { { 0xFF, 0xFF00, 0, 0 } } };
-    // Splat the color in all four entries (x,z,y,w)
-    __m128i vInt = XM_LOADU_SI16(&pSource->v);
-    XMVECTOR vTemp = XM_PERMUTE_PS(_mm_castsi128_ps(vInt), _MM_SHUFFLE(0, 0, 0, 0));
-    // Mask
-    vTemp = _mm_and_ps(vTemp, Mask);
-    // x,y and z are unsigned! Flip the bits to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMXorByte4);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // x, y and z - 0x80 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMAddByte4);
-    // Fix y, z and w because they are too large
-    return _mm_mul_ps(vTemp, Scale);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUByteN2(const XMUBYTEN2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x)* (1.0f / 255.0f),
-            static_cast<float>(pSource->y)* (1.0f / 255.0f),
-            0.0f,
-            0.0f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint16x4_t vInt8 = vld1_dup_u16(reinterpret_cast<const uint16_t*>(pSource));
-    uint16x8_t vInt16 = vmovl_u8(vreinterpret_u8_u16(vInt8));
-    uint32x4_t vInt = vmovl_u16(vget_low_u16(vInt16));
-    vInt = vandq_u32(vInt, g_XMMaskXY);
-    float32x4_t R = vcvtq_f32_u32(vInt);
-    return vmulq_n_f32(R, 1.0f / 255.0f);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 1.0f / 255.0f, 1.0f / (255.0f * 256.0f), 0, 0 } } };
-    static const XMVECTORU32 Mask = { { { 0xFF, 0xFF00, 0, 0 } } };
-    // Splat the color in all four entries (x,z,y,w)
-    __m128i vInt = XM_LOADU_SI16(&pSource->v);
-    XMVECTOR vTemp = XM_PERMUTE_PS(_mm_castsi128_ps(vInt), _MM_SHUFFLE(0, 0, 0, 0));
-    // Mask
-    vTemp = _mm_and_ps(vTemp, Mask);
-    // w is signed! Flip the bits to convert the order to unsigned
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipW);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // w + 0x80 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMAddUDec4);
-    // Fix y, z and w because they are too large
-    return _mm_mul_ps(vTemp, Scale);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUByte2(const XMUBYTE2* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x),
-            static_cast<float>(pSource->y),
-            0.0f,
-            0.0f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint16x4_t vInt8 = vld1_dup_u16(reinterpret_cast<const uint16_t*>(pSource));
-    uint16x8_t vInt16 = vmovl_u8(vreinterpret_u8_u16(vInt8));
-    uint32x4_t vInt = vmovl_u16(vget_low_u16(vInt16));
-    vInt = vandq_u32(vInt, g_XMMaskXY);
-    return vcvtq_f32_u32(vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 Scale = { { { 1.0f, 1.0f / 256.0f, 0, 0 } } };
-    static const XMVECTORU32 Mask = { { { 0xFF, 0xFF00, 0, 0 } } };
-    // Splat the color in all four entries (x,z,y,w)
-    __m128i vInt = XM_LOADU_SI16(&pSource->v);
-    XMVECTOR vTemp = XM_PERMUTE_PS(_mm_castsi128_ps(vInt), _MM_SHUFFLE(0, 0, 0, 0));
-    // Mask
-    vTemp = _mm_and_ps(vTemp, Mask);
-    // w is signed! Flip the bits to convert the order to unsigned
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipW);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // w + 0x80 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMAddUDec4);
-    // Fix y, z and w because they are too large
-    return _mm_mul_ps(vTemp, Scale);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadU565(const XMU565* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            float(pSource->v & 0x1F),
-            float((pSource->v >> 5) & 0x3F),
-            float((pSource->v >> 11) & 0x1F),
-            0.f,
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORI32 U565And = { { { 0x1F, 0x3F << 5, 0x1F << 11, 0 } } };
-    static const XMVECTORF32 U565Mul = { { { 1.0f, 1.0f / 32.0f, 1.0f / 2048.f, 0 } } };
-    uint16x4_t vInt16 = vld1_dup_u16(reinterpret_cast<const uint16_t*>(pSource));
-    uint32x4_t vInt = vmovl_u16(vInt16);
-    vInt = vandq_u32(vInt, U565And);
-    float32x4_t R = vcvtq_f32_u32(vInt);
-    return vmulq_f32(R, U565Mul);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORI32 U565And = { { { 0x1F, 0x3F << 5, 0x1F << 11, 0 } } };
-    static const XMVECTORF32 U565Mul = { { { 1.0f, 1.0f / 32.0f, 1.0f / 2048.f, 0 } } };
-    // Get the 16 bit value and splat it
-    __m128i vInt = XM_LOADU_SI16(&pSource->v);
-    XMVECTOR vResult = XM_PERMUTE_PS(_mm_castsi128_ps(vInt), _MM_SHUFFLE(0, 0, 0, 0));
-    // Mask off x, y and z
-    vResult = _mm_and_ps(vResult, U565And);
-    // Convert to float
-    vResult = _mm_cvtepi32_ps(_mm_castps_si128(vResult));
-    // Normalize x, y, and z
-    vResult = _mm_mul_ps(vResult, U565Mul);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadFloat3PK(const XMFLOAT3PK* pSource) noexcept
-{
-    assert(pSource);
-
-    XM_ALIGNED_DATA(16) uint32_t Result[4];
-    uint32_t Mantissa;
-    uint32_t Exponent;
-
-    // X Channel (6-bit mantissa)
-    Mantissa = pSource->xm;
-
-    if (pSource->xe == 0x1f) // INF or NAN
-    {
-        Result[0] = static_cast<uint32_t>(0x7f800000 | (static_cast<int>(pSource->xm) << 17));
-    }
-    else
-    {
-        if (pSource->xe != 0) // The value is normalized
-        {
-            Exponent = pSource->xe;
-        }
-        else if (Mantissa != 0) // The value is denormalized
-        {
-            // Normalize the value in the resulting float
-            Exponent = 1;
-
-            do
-            {
-                Exponent--;
-                Mantissa <<= 1;
-            } while ((Mantissa & 0x40) == 0);
-
-            Mantissa &= 0x3F;
-        }
-        else // The value is zero
-        {
-            Exponent = static_cast<uint32_t>(-112);
-        }
-
-        Result[0] = ((Exponent + 112) << 23) | (Mantissa << 17);
-    }
-
-    // Y Channel (6-bit mantissa)
-    Mantissa = pSource->ym;
-
-    if (pSource->ye == 0x1f) // INF or NAN
-    {
-        Result[1] = static_cast<uint32_t>(0x7f800000 | (static_cast<int>(pSource->ym) << 17));
-    }
-    else
-    {
-        if (pSource->ye != 0) // The value is normalized
-        {
-            Exponent = pSource->ye;
-        }
-        else if (Mantissa != 0) // The value is denormalized
-        {
-            // Normalize the value in the resulting float
-            Exponent = 1;
-
-            do
-            {
-                Exponent--;
-                Mantissa <<= 1;
-            } while ((Mantissa & 0x40) == 0);
-
-            Mantissa &= 0x3F;
-        }
-        else // The value is zero
-        {
-            Exponent = static_cast<uint32_t>(-112);
-        }
-
-        Result[1] = ((Exponent + 112) << 23) | (Mantissa << 17);
-    }
-
-    // Z Channel (5-bit mantissa)
-    Mantissa = pSource->zm;
-
-    if (pSource->ze == 0x1f) // INF or NAN
-    {
-        Result[2] = static_cast<uint32_t>(0x7f800000 | (static_cast<int>(pSource->zm) << 17));
-    }
-    else
-    {
-        if (pSource->ze != 0) // The value is normalized
-        {
-            Exponent = pSource->ze;
-        }
-        else if (Mantissa != 0) // The value is denormalized
-        {
-            // Normalize the value in the resulting float
-            Exponent = 1;
-
-            do
-            {
-                Exponent--;
-                Mantissa <<= 1;
-            } while ((Mantissa & 0x20) == 0);
-
-            Mantissa &= 0x1F;
-        }
-        else // The value is zero
-        {
-            Exponent = static_cast<uint32_t>(-112);
-        }
-
-        Result[2] = ((Exponent + 112) << 23) | (Mantissa << 18);
-    }
-
-    return XMLoadFloat3A(reinterpret_cast<const XMFLOAT3A*>(&Result));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadFloat3SE(const XMFLOAT3SE* pSource) noexcept
-{
-    assert(pSource);
-
-    union { float f; int32_t i; } fi;
-    fi.i = 0x33800000 + (pSource->e << 23);
-    float Scale = fi.f;
-
-    XMVECTORF32 v = { { {
-                                Scale * float(pSource->xm),
-                                Scale * float(pSource->ym),
-                                Scale * float(pSource->zm),
-                                1.0f } } };
-    return v;
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadHalf4(const XMHALF4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_F16C_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-    __m128i V = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(pSource));
-    return _mm_cvtph_ps(V);
-#else
-    XMVECTORF32 vResult = { { {
-                                      XMConvertHalfToFloat(pSource->x),
-                                      XMConvertHalfToFloat(pSource->y),
-                                      XMConvertHalfToFloat(pSource->z),
-                                      XMConvertHalfToFloat(pSource->w)
-                              } } };
-    return vResult.v;
-#endif // !_XM_F16C_INTRINSICS_
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadShortN4(const XMSHORTN4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            (pSource->x == -32768) ? -1.f : (static_cast<float>(pSource->x)* (1.0f / 32767.0f)),
-            (pSource->y == -32768) ? -1.f : (static_cast<float>(pSource->y)* (1.0f / 32767.0f)),
-            (pSource->z == -32768) ? -1.f : (static_cast<float>(pSource->z)* (1.0f / 32767.0f)),
-            (pSource->w == -32768) ? -1.f : (static_cast<float>(pSource->w)* (1.0f / 32767.0f))
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int16x4_t vInt = vld1_s16(reinterpret_cast<const int16_t*>(pSource));
-    int32x4_t V = vmovl_s16(vInt);
-    float32x4_t vResult = vcvtq_f32_s32(V);
-    vResult = vmulq_n_f32(vResult, 1.0f / 32767.0f);
-    return vmaxq_f32(vResult, vdupq_n_f32(-1.f));
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Splat the color in all four entries (x,z,y,w)
-    __m128d vIntd = _mm_load1_pd(reinterpret_cast<const double*>(&pSource->x));
-    // Shift x&0ffff,z&0xffff,y&0xffff0000,w&0xffff0000
-    __m128 vTemp = _mm_and_ps(_mm_castpd_ps(vIntd), g_XMMaskX16Y16Z16W16);
-    // x and z are unsigned! Flip the bits to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipX16Y16Z16W16);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // x and z - 0x8000 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMFixX16Y16Z16W16);
-    // Convert to -1.0f - 1.0f
-    vTemp = _mm_mul_ps(vTemp, g_XMNormalizeX16Y16Z16W16);
-    // Very important! The entries are x,z,y,w, flip it to x,y,z,w
-    vTemp = XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 1, 2, 0));
-    // Clamp result (for case of -32768)
-    return _mm_max_ps(vTemp, g_XMNegativeOne);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadShort4(const XMSHORT4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x),
-            static_cast<float>(pSource->y),
-            static_cast<float>(pSource->z),
-            static_cast<float>(pSource->w)
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    int16x4_t vInt = vld1_s16(reinterpret_cast<const int16_t*>(pSource));
-    int32x4_t V = vmovl_s16(vInt);
-    return vcvtq_f32_s32(V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Splat the color in all four entries (x,z,y,w)
-    __m128d vIntd = _mm_load1_pd(reinterpret_cast<const double*>(&pSource->x));
-    // Shift x&0ffff,z&0xffff,y&0xffff0000,w&0xffff0000
-    __m128 vTemp = _mm_and_ps(_mm_castpd_ps(vIntd), g_XMMaskX16Y16Z16W16);
-    // x and z are unsigned! Flip the bits to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipX16Y16Z16W16);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // x and z - 0x8000 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMFixX16Y16Z16W16);
-    // Fix y and w because they are 65536 too large
-    vTemp = _mm_mul_ps(vTemp, g_XMFixupY16W16);
-    // Very important! The entries are x,z,y,w, flip it to x,y,z,w
-    return XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 1, 2, 0));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUShortN4(const XMUSHORTN4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x) / 65535.0f,
-            static_cast<float>(pSource->y) / 65535.0f,
-            static_cast<float>(pSource->z) / 65535.0f,
-            static_cast<float>(pSource->w) / 65535.0f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint16x4_t vInt = vld1_u16(reinterpret_cast<const uint16_t*>(pSource));
-    uint32x4_t V = vmovl_u16(vInt);
-    float32x4_t vResult = vcvtq_f32_u32(V);
-    return vmulq_n_f32(vResult, 1.0f / 65535.0f);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 FixupY16W16 = { { { 1.0f / 65535.0f, 1.0f / 65535.0f, 1.0f / (65535.0f * 65536.0f), 1.0f / (65535.0f * 65536.0f) } } };
-    static const XMVECTORF32 FixaddY16W16 = { { { 0, 0, 32768.0f * 65536.0f, 32768.0f * 65536.0f } } };
-    // Splat the color in all four entries (x,z,y,w)
-    __m128d vIntd = _mm_load1_pd(reinterpret_cast<const double*>(&pSource->x));
-    // Shift x&0ffff,z&0xffff,y&0xffff0000,w&0xffff0000
-    __m128 vTemp = _mm_and_ps(_mm_castpd_ps(vIntd), g_XMMaskX16Y16Z16W16);
-    // y and w are signed! Flip the bits to convert the order to unsigned
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipZW);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // y and w + 0x8000 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, FixaddY16W16);
-    // Fix y and w because they are 65536 too large
-    vTemp = _mm_mul_ps(vTemp, FixupY16W16);
-    // Very important! The entries are x,z,y,w, flip it to x,y,z,w
-    return XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 1, 2, 0));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUShort4(const XMUSHORT4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x),
-            static_cast<float>(pSource->y),
-            static_cast<float>(pSource->z),
-            static_cast<float>(pSource->w)
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint16x4_t vInt = vld1_u16(reinterpret_cast<const uint16_t*>(pSource));
-    uint32x4_t V = vmovl_u16(vInt);
-    return vcvtq_f32_u32(V);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 FixaddY16W16 = { { { 0, 0, 32768.0f, 32768.0f } } };
-    // Splat the color in all four entries (x,z,y,w)
-    __m128d vIntd = _mm_load1_pd(reinterpret_cast<const double*>(&pSource->x));
-    // Shift x&0ffff,z&0xffff,y&0xffff0000,w&0xffff0000
-    __m128 vTemp = _mm_and_ps(_mm_castpd_ps(vIntd), g_XMMaskX16Y16Z16W16);
-    // y and w are signed! Flip the bits to convert the order to unsigned
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipZW);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // Fix y and w because they are 65536 too large
-    vTemp = _mm_mul_ps(vTemp, g_XMFixupY16W16);
-    // y and w + 0x8000 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, FixaddY16W16);
-    // Very important! The entries are x,z,y,w, flip it to x,y,z,w
-    return XM_PERMUTE_PS(vTemp, _MM_SHUFFLE(3, 1, 2, 0));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadXDecN4(const XMXDECN4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    static const uint32_t SignExtend[] = { 0x00000000, 0xFFFFFC00 };
-
-    uint32_t ElementX = pSource->v & 0x3FF;
-    uint32_t ElementY = (pSource->v >> 10) & 0x3FF;
-    uint32_t ElementZ = (pSource->v >> 20) & 0x3FF;
-
-    XMVECTORF32 vResult = { { {
-            (ElementX == 0x200) ? -1.f : (static_cast<float>(static_cast<int16_t>(ElementX | SignExtend[ElementX >> 9])) / 511.0f),
-            (ElementY == 0x200) ? -1.f : (static_cast<float>(static_cast<int16_t>(ElementY | SignExtend[ElementY >> 9])) / 511.0f),
-            (ElementZ == 0x200) ? -1.f : (static_cast<float>(static_cast<int16_t>(ElementZ | SignExtend[ElementZ >> 9])) / 511.0f),
-            static_cast<float>(pSource->v >> 30) / 3.0f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vInt = vld1q_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    vInt = vandq_u32(vInt, g_XMMaskA2B10G10R10);
-    vInt = veorq_u32(vInt, g_XMFlipA2B10G10R10);
-    float32x4_t R = vcvtq_f32_s32(vreinterpretq_s32_u32(vInt));
-    R = vaddq_f32(R, g_XMFixAA2B10G10R10);
-    R = vmulq_f32(R, g_XMNormalizeA2B10G10R10);
-    return vmaxq_f32(R, vdupq_n_f32(-1.0f));
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Splat the color in all four entries
-    __m128 vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->v));
-    // Shift R&0xFF0000, G&0xFF00, B&0xFF, A&0xFF000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskA2B10G10R10);
-    // a is unsigned! Flip the bit to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipA2B10G10R10);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // RGB + 0, A + 0x80000000.f to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, g_XMFixAA2B10G10R10);
-    // Convert 0-255 to 0.0f-1.0f
-    vTemp = _mm_mul_ps(vTemp, g_XMNormalizeA2B10G10R10);
-    // Clamp result (for case of -512)
-    return _mm_max_ps(vTemp, g_XMNegativeOne);
-#endif
-}
-
-//------------------------------------------------------------------------------
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996)
-// C4996: ignore deprecation warning
-#endif
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadXDec4(const XMXDEC4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    static const uint32_t SignExtend[] = { 0x00000000, 0xFFFFFC00 };
-
-    uint32_t ElementX = pSource->v & 0x3FF;
-    uint32_t ElementY = (pSource->v >> 10) & 0x3FF;
-    uint32_t ElementZ = (pSource->v >> 20) & 0x3FF;
-
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(static_cast<int16_t>(ElementX | SignExtend[ElementX >> 9])),
-            static_cast<float>(static_cast<int16_t>(ElementY | SignExtend[ElementY >> 9])),
-            static_cast<float>(static_cast<int16_t>(ElementZ | SignExtend[ElementZ >> 9])),
-            static_cast<float>(pSource->v >> 30)
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORU32 XDec4Xor = { { { 0x200, 0x200 << 10, 0x200 << 20, 0x80000000 } } };
-    static const XMVECTORF32 XDec4Add = { { { -512.0f, -512.0f * 1024.0f, -512.0f * 1024.0f * 1024.0f, 32768 * 65536.0f } } };
-    uint32x4_t vInt = vld1q_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    vInt = vandq_u32(vInt, g_XMMaskDec4);
-    vInt = veorq_u32(vInt, XDec4Xor);
-    float32x4_t R = vcvtq_f32_s32(vreinterpretq_s32_u32(vInt));
-    R = vaddq_f32(R, XDec4Add);
-    return vmulq_f32(R, g_XMMulDec4);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORU32 XDec4Xor = { { { 0x200, 0x200 << 10, 0x200 << 20, 0x80000000 } } };
-    static const XMVECTORF32 XDec4Add = { { { -512.0f, -512.0f * 1024.0f, -512.0f * 1024.0f * 1024.0f, 32768 * 65536.0f } } };
-    // Splat the color in all four entries
-    XMVECTOR vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->v));
-    // Shift R&0xFF0000, G&0xFF00, B&0xFF, A&0xFF000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskDec4);
-    // a is unsigned! Flip the bit to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, XDec4Xor);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // RGB + 0, A + 0x80000000.f to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, XDec4Add);
-    // Convert 0-255 to 0.0f-1.0f
-    vTemp = _mm_mul_ps(vTemp, g_XMMulDec4);
-    return vTemp;
-#endif
-}
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUDecN4(const XMUDECN4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-
-    uint32_t ElementX = pSource->v & 0x3FF;
-    uint32_t ElementY = (pSource->v >> 10) & 0x3FF;
-    uint32_t ElementZ = (pSource->v >> 20) & 0x3FF;
-
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(ElementX) / 1023.0f,
-            static_cast<float>(ElementY) / 1023.0f,
-            static_cast<float>(ElementZ) / 1023.0f,
-            static_cast<float>(pSource->v >> 30) / 3.0f
-        } } };
-    return vResult.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 UDecN4Mul = { { { 1.0f / 1023.0f, 1.0f / (1023.0f * 1024.0f), 1.0f / (1023.0f * 1024.0f * 1024.0f), 1.0f / (3.0f * 1024.0f * 1024.0f * 1024.0f) } } };
-    uint32x4_t vInt = vld1q_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    vInt = vandq_u32(vInt, g_XMMaskDec4);
-    float32x4_t R = vcvtq_f32_u32(vInt);
-    return vmulq_f32(R, UDecN4Mul);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 UDecN4Mul = { { { 1.0f / 1023.0f, 1.0f / (1023.0f * 1024.0f), 1.0f / (1023.0f * 1024.0f * 1024.0f), 1.0f / (3.0f * 1024.0f * 1024.0f * 1024.0f) } } };
-    // Splat the color in all four entries
-    XMVECTOR vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->v));
-    // Shift R&0xFF0000, G&0xFF00, B&0xFF, A&0xFF000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskDec4);
-    // a is unsigned! Flip the bit to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipW);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // RGB + 0, A + 0x80000000.f to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, g_XMAddUDec4);
-    // Convert 0-255 to 0.0f-1.0f
-    vTemp = _mm_mul_ps(vTemp, UDecN4Mul);
-    return vTemp;
-#endif
-}
-
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUDecN4_XR(const XMUDECN4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-
-    int32_t ElementX = pSource->v & 0x3FF;
-    int32_t ElementY = (pSource->v >> 10) & 0x3FF;
-    int32_t ElementZ = (pSource->v >> 20) & 0x3FF;
-
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(ElementX - 0x180) / 510.0f,
-            static_cast<float>(ElementY - 0x180) / 510.0f,
-            static_cast<float>(ElementZ - 0x180) / 510.0f,
-            static_cast<float>(pSource->v >> 30) / 3.0f
-        } } };
-
-    return vResult.v;
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 XRMul = { { { 1.0f / 510.0f, 1.0f / (510.0f * 1024.0f), 1.0f / (510.0f * 1024.0f * 1024.0f), 1.0f / (3.0f * 1024.0f * 1024.0f * 1024.0f) } } };
-    static const XMVECTORI32 XRBias = { { { 0x180, 0x180 * 1024, 0x180 * 1024 * 1024, 0 } } };
-    uint32x4_t vInt = vld1q_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    vInt = vandq_u32(vInt, g_XMMaskDec4);
-    int32x4_t vTemp = vsubq_s32(vreinterpretq_s32_u32(vInt), XRBias);
-    vTemp = veorq_s32(vTemp, g_XMFlipW);
-    float32x4_t R = vcvtq_f32_s32(vTemp);
-    R = vaddq_f32(R, g_XMAddUDec4);
-    return vmulq_f32(R, XRMul);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 XRMul = { { { 1.0f / 510.0f, 1.0f / (510.0f * 1024.0f), 1.0f / (510.0f * 1024.0f * 1024.0f), 1.0f / (3.0f * 1024.0f * 1024.0f * 1024.0f) } } };
-    static const XMVECTORI32 XRBias = { { { 0x180, 0x180 * 1024, 0x180 * 1024 * 1024, 0 } } };
-    // Splat the color in all four entries
-    XMVECTOR vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->v));
-    // Mask channels
-    vTemp = _mm_and_ps(vTemp, g_XMMaskDec4);
-    // Subtract bias
-    vTemp = _mm_castsi128_ps(_mm_sub_epi32(_mm_castps_si128(vTemp), XRBias));
-    // a is unsigned! Flip the bit to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipW);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // RGB + 0, A + 0x80000000.f to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, g_XMAddUDec4);
-    // Convert to 0.0f-1.0f
-    return _mm_mul_ps(vTemp, XRMul);
-#endif
-}
-
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUDec4(const XMUDEC4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    uint32_t ElementX = pSource->v & 0x3FF;
-    uint32_t ElementY = (pSource->v >> 10) & 0x3FF;
-    uint32_t ElementZ = (pSource->v >> 20) & 0x3FF;
-
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(ElementX),
-            static_cast<float>(ElementY),
-            static_cast<float>(ElementZ),
-            static_cast<float>(pSource->v >> 30)
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vInt = vld1q_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    vInt = vandq_u32(vInt, g_XMMaskDec4);
-    float32x4_t R = vcvtq_f32_u32(vInt);
-    return vmulq_f32(R, g_XMMulDec4);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Splat the color in all four entries
-    XMVECTOR vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->v));
-    // Shift R&0xFF0000, G&0xFF00, B&0xFF, A&0xFF000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskDec4);
-    // a is unsigned! Flip the bit to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipW);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // RGB + 0, A + 0x80000000.f to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, g_XMAddUDec4);
-    // Convert 0-255 to 0.0f-1.0f
-    vTemp = _mm_mul_ps(vTemp, g_XMMulDec4);
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996)
-// C4996: ignore deprecation warning
-#endif
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadDecN4(const XMDECN4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    static const uint32_t SignExtend[] = { 0x00000000, 0xFFFFFC00 };
-    static const uint32_t SignExtendW[] = { 0x00000000, 0xFFFFFFFC };
-
-    uint32_t ElementX = pSource->v & 0x3FF;
-    uint32_t ElementY = (pSource->v >> 10) & 0x3FF;
-    uint32_t ElementZ = (pSource->v >> 20) & 0x3FF;
-    uint32_t ElementW = pSource->v >> 30;
-
-    XMVECTORF32 vResult = { { {
-            (ElementX == 0x200) ? -1.f : (static_cast<float>(static_cast<int16_t>(ElementX | SignExtend[ElementX >> 9])) / 511.0f),
-            (ElementY == 0x200) ? -1.f : (static_cast<float>(static_cast<int16_t>(ElementY | SignExtend[ElementY >> 9])) / 511.0f),
-            (ElementZ == 0x200) ? -1.f : (static_cast<float>(static_cast<int16_t>(ElementZ | SignExtend[ElementZ >> 9])) / 511.0f),
-            (ElementW == 0x2) ? -1.f : static_cast<float>(static_cast<int16_t>(ElementW | SignExtendW[(ElementW >> 1) & 1]))
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORF32 DecN4Mul = { { { 1.0f / 511.0f, 1.0f / (511.0f * 1024.0f), 1.0f / (511.0f * 1024.0f * 1024.0f), 1.0f / (1024.0f * 1024.0f * 1024.0f) } } };
-    uint32x4_t vInt = vld1q_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    vInt = vandq_u32(vInt, g_XMMaskDec4);
-    vInt = veorq_u32(vInt, g_XMXorDec4);
-    float32x4_t R = vcvtq_f32_s32(vreinterpretq_s32_u32(vInt));
-    R = vaddq_f32(R, g_XMAddDec4);
-    R = vmulq_f32(R, DecN4Mul);
-    return vmaxq_f32(R, vdupq_n_f32(-1.0f));
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 DecN4Mul = { { { 1.0f / 511.0f, 1.0f / (511.0f * 1024.0f), 1.0f / (511.0f * 1024.0f * 1024.0f), 1.0f / (1024.0f * 1024.0f * 1024.0f) } } };
-    // Splat the color in all four entries
-    XMVECTOR vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->v));
-    // Shift R&0xFF0000, G&0xFF00, B&0xFF, A&0xFF000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskDec4);
-    // a is unsigned! Flip the bit to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMXorDec4);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // RGB + 0, A + 0x80000000.f to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, g_XMAddDec4);
-    // Convert 0-255 to 0.0f-1.0f
-    vTemp = _mm_mul_ps(vTemp, DecN4Mul);
-    // Clamp result (for case of -512/-1)
-    return _mm_max_ps(vTemp, g_XMNegativeOne);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadDec4(const XMDEC4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    static const uint32_t SignExtend[] = { 0x00000000, 0xFFFFFC00 };
-    static const uint32_t SignExtendW[] = { 0x00000000, 0xFFFFFFFC };
-
-    uint32_t ElementX = pSource->v & 0x3FF;
-    uint32_t ElementY = (pSource->v >> 10) & 0x3FF;
-    uint32_t ElementZ = (pSource->v >> 20) & 0x3FF;
-    uint32_t ElementW = pSource->v >> 30;
-
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(static_cast<int16_t>(ElementX | SignExtend[ElementX >> 9])),
-            static_cast<float>(static_cast<int16_t>(ElementY | SignExtend[ElementY >> 9])),
-            static_cast<float>(static_cast<int16_t>(ElementZ | SignExtend[ElementZ >> 9])),
-            static_cast<float>(static_cast<int16_t>(ElementW | SignExtendW[ElementW >> 1]))
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x4_t vInt = vld1q_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    vInt = vandq_u32(vInt, g_XMMaskDec4);
-    vInt = veorq_u32(vInt, g_XMXorDec4);
-    float32x4_t R = vcvtq_f32_s32(vreinterpretq_s32_u32(vInt));
-    R = vaddq_f32(R, g_XMAddDec4);
-    return vmulq_f32(R, g_XMMulDec4);
-#elif defined(_XM_SSE_INTRINSICS_)
-    // Splat the color in all four entries
-    XMVECTOR vTemp = _mm_load_ps1(reinterpret_cast<const float*>(&pSource->v));
-    // Shift R&0xFF0000, G&0xFF00, B&0xFF, A&0xFF000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskDec4);
-    // a is unsigned! Flip the bit to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMXorDec4);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // RGB + 0, A + 0x80000000.f to undo the signed order.
-    vTemp = _mm_add_ps(vTemp, g_XMAddDec4);
-    // Convert 0-255 to 0.0f-1.0f
-    vTemp = _mm_mul_ps(vTemp, g_XMMulDec4);
-    return vTemp;
-#endif
-}
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUByteN4(const XMUBYTEN4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x) / 255.0f,
-            static_cast<float>(pSource->y) / 255.0f,
-            static_cast<float>(pSource->z) / 255.0f,
-            static_cast<float>(pSource->w) / 255.0f
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vInt8 = vld1_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    uint16x8_t vInt16 = vmovl_u8(vreinterpret_u8_u32(vInt8));
-    uint32x4_t vInt = vmovl_u16(vget_low_u16(vInt16));
-    float32x4_t R = vcvtq_f32_u32(vInt);
-    return vmulq_n_f32(R, 1.0f / 255.0f);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 LoadUByteN4Mul = { { { 1.0f / 255.0f, 1.0f / (255.0f * 256.0f), 1.0f / (255.0f * 65536.0f), 1.0f / (255.0f * 65536.0f * 256.0f) } } };
-    // Splat the color in all four entries (x,z,y,w)
-    XMVECTOR vTemp = _mm_load1_ps(reinterpret_cast<const float*>(&pSource->x));
-    // Mask x&0ff,y&0xff00,z&0xff0000,w&0xff000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskByte4);
-    // w is signed! Flip the bits to convert the order to unsigned
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipW);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // w + 0x80 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMAddUDec4);
-    // Fix y, z and w because they are too large
-    vTemp = _mm_mul_ps(vTemp, LoadUByteN4Mul);
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUByte4(const XMUBYTE4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x),
-            static_cast<float>(pSource->y),
-            static_cast<float>(pSource->z),
-            static_cast<float>(pSource->w)
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vInt8 = vld1_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    uint16x8_t vInt16 = vmovl_u8(vreinterpret_u8_u32(vInt8));
-    uint32x4_t vInt = vmovl_u16(vget_low_u16(vInt16));
-    return vcvtq_f32_u32(vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 LoadUByte4Mul = { { { 1.0f, 1.0f / 256.0f, 1.0f / 65536.0f, 1.0f / (65536.0f * 256.0f) } } };
-    // Splat the color in all four entries (x,z,y,w)
-    XMVECTOR vTemp = _mm_load1_ps(reinterpret_cast<const float*>(&pSource->x));
-    // Mask x&0ff,y&0xff00,z&0xff0000,w&0xff000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskByte4);
-    // w is signed! Flip the bits to convert the order to unsigned
-    vTemp = _mm_xor_ps(vTemp, g_XMFlipW);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // w + 0x80 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMAddUDec4);
-    // Fix y, z and w because they are too large
-    vTemp = _mm_mul_ps(vTemp, LoadUByte4Mul);
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadByteN4(const XMBYTEN4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            (pSource->x == -128) ? -1.f : (static_cast<float>(pSource->x) / 127.0f),
-            (pSource->y == -128) ? -1.f : (static_cast<float>(pSource->y) / 127.0f),
-            (pSource->z == -128) ? -1.f : (static_cast<float>(pSource->z) / 127.0f),
-            (pSource->w == -128) ? -1.f : (static_cast<float>(pSource->w) / 127.0f)
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vInt8 = vld1_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    int16x8_t vInt16 = vmovl_s8(vreinterpret_s8_u32(vInt8));
-    int32x4_t vInt = vmovl_s16(vget_low_s16(vInt16));
-    float32x4_t R = vcvtq_f32_s32(vInt);
-    R = vmulq_n_f32(R, 1.0f / 127.0f);
-    return vmaxq_f32(R, vdupq_n_f32(-1.f));
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 LoadByteN4Mul = { { { 1.0f / 127.0f, 1.0f / (127.0f * 256.0f), 1.0f / (127.0f * 65536.0f), 1.0f / (127.0f * 65536.0f * 256.0f) } } };
-    // Splat the color in all four entries (x,z,y,w)
-    XMVECTOR vTemp = _mm_load1_ps(reinterpret_cast<const float*>(&pSource->x));
-    // Mask x&0ff,y&0xff00,z&0xff0000,w&0xff000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskByte4);
-    // x,y and z are unsigned! Flip the bits to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMXorByte4);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // x, y and z - 0x80 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMAddByte4);
-    // Fix y, z and w because they are too large
-    vTemp = _mm_mul_ps(vTemp, LoadByteN4Mul);
-    // Clamp result (for case of -128)
-    return _mm_max_ps(vTemp, g_XMNegativeOne);
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadByte4(const XMBYTE4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            static_cast<float>(pSource->x),
-            static_cast<float>(pSource->y),
-            static_cast<float>(pSource->z),
-            static_cast<float>(pSource->w)
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    uint32x2_t vInt8 = vld1_dup_u32(reinterpret_cast<const uint32_t*>(pSource));
-    int16x8_t vInt16 = vmovl_s8(vreinterpret_s8_u32(vInt8));
-    int32x4_t vInt = vmovl_s16(vget_low_s16(vInt16));
-    return vcvtq_f32_s32(vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORF32 LoadByte4Mul = { { { 1.0f, 1.0f / 256.0f, 1.0f / 65536.0f, 1.0f / (65536.0f * 256.0f) } } };
-    // Splat the color in all four entries (x,z,y,w)
-    XMVECTOR vTemp = _mm_load1_ps(reinterpret_cast<const float*>(&pSource->x));
-    // Mask x&0ff,y&0xff00,z&0xff0000,w&0xff000000
-    vTemp = _mm_and_ps(vTemp, g_XMMaskByte4);
-    // x,y and z are unsigned! Flip the bits to convert the order to signed
-    vTemp = _mm_xor_ps(vTemp, g_XMXorByte4);
-    // Convert to floating point numbers
-    vTemp = _mm_cvtepi32_ps(_mm_castps_si128(vTemp));
-    // x, y and z - 0x80 to complete the conversion
-    vTemp = _mm_add_ps(vTemp, g_XMAddByte4);
-    // Fix y, z and w because they are too large
-    vTemp = _mm_mul_ps(vTemp, LoadByte4Mul);
-    return vTemp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadUNibble4(const XMUNIBBLE4* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            float(pSource->v & 0xF),
-            float((pSource->v >> 4) & 0xF),
-            float((pSource->v >> 8) & 0xF),
-            float((pSource->v >> 12) & 0xF)
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORI32 UNibble4And = { { { 0xF, 0xF0, 0xF00, 0xF000 } } };
-    static const XMVECTORF32 UNibble4Mul = { { { 1.0f, 1.0f / 16.f, 1.0f / 256.f, 1.0f / 4096.f } } };
-    uint16x4_t vInt16 = vld1_dup_u16(reinterpret_cast<const uint16_t*>(pSource));
-    uint32x4_t vInt = vmovl_u16(vInt16);
-    vInt = vandq_u32(vInt, UNibble4And);
-    float32x4_t R = vcvtq_f32_u32(vInt);
-    return vmulq_f32(R, UNibble4Mul);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORI32 UNibble4And = { { { 0xF, 0xF0, 0xF00, 0xF000 } } };
-    static const XMVECTORF32 UNibble4Mul = { { { 1.0f, 1.0f / 16.f, 1.0f / 256.f, 1.0f / 4096.f } } };
-    // Get the 16 bit value and splat it
-    __m128i vInt = XM_LOADU_SI16(&pSource->v);
-    XMVECTOR vResult = XM_PERMUTE_PS(_mm_castsi128_ps(vInt), _MM_SHUFFLE(0,0,0,0));
-    // Mask off x, y and z
-    vResult = _mm_and_ps(vResult, UNibble4And);
-    // Convert to float
-    vResult = _mm_cvtepi32_ps(_mm_castps_si128(vResult));
-    // Normalize x, y, and z
-    vResult = _mm_mul_ps(vResult, UNibble4Mul);
-    return vResult;
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMVECTOR XM_CALLCONV XMLoadU555(const XMU555* pSource) noexcept
-{
-    assert(pSource);
-#if defined(_XM_NO_INTRINSICS_)
-    XMVECTORF32 vResult = { { {
-            float(pSource->v & 0x1F),
-            float((pSource->v >> 5) & 0x1F),
-            float((pSource->v >> 10) & 0x1F),
-            float((pSource->v >> 15) & 0x1)
-        } } };
-    return vResult.v;
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-    static const XMVECTORI32 U555And = { { { 0x1F, 0x1F << 5, 0x1F << 10, 0x8000 } } };
-    static const XMVECTORF32 U555Mul = { { { 1.0f, 1.0f / 32.f, 1.0f / 1024.f, 1.0f / 32768.f } } };
-    uint16x4_t vInt16 = vld1_dup_u16(reinterpret_cast<const uint16_t*>(pSource));
-    uint32x4_t vInt = vmovl_u16(vInt16);
-    vInt = vandq_u32(vInt, U555And);
-    float32x4_t R = vcvtq_f32_u32(vInt);
-    return vmulq_f32(R, U555Mul);
-#elif defined(_XM_SSE_INTRINSICS_)
-    static const XMVECTORI32 U555And = { { { 0x1F, 0x1F << 5, 0x1F << 10, 0x8000 } } };
-    static const XMVECTORF32 U555Mul = { { { 1.0f, 1.0f / 32.f, 1.0f / 1024.f, 1.0f / 32768.f } } };
-    // Get the 16bit value and splat it
-    __m128i vInt = XM_LOADU_SI16(&pSource->v);
-    XMVECTOR vResult = XM_PERMUTE_PS(_mm_castsi128_ps(vInt), _MM_SHUFFLE(0, 0, 0, 0));
-    // Mask off x, y and z
-    vResult = _mm_and_ps(vResult, U555And);
-    // Convert to float
-    vResult = _mm_cvtepi32_ps(_mm_castps_si128(vResult));
-    // Normalize x, y, and z
-    vResult = _mm_mul_ps(vResult, U555Mul);
-    return vResult;
-#endif
-}
-
-#ifdef _PREFAST_
-#pragma prefast(pop)
-#endif
-
-/****************************************************************************
- *
- * Vector and matrix store operations
- *
- ****************************************************************************/
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreColor
-(
-        XMCOLOR* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorSaturate(V);
-    N = XMVectorMultiply(N, g_UByteMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->c = (static_cast<uint32_t>(tmp.w) << 24) |
-        (static_cast<uint32_t>(tmp.x) << 16) |
-        (static_cast<uint32_t>(tmp.y) << 8) |
-        static_cast<uint32_t>(tmp.z);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(0));
-    R = vminq_f32(R, vdupq_n_f32(1.0f));
-    R = vmulq_n_f32(R, 255.0f);
-    R = XMVectorRound(R);
-    uint32x4_t vInt32 = vcvtq_u32_f32(R);
-    uint16x4_t vInt16 = vqmovn_u32(vInt32);
-    uint8x8_t vInt8 = vqmovn_u16(vcombine_u16(vInt16, vInt16));
-    uint32_t rgba = vget_lane_u32(vreinterpret_u32_u8(vInt8), 0);
-    pDestination->c = (rgba & 0xFF00FF00) | ((rgba >> 16) & 0xFF) | ((rgba << 16) & 0xFF0000);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Set <0 to 0
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    // Set>1 to 1
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    // Convert to 0-255
-    vResult = _mm_mul_ps(vResult, g_UByteMax);
-    // Shuffle RGBA to ARGB
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(3, 0, 1, 2));
-    // Convert to int
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // Mash to shorts
-    vInt = _mm_packs_epi32(vInt, vInt);
-    // Mash to bytes
-    vInt = _mm_packus_epi16(vInt, vInt);
-    // Store the color
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->c), _mm_castsi128_ps(vInt));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreHalf2
-(
-        XMHALF2* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_F16C_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-__m128i V1 = _mm_cvtps_ph(V, _MM_FROUND_TO_NEAREST_INT);
-    _mm_store_ss(reinterpret_cast<float*>(pDestination), _mm_castsi128_ps(V1));
-#else
-pDestination->x = XMConvertFloatToHalf(XMVectorGetX(V));
-pDestination->y = XMConvertFloatToHalf(XMVectorGetY(V));
-#endif // !_XM_F16C_INTRINSICS_
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreShortN2
-(
-        XMSHORTN2* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, g_XMNegativeOne.v, g_XMOne.v);
-    N = XMVectorMultiply(N, g_ShortMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<int16_t>(tmp.x);
-    pDestination->y = static_cast<int16_t>(tmp.y);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(-1.f));
-    R = vminq_f32(R, vdupq_n_f32(1.0f));
-    R = vmulq_n_f32(R, 32767.0f);
-    int32x4_t vInt32 = vcvtq_s32_f32(R);
-    int16x4_t vInt16 = vqmovn_s32(vInt32);
-    vst1_lane_u32(&pDestination->v, vreinterpret_u32_s16(vInt16), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-XMVECTOR vResult = _mm_max_ps(V, g_XMNegativeOne);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    vResult = _mm_mul_ps(vResult, g_ShortMax);
-    __m128i vResulti = _mm_cvtps_epi32(vResult);
-    vResulti = _mm_packs_epi32(vResulti, vResulti);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->x), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreShort2
-(
-        XMSHORT2* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, g_ShortMin, g_ShortMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<int16_t>(tmp.x);
-    pDestination->y = static_cast<int16_t>(tmp.y);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(-32767.f));
-    R = vminq_f32(R, vdupq_n_f32(32767.0f));
-    int32x4_t vInt32 = vcvtq_s32_f32(R);
-    int16x4_t vInt16 = vqmovn_s32(vInt32);
-    vst1_lane_u32(&pDestination->v, vreinterpret_u32_s16(vInt16), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Bounds check
-    XMVECTOR vResult = _mm_max_ps(V, g_ShortMin);
-    vResult = _mm_min_ps(vResult, g_ShortMax);
-    // Convert to int with rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // Pack the ints into shorts
-    vInt = _mm_packs_epi32(vInt, vInt);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->x), _mm_castsi128_ps(vInt));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUShortN2
-(
-        XMUSHORTN2* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorSaturate(V);
-    N = XMVectorMultiplyAdd(N, g_UShortMax, g_XMOneHalf.v);
-    N = XMVectorTruncate(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<uint16_t>(tmp.x);
-    pDestination->y = static_cast<uint16_t>(tmp.y);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(0.f));
-    R = vminq_f32(R, vdupq_n_f32(1.0f));
-    R = vmulq_n_f32(R, 65535.0f);
-    R = vaddq_f32(R, g_XMOneHalf);
-    uint32x4_t vInt32 = vcvtq_u32_f32(R);
-    uint16x4_t vInt16 = vqmovn_u32(vInt32);
-    vst1_lane_u32(&pDestination->v, vreinterpret_u32_u16(vInt16), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Bounds check
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    vResult = _mm_mul_ps(vResult, g_UShortMax);
-    vResult = _mm_add_ps(vResult, g_XMOneHalf);
-    // Convert to int
-    __m128i vInt = _mm_cvttps_epi32(vResult);
-    // Since the SSE pack instruction clamps using signed rules,
-    // manually extract the values to store them to memory
-    pDestination->x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    pDestination->y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUShort2
-(
-        XMUSHORT2* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, XMVectorZero(), g_UShortMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<uint16_t>(tmp.x);
-    pDestination->y = static_cast<uint16_t>(tmp.y);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(0.f));
-    R = vminq_f32(R, vdupq_n_f32(65535.0f));
-    uint32x4_t vInt32 = vcvtq_u32_f32(R);
-    uint16x4_t vInt16 = vqmovn_u32(vInt32);
-    vst1_lane_u32(&pDestination->v, vreinterpret_u32_u16(vInt16), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Bounds check
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_UShortMax);
-    // Convert to int with rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // Since the SSE pack instruction clamps using signed rules,
-    // manually extract the values to store them to memory
-    pDestination->x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    pDestination->y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreByteN2
-(
-        XMBYTEN2* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, g_XMNegativeOne.v, g_XMOne.v);
-    N = XMVectorMultiply(N, g_ByteMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<int8_t>(tmp.x);
-    pDestination->y = static_cast<int8_t>(tmp.y);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(-1.f));
-    R = vminq_f32(R, vdupq_n_f32(1.0f));
-    R = vmulq_n_f32(R, 127.0f);
-    int32x4_t vInt32 = vcvtq_s32_f32(R);
-    int16x4_t vInt16 = vqmovn_s32(vInt32);
-    int8x8_t vInt8 = vqmovn_s16(vcombine_s16(vInt16, vInt16));
-    vst1_lane_u16(reinterpret_cast<uint16_t*>(pDestination), vreinterpret_u16_s8(vInt8), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_XMNegativeOne);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, g_ByteMax);
-    // Convert to int by rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // No SSE operations will write to 16-bit values, so we have to extract them manually
-    auto x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    auto y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-    pDestination->v = static_cast<uint16_t>(((static_cast<int>(y) & 0xFF) << 8) | (static_cast<int>(x) & 0xFF));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreByte2
-(
-        XMBYTE2* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, g_ByteMin, g_ByteMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<int8_t>(tmp.x);
-    pDestination->y = static_cast<int8_t>(tmp.y);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(-127.f));
-    R = vminq_f32(R, vdupq_n_f32(127.0f));
-    int32x4_t vInt32 = vcvtq_s32_f32(R);
-    int16x4_t vInt16 = vqmovn_s32(vInt32);
-    int8x8_t vInt8 = vqmovn_s16(vcombine_s16(vInt16, vInt16));
-    vst1_lane_u16(reinterpret_cast<uint16_t*>(pDestination), vreinterpret_u16_s8(vInt8), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_ByteMin);
-    vResult = _mm_min_ps(vResult, g_ByteMax);
-    // Convert to int by rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // No SSE operations will write to 16-bit values, so we have to extract them manually
-    auto x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    auto y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-    pDestination->v = static_cast<uint16_t>(((static_cast<int>(y) & 0xFF) << 8) | (static_cast<int>(x) & 0xFF));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUByteN2
-(
-        XMUBYTEN2* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorSaturate(V);
-    N = XMVectorMultiplyAdd(N, g_UByteMax, g_XMOneHalf.v);
-    N = XMVectorTruncate(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<uint8_t>(tmp.x);
-    pDestination->y = static_cast<uint8_t>(tmp.y);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(0.f));
-    R = vminq_f32(R, vdupq_n_f32(1.0f));
-    R = vmulq_n_f32(R, 255.0f);
-    R = vaddq_f32(R, g_XMOneHalf);
-    uint32x4_t vInt32 = vcvtq_u32_f32(R);
-    uint16x4_t vInt16 = vqmovn_u32(vInt32);
-    uint8x8_t vInt8 = vqmovn_u16(vcombine_u16(vInt16, vInt16));
-    vst1_lane_u16(reinterpret_cast<uint16_t*>(pDestination), vreinterpret_u16_u8(vInt8), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, g_UByteMax);
-    vResult = _mm_add_ps(vResult, g_XMOneHalf);
-    // Convert to int
-    __m128i vInt = _mm_cvttps_epi32(vResult);
-    // No SSE operations will write to 16-bit values, so we have to extract them manually
-    auto x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    auto y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-    pDestination->v = static_cast<uint16_t>(((static_cast<int>(y) & 0xFF) << 8) | (static_cast<int>(x) & 0xFF));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUByte2
-(
-        XMUBYTE2* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, XMVectorZero(), g_UByteMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<uint8_t>(tmp.x);
-    pDestination->y = static_cast<uint8_t>(tmp.y);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(0.f));
-    R = vminq_f32(R, vdupq_n_f32(255.0f));
-    uint32x4_t vInt32 = vcvtq_u32_f32(R);
-    uint16x4_t vInt16 = vqmovn_u32(vInt32);
-    uint8x8_t vInt8 = vqmovn_u16(vcombine_u16(vInt16, vInt16));
-    vst1_lane_u16(reinterpret_cast<uint16_t*>(pDestination), vreinterpret_u16_u8(vInt8), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_UByteMax);
-    // Convert to int by rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // No SSE operations will write to 16-bit values, so we have to extract them manually
-    auto x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    auto y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-    pDestination->v = static_cast<uint16_t>(((static_cast<int>(y) & 0xFF) << 8) | (static_cast<int>(x) & 0xFF));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreU565
-(
-        XMU565* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-static const XMVECTORF32 Max = { { { 31.0f, 63.0f, 31.0f, 0.0f } } };
-
-#if defined(_XM_NO_INTRINSICS_)
-XMVECTOR N = XMVectorClamp(V, XMVectorZero(), Max.v);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint16_t>(
-        ((static_cast<int>(tmp.z) & 0x1F) << 11)
-        | ((static_cast<int>(tmp.y) & 0x3F) << 5)
-        | ((static_cast<int>(tmp.x) & 0x1F)));
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 Scale = { { { 1.0f, 32.f, 32.f * 64.f, 0.f } } };
-    static const XMVECTORU32 Mask = { { { 0x1F, 0x3F << 5, 0x1F << 11, 0 } } };
-    float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(0));
-    vResult = vminq_f32(vResult, Max);
-    vResult = vmulq_f32(vResult, Scale);
-    uint32x4_t vResulti = vcvtq_u32_f32(vResult);
-    vResulti = vandq_u32(vResulti, Mask);
-    // Do a horizontal or of 4 entries
-    uint32x2_t vTemp = vget_low_u32(vResulti);
-    uint32x2_t vhi = vget_high_u32(vResulti);
-    vTemp = vorr_u32(vTemp, vhi);
-    vTemp = vpadd_u32(vTemp, vTemp);
-    vst1_lane_u16(&pDestination->v, vreinterpret_u16_u32(vTemp), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Bounds check
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, Max);
-    // Convert to int with rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // No SSE operations will write to 16-bit values, so we have to extract them manually
-    auto x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    auto y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-    auto z = static_cast<uint16_t>(_mm_extract_epi16(vInt, 4));
-    pDestination->v = static_cast<uint16_t>(
-        ((static_cast<int>(z) & 0x1F) << 11)
-        | ((static_cast<int>(y) & 0x3F) << 5)
-        | ((static_cast<int>(x) & 0x1F)));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat3PK
-(
-        XMFLOAT3PK* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-
-XM_ALIGNED_DATA(16) uint32_t IValue[4];
-XMStoreFloat3A(reinterpret_cast<XMFLOAT3A*>(&IValue), V);
-
-uint32_t Result[3];
-
-// X & Y Channels (5-bit exponent, 6-bit mantissa)
-for (uint32_t j = 0; j < 2; ++j)
-{
-uint32_t Sign = IValue[j] & 0x80000000;
-uint32_t I = IValue[j] & 0x7FFFFFFF;
-
-if ((I & 0x7F800000) == 0x7F800000)
-{
-// INF or NAN
-Result[j] = 0x7C0U;
-if ((I & 0x7FFFFF) != 0)
-{
-Result[j] = 0x7FFU;
-}
-else if (Sign)
-{
-// -INF is clamped to 0 since 3PK is positive only
-Result[j] = 0;
-}
-}
-else if (Sign || I < 0x35800000)
-{
-// 3PK is positive only, so clamp to zero
-Result[j] = 0;
-}
-else if (I > 0x477E0000U)
-{
-// The number is too large to be represented as a float11, set to max
-Result[j] = 0x7BFU;
-}
-else
-{
-if (I < 0x38800000U)
-{
-// The number is too small to be represented as a normalized float11
-// Convert it to a denormalized value.
-uint32_t Shift = 113U - (I >> 23U);
-I = (0x800000U | (I & 0x7FFFFFU)) >> Shift;
-}
-else
-{
-// Rebias the exponent to represent the value as a normalized float11
-I += 0xC8000000U;
-}
-
-Result[j] = ((I + 0xFFFFU + ((I >> 17U) & 1U)) >> 17U) & 0x7ffU;
-}
-}
-
-// Z Channel (5-bit exponent, 5-bit mantissa)
-uint32_t Sign = IValue[2] & 0x80000000;
-uint32_t I = IValue[2] & 0x7FFFFFFF;
-
-if ((I & 0x7F800000) == 0x7F800000)
-{
-// INF or NAN
-Result[2] = 0x3E0U;
-if (I & 0x7FFFFF)
-{
-Result[2] = 0x3FFU;
-}
-else if (Sign || I < 0x36000000)
-{
-// -INF is clamped to 0 since 3PK is positive only
-Result[2] = 0;
-}
-}
-else if (Sign)
-{
-// 3PK is positive only, so clamp to zero
-Result[2] = 0;
-}
-else if (I > 0x477C0000U)
-{
-// The number is too large to be represented as a float10, set to max
-Result[2] = 0x3DFU;
-}
-else
-{
-if (I < 0x38800000U)
-{
-// The number is too small to be represented as a normalized float10
-// Convert it to a denormalized value.
-uint32_t Shift = 113U - (I >> 23U);
-I = (0x800000U | (I & 0x7FFFFFU)) >> Shift;
-}
-else
-{
-// Rebias the exponent to represent the value as a normalized float10
-I += 0xC8000000U;
-}
-
-Result[2] = ((I + 0x1FFFFU + ((I >> 18U) & 1U)) >> 18U) & 0x3ffU;
-}
-
-// Pack Result into memory
-pDestination->v = (Result[0] & 0x7ff)
-                  | ((Result[1] & 0x7ff) << 11)
-                  | ((Result[2] & 0x3ff) << 22);
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreFloat3SE
-(
-        XMFLOAT3SE* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-
-XMFLOAT3A tmp;
-XMStoreFloat3A(&tmp, V);
-
-static constexpr float maxf9 = float(0x1FF << 7);
-static constexpr float minf9 = float(1.f / (1 << 16));
-
-float x = (tmp.x >= 0.f) ? ((tmp.x > maxf9) ? maxf9 : tmp.x) : 0.f;
-float y = (tmp.y >= 0.f) ? ((tmp.y > maxf9) ? maxf9 : tmp.y) : 0.f;
-float z = (tmp.z >= 0.f) ? ((tmp.z > maxf9) ? maxf9 : tmp.z) : 0.f;
-
-const float max_xy = (x > y) ? x : y;
-const float max_xyz = (max_xy > z) ? max_xy : z;
-
-const float maxColor = (max_xyz > minf9) ? max_xyz : minf9;
-
-union { float f; int32_t i; } fi;
-fi.f = maxColor;
-fi.i += 0x00004000; // round up leaving 9 bits in fraction (including assumed 1)
-
-auto exp = static_cast<uint32_t>(fi.i) >> 23;
-pDestination->e = exp - 0x6f;
-
-fi.i = static_cast<int32_t>(0x83000000 - (exp << 23));
-float ScaleR = fi.f;
-
-pDestination->xm = static_cast<uint32_t>(Internal::round_to_nearest(x * ScaleR));
-pDestination->ym = static_cast<uint32_t>(Internal::round_to_nearest(y * ScaleR));
-pDestination->zm = static_cast<uint32_t>(Internal::round_to_nearest(z * ScaleR));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreHalf4
-(
-        XMHALF4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_F16C_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
-__m128i V1 = _mm_cvtps_ph(V, _MM_FROUND_TO_NEAREST_INT);
-    _mm_storel_epi64(reinterpret_cast<__m128i*>(pDestination), V1);
-#else
-XMFLOAT4A t;
-XMStoreFloat4A(&t, V);
-
-pDestination->x = XMConvertFloatToHalf(t.x);
-pDestination->y = XMConvertFloatToHalf(t.y);
-pDestination->z = XMConvertFloatToHalf(t.z);
-pDestination->w = XMConvertFloatToHalf(t.w);
-#endif // !_XM_F16C_INTRINSICS_
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreShortN4
-(
-        XMSHORTN4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, g_XMNegativeOne.v, g_XMOne.v);
-    N = XMVectorMultiply(N, g_ShortMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<int16_t>(tmp.x);
-    pDestination->y = static_cast<int16_t>(tmp.y);
-    pDestination->z = static_cast<int16_t>(tmp.z);
-    pDestination->w = static_cast<int16_t>(tmp.w);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(-1.f));
-    vResult = vminq_f32(vResult, vdupq_n_f32(1.0f));
-    vResult = vmulq_n_f32(vResult, 32767.0f);
-    int16x4_t vInt = vmovn_s32(vcvtq_s32_f32(vResult));
-    vst1_s16(reinterpret_cast<int16_t*>(pDestination), vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-XMVECTOR vResult = _mm_max_ps(V, g_XMNegativeOne);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    vResult = _mm_mul_ps(vResult, g_ShortMax);
-    __m128i vResulti = _mm_cvtps_epi32(vResult);
-    vResulti = _mm_packs_epi32(vResulti, vResulti);
-    _mm_store_sd(reinterpret_cast<double*>(&pDestination->x), _mm_castsi128_pd(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreShort4
-(
-        XMSHORT4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, g_ShortMin, g_ShortMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<int16_t>(tmp.x);
-    pDestination->y = static_cast<int16_t>(tmp.y);
-    pDestination->z = static_cast<int16_t>(tmp.z);
-    pDestination->w = static_cast<int16_t>(tmp.w);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t vResult = vmaxq_f32(V, g_ShortMin);
-    vResult = vminq_f32(vResult, g_ShortMax);
-    int16x4_t vInt = vmovn_s32(vcvtq_s32_f32(vResult));
-    vst1_s16(reinterpret_cast<int16_t*>(pDestination), vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Bounds check
-    XMVECTOR vResult = _mm_max_ps(V, g_ShortMin);
-    vResult = _mm_min_ps(vResult, g_ShortMax);
-    // Convert to int with rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // Pack the ints into shorts
-    vInt = _mm_packs_epi32(vInt, vInt);
-    _mm_store_sd(reinterpret_cast<double*>(&pDestination->x), _mm_castsi128_pd(vInt));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUShortN4
-(
-        XMUSHORTN4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorSaturate(V);
-    N = XMVectorMultiplyAdd(N, g_UShortMax, g_XMOneHalf.v);
-    N = XMVectorTruncate(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<uint16_t>(tmp.x);
-    pDestination->y = static_cast<uint16_t>(tmp.y);
-    pDestination->z = static_cast<uint16_t>(tmp.z);
-    pDestination->w = static_cast<uint16_t>(tmp.w);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(0));
-    vResult = vminq_f32(vResult, vdupq_n_f32(1.0f));
-    vResult = vmulq_n_f32(vResult, 65535.0f);
-    vResult = vaddq_f32(vResult, g_XMOneHalf);
-    uint16x4_t vInt = vmovn_u32(vcvtq_u32_f32(vResult));
-    vst1_u16(reinterpret_cast<uint16_t*>(pDestination), vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Bounds check
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    vResult = _mm_mul_ps(vResult, g_UShortMax);
-    vResult = _mm_add_ps(vResult, g_XMOneHalf);
-    // Convert to int
-    __m128i vInt = _mm_cvttps_epi32(vResult);
-    // Since the SSE pack instruction clamps using signed rules,
-    // manually extract the values to store them to memory
-    pDestination->x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    pDestination->y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-    pDestination->z = static_cast<uint16_t>(_mm_extract_epi16(vInt, 4));
-    pDestination->w = static_cast<uint16_t>(_mm_extract_epi16(vInt, 6));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUShort4
-(
-        XMUSHORT4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, XMVectorZero(), g_UShortMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<uint16_t>(tmp.x);
-    pDestination->y = static_cast<uint16_t>(tmp.y);
-    pDestination->z = static_cast<uint16_t>(tmp.z);
-    pDestination->w = static_cast<uint16_t>(tmp.w);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(0));
-    vResult = vminq_f32(vResult, g_UShortMax);
-    uint16x4_t vInt = vmovn_u32(vcvtq_u32_f32(vResult));
-    vst1_u16(reinterpret_cast<uint16_t*>(pDestination), vInt);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Bounds check
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_UShortMax);
-    // Convert to int with rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // Since the SSE pack instruction clamps using signed rules,
-    // manually extract the values to store them to memory
-    pDestination->x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    pDestination->y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-    pDestination->z = static_cast<uint16_t>(_mm_extract_epi16(vInt, 4));
-    pDestination->w = static_cast<uint16_t>(_mm_extract_epi16(vInt, 6));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreXDecN4
-(
-        XMXDECN4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-static const XMVECTORF32 Min = { { { -1.0f, -1.0f, -1.0f, 0.0f } } };
-
-#if defined(_XM_NO_INTRINSICS_)
-
-static const XMVECTORF32  Scale = { { { 511.0f, 511.0f, 511.0f, 3.0f } } };
-
-    XMVECTOR N = XMVectorClamp(V, Min.v, g_XMOne.v);
-    N = XMVectorMultiply(N, Scale.v);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint32_t>(
-        (static_cast<int>(tmp.w) << 30)
-        | ((static_cast<int>(tmp.z) & 0x3FF) << 20)
-        | ((static_cast<int>(tmp.y) & 0x3FF) << 10)
-        | (static_cast<int>(tmp.x) & 0x3FF));
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 Scale = { { { 511.0f, 511.0f * 1024.0f, 511.0f * 1048576.0f, 3.0f * 536870912.0f } } };
-    static const XMVECTORI32 ScaleMask = { { { 0x3FF, 0x3FF << 10, 0x3FF << 20, 0x3 << 29 } } };
-    float32x4_t vResult = vmaxq_f32(V, Min);
-    vResult = vminq_f32(vResult, vdupq_n_f32(1.0f));
-    vResult = vmulq_f32(vResult, Scale);
-    int32x4_t vResulti = vcvtq_s32_f32(vResult);
-    vResulti = vandq_s32(vResulti, ScaleMask);
-    int32x4_t vResultw = vandq_s32(vResulti, g_XMMaskW);
-    vResulti = vaddq_s32(vResulti, vResultw);
-    // Do a horizontal or of all 4 entries
-    uint32x2_t vTemp = vget_low_u32(vreinterpretq_u32_s32(vResulti));
-    uint32x2_t vhi = vget_high_u32(vreinterpretq_u32_s32(vResulti));
-    vTemp = vorr_u32(vTemp, vhi);
-    vTemp = vpadd_u32(vTemp, vTemp);
-    vst1_lane_u32(&pDestination->v, vTemp, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 Scale = { { { 511.0f, 511.0f * 1024.0f, 511.0f * 1048576.0f, 3.0f * 536870912.0f } } };
-    static const XMVECTORI32 ScaleMask = { { { 0x3FF, 0x3FF << 10, 0x3FF << 20, 0x3 << 29 } } };
-    XMVECTOR vResult = _mm_max_ps(V, Min);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, Scale);
-    // Convert to int (W is unsigned)
-    __m128i vResulti = _mm_cvtps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, ScaleMask);
-    // To fix W, add itself to shift it up to <<30 instead of <<29
-    __m128i vResultw = _mm_and_si128(vResulti, g_XMMaskW);
-    vResulti = _mm_add_epi32(vResulti, vResultw);
-    // Do a horizontal or of all 4 entries
-    vResult = XM_PERMUTE_PS(_mm_castsi128_ps(vResulti), _MM_SHUFFLE(0, 3, 2, 1));
-    vResulti = _mm_or_si128(vResulti, _mm_castps_si128(vResult));
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(0, 3, 2, 1));
-    vResulti = _mm_or_si128(vResulti, _mm_castps_si128(vResult));
-    vResult = XM_PERMUTE_PS(vResult, _MM_SHUFFLE(0, 3, 2, 1));
-    vResulti = _mm_or_si128(vResulti, _mm_castps_si128(vResult));
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996)
-// C4996: ignore deprecation warning
-#endif
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreXDec4
-(
-        XMXDEC4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-static const XMVECTORF32 MinXDec4 = { { { -511.0f, -511.0f, -511.0f, 0.0f } } };
-static const XMVECTORF32 MaxXDec4 = { { { 511.0f, 511.0f, 511.0f, 3.0f } } };
-
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, MinXDec4, MaxXDec4);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint32_t>(
-        (static_cast<int>(tmp.w) << 30)
-        | ((static_cast<int>(tmp.z) & 0x3FF) << 20)
-        | ((static_cast<int>(tmp.y) & 0x3FF) << 10)
-        | ((static_cast<int>(tmp.x) & 0x3FF)));
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 ScaleXDec4 = { { { 1.0f, 1024.0f / 2.0f, 1024.0f * 1024.0f, 1024.0f * 1024.0f * 1024.0f / 2.0f } } };
-    static const XMVECTORI32 MaskXDec4 = { { { 0x3FF, 0x3FF << (10 - 1), 0x3FF << 20, 0x3 << (30 - 1) } } };
-    float32x4_t vResult = vmaxq_f32(V, MinXDec4);
-    vResult = vminq_f32(vResult, MaxXDec4);
-    vResult = vmulq_f32(vResult, ScaleXDec4);
-    int32x4_t vResulti = vcvtq_s32_f32(vResult);
-    vResulti = vandq_s32(vResulti, MaskXDec4);
-    // Do a horizontal or of 4 entries
-    uint32x2_t vTemp = vget_low_u32(vreinterpretq_u32_s32(vResulti));
-    uint32x2_t vTemp2 = vget_high_u32(vreinterpretq_u32_s32(vResulti));
-    vTemp = vorr_u32(vTemp, vTemp2);
-    // Perform a single bit left shift on y|w
-    vTemp2 = vdup_lane_u32(vTemp, 1);
-    vTemp2 = vadd_u32(vTemp2, vTemp2);
-    vTemp = vorr_u32(vTemp, vTemp2);
-    vst1_lane_u32(&pDestination->v, vTemp, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 ScaleXDec4 = { { { 1.0f, 1024.0f / 2.0f, 1024.0f * 1024.0f, 1024.0f * 1024.0f * 1024.0f / 2.0f } } };
-    static const XMVECTORI32 MaskXDec4 = { { { 0x3FF, 0x3FF << (10 - 1), 0x3FF << 20, 0x3 << (30 - 1) } } };
-    // Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, MinXDec4);
-    vResult = _mm_min_ps(vResult, MaxXDec4);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, ScaleXDec4);
-    // Convert to int
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, MaskXDec4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // Perform a single bit left shift on y|w
-    vResulti2 = _mm_add_epi32(vResulti2, vResulti2);
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUDecN4
-(
-        XMUDECN4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-static const XMVECTORF32  Scale = { { { 1023.0f, 1023.0f, 1023.0f, 3.0f } } };
-
-    XMVECTOR N = XMVectorSaturate(V);
-    N = XMVectorMultiply(N, Scale.v);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint32_t>(
-        (static_cast<int>(tmp.w) << 30)
-        | ((static_cast<int>(tmp.z) & 0x3FF) << 20)
-        | ((static_cast<int>(tmp.y) & 0x3FF) << 10)
-        | ((static_cast<int>(tmp.x) & 0x3FF)));
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 ScaleUDecN4 = { { { 1023.0f, 1023.0f * 1024.0f * 0.5f, 1023.0f * 1024.0f * 1024.0f, 3.0f * 1024.0f * 1024.0f * 1024.0f * 0.5f } } };
-    static const XMVECTORI32 MaskUDecN4 = { { { 0x3FF, 0x3FF << (10 - 1), 0x3FF << 20, 0x3 << (30 - 1) } } };
-    float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(0.f));
-    vResult = vminq_f32(vResult, vdupq_n_f32(1.f));
-    vResult = vmulq_f32(vResult, ScaleUDecN4);
-    uint32x4_t vResulti = vcvtq_u32_f32(vResult);
-    vResulti = vandq_u32(vResulti, MaskUDecN4);
-    // Do a horizontal or of 4 entries
-    uint32x2_t vTemp = vget_low_u32(vResulti);
-    uint32x2_t vTemp2 = vget_high_u32(vResulti);
-    vTemp = vorr_u32(vTemp, vTemp2);
-    // Perform a single bit left shift on y|w
-    vTemp2 = vdup_lane_u32(vTemp, 1);
-    vTemp2 = vadd_u32(vTemp2, vTemp2);
-    vTemp = vorr_u32(vTemp, vTemp2);
-    vst1_lane_u32(&pDestination->v, vTemp, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 ScaleUDecN4 = { { { 1023.0f, 1023.0f * 1024.0f * 0.5f, 1023.0f * 1024.0f * 1024.0f, 3.0f * 1024.0f * 1024.0f * 1024.0f * 0.5f } } };
-    static const XMVECTORI32 MaskUDecN4 = { { { 0x3FF, 0x3FF << (10 - 1), 0x3FF << 20, 0x3 << (30 - 1) } } };
-    // Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, ScaleUDecN4);
-    // Convert to int
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, MaskUDecN4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // Perform a left shift by one bit on y|w
-    vResulti2 = _mm_add_epi32(vResulti2, vResulti2);
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUDecN4_XR
-(
-        XMUDECN4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-static const XMVECTORF32 Scale = { { { 510.0f, 510.0f, 510.0f, 3.0f } } };
-static const XMVECTORF32 Bias = { { { 384.0f, 384.0f, 384.0f, 0.0f } } };
-static const XMVECTORF32 C = { { { 1023.f, 1023.f, 1023.f, 3.f } } };
-
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorMultiplyAdd(V, Scale, Bias);
-    N = XMVectorClamp(N, g_XMZero, C);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint32_t>(
-        (static_cast<int>(tmp.w) << 30)
-        | ((static_cast<int>(tmp.z) & 0x3FF) << 20)
-        | ((static_cast<int>(tmp.y) & 0x3FF) << 10)
-        | ((static_cast<int>(tmp.x) & 0x3FF)));
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 Shift = { { { 1.0f, 1024.0f * 0.5f, 1024.0f * 1024.0f, 1024.0f * 1024.0f * 1024.0f * 0.5f } } };
-    static const XMVECTORU32 MaskUDecN4 = { { { 0x3FF, 0x3FF << (10 - 1), 0x3FF << 20, 0x3 << (30 - 1) } } };
-    float32x4_t vResult = vmlaq_f32(Bias, V, Scale);
-    vResult = vmaxq_f32(vResult, vdupq_n_f32(0.f));
-    vResult = vminq_f32(vResult, C);
-    vResult = vmulq_f32(vResult, Shift);
-    uint32x4_t vResulti = vcvtq_u32_f32(vResult);
-    vResulti = vandq_u32(vResulti, MaskUDecN4);
-    // Do a horizontal or of 4 entries
-    uint32x2_t vTemp = vget_low_u32(vResulti);
-    uint32x2_t vTemp2 = vget_high_u32(vResulti);
-    vTemp = vorr_u32(vTemp, vTemp2);
-    // Perform a single bit left shift on y|w
-    vTemp2 = vdup_lane_u32(vTemp, 1);
-    vTemp2 = vadd_u32(vTemp2, vTemp2);
-    vTemp = vorr_u32(vTemp, vTemp2);
-    vst1_lane_u32(&pDestination->v, vTemp, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 Shift = { { { 1.0f, 1024.0f * 0.5f, 1024.0f * 1024.0f, 1024.0f * 1024.0f * 1024.0f * 0.5f } } };
-    static const XMVECTORU32 MaskUDecN4 = { { { 0x3FF, 0x3FF << (10 - 1), 0x3FF << 20, 0x3 << (30 - 1) } } };
-    // Scale & bias
-    XMVECTOR vResult = XM_FMADD_PS(V, Scale, Bias);
-    // Clamp to bounds
-    vResult = _mm_max_ps(vResult, g_XMZero);
-    vResult = _mm_min_ps(vResult, C);
-    // Scale by shift values
-    vResult = _mm_mul_ps(vResult, Shift);
-    // Convert to int
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, MaskUDecN4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // Perform a left shift by one bit on y|w
-    vResulti2 = _mm_add_epi32(vResulti2, vResulti2);
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUDec4
-(
-        XMUDEC4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-static const XMVECTORF32 MaxUDec4 = { { { 1023.0f, 1023.0f, 1023.0f, 3.0f } } };
-
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, XMVectorZero(), MaxUDec4);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint32_t>(
-        (static_cast<int>(tmp.w) << 30)
-        | ((static_cast<int>(tmp.z) & 0x3FF) << 20)
-        | ((static_cast<int>(tmp.y) & 0x3FF) << 10)
-        | ((static_cast<int>(tmp.x) & 0x3FF)));
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 ScaleUDec4 = { { { 1.0f, 1024.0f / 2.0f, 1024.0f * 1024.0f, 1024.0f * 1024.0f * 1024.0f / 2.0f } } };
-    static const XMVECTORI32 MaskUDec4 = { { { 0x3FF, 0x3FF << (10 - 1), 0x3FF << 20, 0x3 << (30 - 1) } } };
-    float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(0.f));
-    vResult = vminq_f32(vResult, MaxUDec4);
-    vResult = vmulq_f32(vResult, ScaleUDec4);
-    uint32x4_t vResulti = vcvtq_u32_f32(vResult);
-    vResulti = vandq_u32(vResulti, MaskUDec4);
-    // Do a horizontal or of 4 entries
-    uint32x2_t vTemp = vget_low_u32(vResulti);
-    uint32x2_t vTemp2 = vget_high_u32(vResulti);
-    vTemp = vorr_u32(vTemp, vTemp2);
-    // Perform a single bit left shift on y|w
-    vTemp2 = vdup_lane_u32(vTemp, 1);
-    vTemp2 = vadd_u32(vTemp2, vTemp2);
-    vTemp = vorr_u32(vTemp, vTemp2);
-    vst1_lane_u32(&pDestination->v, vTemp, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 ScaleUDec4 = { { { 1.0f, 1024.0f / 2.0f, 1024.0f * 1024.0f, 1024.0f * 1024.0f * 1024.0f / 2.0f } } };
-    static const XMVECTORI32 MaskUDec4 = { { { 0x3FF, 0x3FF << (10 - 1), 0x3FF << 20, 0x3 << (30 - 1) } } };
-    // Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, MaxUDec4);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, ScaleUDec4);
-    // Convert to int
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, MaskUDec4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // Perform a left shift by one bit on y|w
-    vResulti2 = _mm_add_epi32(vResulti2, vResulti2);
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996)
-// C4996: ignore deprecation warning
-#endif
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreDecN4
-(
-        XMDECN4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-static const XMVECTORF32 Scale = { { { 511.0f, 511.0f, 511.0f, 1.0f } } };
-
-    XMVECTOR N = XMVectorClamp(V, g_XMNegativeOne.v, g_XMOne.v);
-    N = XMVectorMultiply(N, Scale.v);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint32_t>(
-        (static_cast<int>(tmp.w) << 30)
-        | ((static_cast<int>(tmp.z) & 0x3FF) << 20)
-        | ((static_cast<int>(tmp.y) & 0x3FF) << 10)
-        | ((static_cast<int>(tmp.x) & 0x3FF)));
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 ScaleDecN4 = { { { 511.0f, 511.0f * 1024.0f, 511.0f * 1024.0f * 1024.0f, 1.0f * 1024.0f * 1024.0f * 1024.0f } } };
-    float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(-1.f));
-    vResult = vminq_f32(vResult, vdupq_n_f32(1.f));
-    vResult = vmulq_f32(vResult, ScaleDecN4);
-    int32x4_t vResulti = vcvtq_s32_f32(vResult);
-    vResulti = vandq_s32(vResulti, g_XMMaskDec4);
-    // Do a horizontal or of 4 entries
-    uint32x2_t vTemp = vget_low_u32(vreinterpretq_u32_s32(vResulti));
-    uint32x2_t vhi = vget_high_u32(vreinterpretq_u32_s32(vResulti));
-    vTemp = vorr_u32(vTemp, vhi);
-    vTemp = vpadd_u32(vTemp, vTemp);
-    vst1_lane_u32(&pDestination->v, vTemp, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 ScaleDecN4 = { { { 511.0f, 511.0f * 1024.0f, 511.0f * 1024.0f * 1024.0f, 1.0f * 1024.0f * 1024.0f * 1024.0f } } };
-    // Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_XMNegativeOne);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, ScaleDecN4);
-    // Convert to int
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, g_XMMaskDec4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreDec4
-(
-        XMDEC4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-static const XMVECTORF32 MinDec4 = { { { -511.0f, -511.0f, -511.0f, -1.0f } } };
-static const XMVECTORF32 MaxDec4 = { { { 511.0f, 511.0f, 511.0f, 1.0f } } };
-
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, MinDec4, MaxDec4);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint32_t>(
-        (static_cast<int>(tmp.w) << 30)
-        | ((static_cast<int>(tmp.z) & 0x3FF) << 20)
-        | ((static_cast<int>(tmp.y) & 0x3FF) << 10)
-        | ((static_cast<int>(tmp.x) & 0x3FF)));
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 ScaleDec4 = { { { 1.0f, 1024.0f, 1024.0f * 1024.0f, 1024.0f * 1024.0f * 1024.0f } } };
-    float32x4_t vResult = vmaxq_f32(V, MinDec4);
-    vResult = vminq_f32(vResult, MaxDec4);
-    vResult = vmulq_f32(vResult, ScaleDec4);
-    int32x4_t vResulti = vcvtq_s32_f32(vResult);
-    vResulti = vandq_s32(vResulti, g_XMMaskDec4);
-    // Do a horizontal or of all 4 entries
-    uint32x2_t vTemp = vget_low_u32(vreinterpretq_u32_s32(vResulti));
-    uint32x2_t vhi = vget_high_u32(vreinterpretq_u32_s32(vResulti));
-    vTemp = vorr_u32(vTemp, vhi);
-    vTemp = vpadd_u32(vTemp, vTemp);
-    vst1_lane_u32(&pDestination->v, vTemp, 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 ScaleDec4 = { { { 1.0f, 1024.0f, 1024.0f * 1024.0f, 1024.0f * 1024.0f * 1024.0f } } };
-    // Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, MinDec4);
-    vResult = _mm_min_ps(vResult, MaxDec4);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, ScaleDec4);
-    // Convert to int
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, g_XMMaskDec4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUByteN4
-(
-        XMUBYTEN4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorSaturate(V);
-    N = XMVectorMultiply(N, g_UByteMax);
-    N = XMVectorTruncate(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<uint8_t>(tmp.x);
-    pDestination->y = static_cast<uint8_t>(tmp.y);
-    pDestination->z = static_cast<uint8_t>(tmp.z);
-    pDestination->w = static_cast<uint8_t>(tmp.w);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(0));
-    R = vminq_f32(R, vdupq_n_f32(1.0f));
-    R = vmulq_n_f32(R, 255.0f);
-    uint32x4_t vInt32 = vcvtq_u32_f32(R);
-    uint16x4_t vInt16 = vqmovn_u32(vInt32);
-    uint8x8_t vInt8 = vqmovn_u16(vcombine_u16(vInt16, vInt16));
-    vst1_lane_u32(&pDestination->v, vreinterpret_u32_u8(vInt8), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 ScaleUByteN4 = { { { 255.0f, 255.0f * 256.0f * 0.5f, 255.0f * 256.0f * 256.0f, 255.0f * 256.0f * 256.0f * 256.0f * 0.5f } } };
-    static const XMVECTORI32 MaskUByteN4 = { { { 0xFF, 0xFF << (8 - 1), 0xFF << 16, 0xFF << (24 - 1) } } };
-    // Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, ScaleUByteN4);
-    // Convert to int
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, MaskUByteN4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // Perform a single bit left shift to fix y|w
-    vResulti2 = _mm_add_epi32(vResulti2, vResulti2);
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUByte4
-(
-        XMUBYTE4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, XMVectorZero(), g_UByteMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<uint8_t>(tmp.x);
-    pDestination->y = static_cast<uint8_t>(tmp.y);
-    pDestination->z = static_cast<uint8_t>(tmp.z);
-    pDestination->w = static_cast<uint8_t>(tmp.w);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(0));
-    R = vminq_f32(R, vdupq_n_f32(255.0f));
-    uint32x4_t vInt32 = vcvtq_u32_f32(R);
-    uint16x4_t vInt16 = vqmovn_u32(vInt32);
-    uint8x8_t vInt8 = vqmovn_u16(vcombine_u16(vInt16, vInt16));
-    vst1_lane_u32(&pDestination->v, vreinterpret_u32_u8(vInt8), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 ScaleUByte4 = { { { 1.0f, 256.0f * 0.5f, 256.0f * 256.0f, 256.0f * 256.0f * 256.0f * 0.5f } } };
-    static const XMVECTORI32 MaskUByte4 = { { { 0xFF, 0xFF << (8 - 1), 0xFF << 16, 0xFF << (24 - 1) } } };
-    // Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, g_UByteMax);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, ScaleUByte4);
-    // Convert to int by rounding
-    __m128i vResulti = _mm_cvtps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, MaskUByte4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // Perform a single bit left shift to fix y|w
-    vResulti2 = _mm_add_epi32(vResulti2, vResulti2);
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreByteN4
-(
-        XMBYTEN4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, g_XMNegativeOne.v, g_XMOne.v);
-    N = XMVectorMultiply(N, g_ByteMax);
-    N = XMVectorTruncate(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<int8_t>(tmp.x);
-    pDestination->y = static_cast<int8_t>(tmp.y);
-    pDestination->z = static_cast<int8_t>(tmp.z);
-    pDestination->w = static_cast<int8_t>(tmp.w);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(-1.f));
-    R = vminq_f32(R, vdupq_n_f32(1.0f));
-    R = vmulq_n_f32(R, 127.0f);
-    int32x4_t vInt32 = vcvtq_s32_f32(R);
-    int16x4_t vInt16 = vqmovn_s32(vInt32);
-    int8x8_t vInt8 = vqmovn_s16(vcombine_s16(vInt16, vInt16));
-    vst1_lane_u32(&pDestination->v, vreinterpret_u32_s8(vInt8), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 ScaleByteN4 = { { { 127.0f, 127.0f * 256.0f, 127.0f * 256.0f * 256.0f, 127.0f * 256.0f * 256.0f * 256.0f } } };
-    static const XMVECTORI32 MaskByteN4 = { { { 0xFF, 0xFF << 8, 0xFF << 16, static_cast<int>(0xFF000000) } } };
-    // Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_XMNegativeOne);
-    vResult = _mm_min_ps(vResult, g_XMOne);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, ScaleByteN4);
-    // Convert to int
-    __m128i vResulti = _mm_cvttps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, MaskByteN4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreByte4
-(
-        XMBYTE4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, g_ByteMin, g_ByteMax);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->x = static_cast<int8_t>(tmp.x);
-    pDestination->y = static_cast<int8_t>(tmp.y);
-    pDestination->z = static_cast<int8_t>(tmp.z);
-    pDestination->w = static_cast<int8_t>(tmp.w);
-
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-float32x4_t R = vmaxq_f32(V, vdupq_n_f32(-127.f));
-    R = vminq_f32(R, vdupq_n_f32(127.f));
-    int32x4_t vInt32 = vcvtq_s32_f32(R);
-    int16x4_t vInt16 = vqmovn_s32(vInt32);
-    int8x8_t vInt8 = vqmovn_s16(vcombine_s16(vInt16, vInt16));
-    vst1_lane_u32(&pDestination->v, vreinterpret_u32_s8(vInt8), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-static const XMVECTORF32 ScaleByte4 = { { { 1.0f, 256.0f, 256.0f * 256.0f, 256.0f * 256.0f * 256.0f } } };
-    static const XMVECTORI32 MaskByte4 = { { { 0xFF, 0xFF << 8, 0xFF << 16, static_cast<int>(0xFF000000) } } };
-    // Clamp to bounds
-    XMVECTOR vResult = _mm_max_ps(V, g_ByteMin);
-    vResult = _mm_min_ps(vResult, g_ByteMax);
-    // Scale by multiplication
-    vResult = _mm_mul_ps(vResult, ScaleByte4);
-    // Convert to int by rounding
-    __m128i vResulti = _mm_cvtps_epi32(vResult);
-    // Mask off any fraction
-    vResulti = _mm_and_si128(vResulti, MaskByte4);
-    // Do a horizontal or of 4 entries
-    __m128i vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(3, 2, 3, 2));
-    // x = x|z, y = y|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    // Move Z to the x position
-    vResulti2 = _mm_shuffle_epi32(vResulti, _MM_SHUFFLE(1, 1, 1, 1));
-    // i = x|y|z|w
-    vResulti = _mm_or_si128(vResulti, vResulti2);
-    _mm_store_ss(reinterpret_cast<float*>(&pDestination->v), _mm_castsi128_ps(vResulti));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreUNibble4
-(
-        XMUNIBBLE4* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-static const XMVECTORF32 Max = { { { 15.0f, 15.0f, 15.0f, 15.0f } } };
-#if defined(_XM_NO_INTRINSICS_)
-
-XMVECTOR N = XMVectorClamp(V, XMVectorZero(), Max.v);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint16_t>(
-        ((static_cast<int>(tmp.w) & 0xF) << 12)
-        | ((static_cast<int>(tmp.z) & 0xF) << 8)
-        | ((static_cast<int>(tmp.y) & 0xF) << 4)
-        | (static_cast<int>(tmp.x) & 0xF));
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 Scale = { { { 1.0f, 16.f, 16.f * 16.f, 16.f * 16.f * 16.f } } };
-    static const XMVECTORU32 Mask = { { { 0xF, 0xF << 4, 0xF << 8, 0xF << 12 } } };
-    float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(0));
-    vResult = vminq_f32(vResult, Max);
-    vResult = vmulq_f32(vResult, Scale);
-    uint32x4_t vResulti = vcvtq_u32_f32(vResult);
-    vResulti = vandq_u32(vResulti, Mask);
-    // Do a horizontal or of 4 entries
-    uint32x2_t vTemp = vget_low_u32(vResulti);
-    uint32x2_t vhi = vget_high_u32(vResulti);
-    vTemp = vorr_u32(vTemp, vhi);
-    vTemp = vpadd_u32(vTemp, vTemp);
-    vst1_lane_u16(&pDestination->v, vreinterpret_u16_u32(vTemp), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Bounds check
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, Max);
-    // Convert to int with rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // No SSE operations will write to 16-bit values, so we have to extract them manually
-    auto x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    auto y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-    auto z = static_cast<uint16_t>(_mm_extract_epi16(vInt, 4));
-    auto w = static_cast<uint16_t>(_mm_extract_epi16(vInt, 6));
-    pDestination->v = static_cast<uint16_t>(
-        ((static_cast<int>(w) & 0xF) << 12)
-        | ((static_cast<int>(z) & 0xF) << 8)
-        | ((static_cast<int>(y) & 0xF) << 4)
-        | ((static_cast<int>(x) & 0xF)));
-#endif
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline void XM_CALLCONV XMStoreU555
-(
-        XMU555* pDestination,
-FXMVECTOR V
-) noexcept
-{
-assert(pDestination);
-static const XMVECTORF32 Max = { { { 31.0f, 31.0f, 31.0f, 1.0f } } };
-
-#if defined(_XM_NO_INTRINSICS_)
-XMVECTOR N = XMVectorClamp(V, XMVectorZero(), Max.v);
-    N = XMVectorRound(N);
-
-    XMFLOAT4A tmp;
-    XMStoreFloat4A(&tmp, N);
-
-    pDestination->v = static_cast<uint16_t>(
-        ((tmp.w > 0.f) ? 0x8000 : 0)
-        | ((static_cast<int>(tmp.z) & 0x1F) << 10)
-        | ((static_cast<int>(tmp.y) & 0x1F) << 5)
-        | (static_cast<int>(tmp.x) & 0x1F));
-#elif defined(_XM_ARM_NEON_INTRINSICS_)
-static const XMVECTORF32 Scale = { { { 1.0f, 32.f / 2.f, 32.f * 32.f, 32.f * 32.f * 32.f / 2.f } } };
-    static const XMVECTORU32 Mask = { { { 0x1F, 0x1F << (5 - 1), 0x1F << 10, 0x1 << (15 - 1) } } };
-    float32x4_t vResult = vmaxq_f32(V, vdupq_n_f32(0));
-    vResult = vminq_f32(vResult, Max);
-    vResult = vmulq_f32(vResult, Scale);
-    uint32x4_t vResulti = vcvtq_u32_f32(vResult);
-    vResulti = vandq_u32(vResulti, Mask);
-    // Do a horizontal or of 4 entries
-    uint32x2_t vTemp = vget_low_u32(vResulti);
-    uint32x2_t vTemp2 = vget_high_u32(vResulti);
-    vTemp = vorr_u32(vTemp, vTemp2);
-    // Perform a single bit left shift on y|w
-    vTemp2 = vdup_lane_u32(vTemp, 1);
-    vTemp2 = vadd_u32(vTemp2, vTemp2);
-    vTemp = vorr_u32(vTemp, vTemp2);
-    vst1_lane_u16(&pDestination->v, vreinterpret_u16_u32(vTemp), 0);
-#elif defined(_XM_SSE_INTRINSICS_)
-// Bounds check
-    XMVECTOR vResult = _mm_max_ps(V, g_XMZero);
-    vResult = _mm_min_ps(vResult, Max);
-    // Convert to int with rounding
-    __m128i vInt = _mm_cvtps_epi32(vResult);
-    // No SSE operations will write to 16-bit values, so we have to extract them manually
-    auto x = static_cast<uint16_t>(_mm_extract_epi16(vInt, 0));
-    auto y = static_cast<uint16_t>(_mm_extract_epi16(vInt, 2));
-    auto z = static_cast<uint16_t>(_mm_extract_epi16(vInt, 4));
-    auto w = static_cast<uint16_t>(_mm_extract_epi16(vInt, 6));
-    pDestination->v = static_cast<uint16_t>(
-        (static_cast<int>(w) ? 0x8000 : 0)
-        | ((static_cast<int>(z) & 0x1F) << 10)
-        | ((static_cast<int>(y) & 0x1F) << 5)
-        | ((static_cast<int>(x) & 0x1F)));
-#endif
-}
-
-
-/****************************************************************************
- *
- * XMCOLOR operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMCOLOR::XMCOLOR
-        (
-                float _r,
-                float _g,
-                float _b,
-                float _a
-        ) noexcept
-{
-    XMStoreColor(this, XMVectorSet(_r, _g, _b, _a));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMCOLOR::XMCOLOR(const float* pArray) noexcept
-{
-    XMStoreColor(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMHALF2 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMHALF2::XMHALF2
-        (
-                float _x,
-                float _y
-        ) noexcept
-{
-    x = XMConvertFloatToHalf(_x);
-    y = XMConvertFloatToHalf(_y);
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMHALF2::XMHALF2(const float* pArray) noexcept
-{
-    assert(pArray != nullptr);
-    x = XMConvertFloatToHalf(pArray[0]);
-    y = XMConvertFloatToHalf(pArray[1]);
-}
-
-/****************************************************************************
- *
- * XMSHORTN2 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMSHORTN2::XMSHORTN2
-        (
-                float _x,
-                float _y
-        ) noexcept
-{
-    XMStoreShortN2(this, XMVectorSet(_x, _y, 0.0f, 0.0f));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMSHORTN2::XMSHORTN2(const float* pArray) noexcept
-{
-    XMStoreShortN2(this, XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMSHORT2 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMSHORT2::XMSHORT2
-        (
-                float _x,
-                float _y
-        ) noexcept
-{
-    XMStoreShort2(this, XMVectorSet(_x, _y, 0.0f, 0.0f));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMSHORT2::XMSHORT2(const float* pArray) noexcept
-{
-    XMStoreShort2(this, XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUSHORTN2 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUSHORTN2::XMUSHORTN2
-        (
-                float _x,
-                float _y
-        ) noexcept
-{
-    XMStoreUShortN2(this, XMVectorSet(_x, _y, 0.0f, 0.0f));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUSHORTN2::XMUSHORTN2(const float* pArray) noexcept
-{
-    XMStoreUShortN2(this, XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUSHORT2 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUSHORT2::XMUSHORT2
-        (
-                float _x,
-                float _y
-        ) noexcept
-{
-    XMStoreUShort2(this, XMVectorSet(_x, _y, 0.0f, 0.0f));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUSHORT2::XMUSHORT2(const float* pArray) noexcept
-{
-    XMStoreUShort2(this, XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMBYTEN2 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMBYTEN2::XMBYTEN2
-        (
-                float _x,
-                float _y
-        ) noexcept
-{
-    XMStoreByteN2(this, XMVectorSet(_x, _y, 0.0f, 0.0f));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMBYTEN2::XMBYTEN2(const float* pArray) noexcept
-{
-    XMStoreByteN2(this, XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMBYTE2 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMBYTE2::XMBYTE2
-        (
-                float _x,
-                float _y
-        ) noexcept
-{
-    XMStoreByte2(this, XMVectorSet(_x, _y, 0.0f, 0.0f));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMBYTE2::XMBYTE2(const float* pArray) noexcept
-{
-    XMStoreByte2(this, XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUBYTEN2 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUBYTEN2::XMUBYTEN2
-        (
-                float _x,
-                float _y
-        ) noexcept
-{
-    XMStoreUByteN2(this, XMVectorSet(_x, _y, 0.0f, 0.0f));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUBYTEN2::XMUBYTEN2(const float* pArray) noexcept
-{
-    XMStoreUByteN2(this, XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUBYTE2 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUBYTE2::XMUBYTE2
-        (
-                float _x,
-                float _y
-        ) noexcept
-{
-    XMStoreUByte2(this, XMVectorSet(_x, _y, 0.0f, 0.0f));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUBYTE2::XMUBYTE2(const float* pArray) noexcept
-{
-    XMStoreUByte2(this, XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMU565 operators
- *
- ****************************************************************************/
-
-inline XMU565::XMU565
-        (
-                float _x,
-                float _y,
-                float _z
-        ) noexcept
-{
-    XMStoreU565(this, XMVectorSet(_x, _y, _z, 0.0f));
-}
-
-_Use_decl_annotations_
-inline XMU565::XMU565(const float* pArray) noexcept
-{
-    XMStoreU565(this, XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMFLOAT3PK operators
- *
- ****************************************************************************/
-
-inline XMFLOAT3PK::XMFLOAT3PK
-        (
-                float _x,
-                float _y,
-                float _z
-        ) noexcept
-{
-    XMStoreFloat3PK(this, XMVectorSet(_x, _y, _z, 0.0f));
-}
-
-_Use_decl_annotations_
-inline XMFLOAT3PK::XMFLOAT3PK(const float* pArray) noexcept
-{
-    XMStoreFloat3PK(this, XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMFLOAT3SE operators
- *
- ****************************************************************************/
-
-inline XMFLOAT3SE::XMFLOAT3SE
-        (
-                float _x,
-                float _y,
-                float _z
-        ) noexcept
-{
-    XMStoreFloat3SE(this, XMVectorSet(_x, _y, _z, 0.0f));
-}
-
-_Use_decl_annotations_
-inline XMFLOAT3SE::XMFLOAT3SE(const float* pArray) noexcept
-{
-    XMStoreFloat3SE(this, XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMHALF4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMHALF4::XMHALF4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    x = XMConvertFloatToHalf(_x);
-    y = XMConvertFloatToHalf(_y);
-    z = XMConvertFloatToHalf(_z);
-    w = XMConvertFloatToHalf(_w);
-}
-
-//------------------------------------------------------------------------------
-
-_Use_decl_annotations_
-inline XMHALF4::XMHALF4(const float* pArray) noexcept
-{
-    XMConvertFloatToHalfStream(&x, sizeof(HALF), pArray, sizeof(float), 4);
-}
-
-/****************************************************************************
- *
- * XMSHORTN4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMSHORTN4::XMSHORTN4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreShortN4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMSHORTN4::XMSHORTN4(const float* pArray) noexcept
-{
-    XMStoreShortN4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMSHORT4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMSHORT4::XMSHORT4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreShort4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMSHORT4::XMSHORT4(const float* pArray) noexcept
-{
-    XMStoreShort4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUSHORTN4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUSHORTN4::XMUSHORTN4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreUShortN4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUSHORTN4::XMUSHORTN4(const float* pArray) noexcept
-{
-    XMStoreUShortN4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUSHORT4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUSHORT4::XMUSHORT4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreUShort4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUSHORT4::XMUSHORT4(const float* pArray) noexcept
-{
-    XMStoreUShort4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMXDECN4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMXDECN4::XMXDECN4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreXDecN4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMXDECN4::XMXDECN4(const float* pArray) noexcept
-{
-    XMStoreXDecN4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMXDEC4 operators
- *
- ****************************************************************************/
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996)
- // C4996: ignore deprecation warning
-#endif
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-//------------------------------------------------------------------------------
-
-inline XMXDEC4::XMXDEC4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreXDec4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMXDEC4::XMXDEC4(const float* pArray) noexcept
-{
-    XMStoreXDec4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMDECN4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMDECN4::XMDECN4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreDecN4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMDECN4::XMDECN4(const float* pArray) noexcept
-{
-    XMStoreDecN4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMDEC4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMDEC4::XMDEC4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreDec4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMDEC4::XMDEC4(const float* pArray) noexcept
-{
-    XMStoreDec4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-/****************************************************************************
- *
- * XMUDECN4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUDECN4::XMUDECN4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreUDecN4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUDECN4::XMUDECN4(const float* pArray) noexcept
-{
-    XMStoreUDecN4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUDEC4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUDEC4::XMUDEC4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreUDec4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUDEC4::XMUDEC4(const float* pArray) noexcept
-{
-    XMStoreUDec4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMBYTEN4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMBYTEN4::XMBYTEN4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreByteN4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMBYTEN4::XMBYTEN4(const float* pArray) noexcept
-{
-    XMStoreByteN4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMBYTE4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMBYTE4::XMBYTE4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreByte4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMBYTE4::XMBYTE4(const float* pArray) noexcept
-{
-    XMStoreByte4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUBYTEN4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUBYTEN4::XMUBYTEN4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreUByteN4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUBYTEN4::XMUBYTEN4(const float* pArray) noexcept
-{
-    XMStoreUByteN4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUBYTE4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUBYTE4::XMUBYTE4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreUByte4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUBYTE4::XMUBYTE4(const float* pArray) noexcept
-{
-    XMStoreUByte4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMUNIBBLE4 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMUNIBBLE4::XMUNIBBLE4
-        (
-                float _x,
-                float _y,
-                float _z,
-                float _w
-        ) noexcept
-{
-    XMStoreUNibble4(this, XMVectorSet(_x, _y, _z, _w));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMUNIBBLE4::XMUNIBBLE4(const float* pArray) noexcept
-{
-    XMStoreUNibble4(this, XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray)));
-}
-
-/****************************************************************************
- *
- * XMU555 operators
- *
- ****************************************************************************/
-
-//------------------------------------------------------------------------------
-
-inline XMU555::XMU555
-        (
-                float _x,
-                float _y,
-                float _z,
-                bool _w
-        ) noexcept
-{
-    XMStoreU555(this, XMVectorSet(_x, _y, _z, ((_w) ? 1.0f : 0.0f)));
-}
-
-//------------------------------------------------------------------------------
-_Use_decl_annotations_
-inline XMU555::XMU555
-        (
-                const float* pArray,
-                bool _w
-        ) noexcept
-{
-    XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pArray));
-    XMStoreU555(this, XMVectorSetW(V, ((_w) ? 1.0f : 0.0f)));
-}
-
diff --git a/thirdparty/directxtex/BC.cpp b/thirdparty/directxtex/BC.cpp
deleted file mode 100644
index e730550..0000000
--- a/thirdparty/directxtex/BC.cpp
+++ /dev/null
@@ -1,1141 +0,0 @@
-//-------------------------------------------------------------------------------------
-// BC.cpp
-//
-// Block-compression (BC) functionality for BC1, BC2, BC3 (orginal DXTn formats)
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-// Experiemental encoding variants, not enabled by default
-//#define COLOR_WEIGHTS
-//#define COLOR_AVG_0WEIGHTS
-
-#include "BC.h"
-
-using namespace DirectX;
-using namespace DirectX::PackedVector;
-
-namespace
-{
-    //-------------------------------------------------------------------------------------
-    // Constants
-    //-------------------------------------------------------------------------------------
-
-    // Perceptual weightings for the importance of each channel.
-    const HDRColorA g_Luminance(0.2125f / 0.7154f, 1.0f, 0.0721f / 0.7154f, 1.0f);
-    const HDRColorA g_LuminanceInv(0.7154f / 0.2125f, 1.0f, 0.7154f / 0.0721f, 1.0f);
-
-    //-------------------------------------------------------------------------------------
-    // Decode/Encode RGB 5/6/5 colors
-    //-------------------------------------------------------------------------------------
-    inline void Decode565(_Out_ HDRColorA *pColor, _In_ const uint16_t w565) noexcept
-    {
-        pColor->r = static_cast<float>((w565 >> 11) & 31) * (1.0f / 31.0f);
-        pColor->g = static_cast<float>((w565 >> 5) & 63) * (1.0f / 63.0f);
-        pColor->b = static_cast<float>((w565 >> 0) & 31) * (1.0f / 31.0f);
-        pColor->a = 1.0f;
-    }
-
-    inline uint16_t Encode565(_In_ const HDRColorA *pColor) noexcept
-    {
-        HDRColorA Color;
-
-        Color.r = (pColor->r < 0.0f) ? 0.0f : (pColor->r > 1.0f) ? 1.0f : pColor->r;
-        Color.g = (pColor->g < 0.0f) ? 0.0f : (pColor->g > 1.0f) ? 1.0f : pColor->g;
-        Color.b = (pColor->b < 0.0f) ? 0.0f : (pColor->b > 1.0f) ? 1.0f : pColor->b;
-        Color.a = pColor->a;
-
-        uint16_t w;
-
-        w = static_cast<uint16_t>(
-            (static_cast<int32_t>(Color.r * 31.0f + 0.5f) << 11)
-            | (static_cast<int32_t>(Color.g * 63.0f + 0.5f) << 5)
-            | (static_cast<int32_t>(Color.b * 31.0f + 0.5f) << 0));
-
-        return w;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    void OptimizeRGB(
-        _Out_ HDRColorA *pX,
-        _Out_ HDRColorA *pY,
-        _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA *pPoints,
-        uint32_t cSteps,
-        uint32_t flags) noexcept
-    {
-        constexpr float fEpsilon = (0.25f / 64.0f) * (0.25f / 64.0f);
-        static const float pC3[] = { 2.0f / 2.0f, 1.0f / 2.0f, 0.0f / 2.0f };
-        static const float pD3[] = { 0.0f / 2.0f, 1.0f / 2.0f, 2.0f / 2.0f };
-        static const float pC4[] = { 3.0f / 3.0f, 2.0f / 3.0f, 1.0f / 3.0f, 0.0f / 3.0f };
-        static const float pD4[] = { 0.0f / 3.0f, 1.0f / 3.0f, 2.0f / 3.0f, 3.0f / 3.0f };
-
-        const float *pC = (3 == cSteps) ? pC3 : pC4;
-        const float *pD = (3 == cSteps) ? pD3 : pD4;
-
-        // Find Min and Max points, as starting point
-        HDRColorA X = (flags & BC_FLAGS_UNIFORM) ? HDRColorA(1.f, 1.f, 1.f, 1.f) : g_Luminance;
-        HDRColorA Y = HDRColorA(0.0f, 0.0f, 0.0f, 1.0f);
-
-        for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
-        {
-        #ifdef COLOR_WEIGHTS
-            if (pPoints[iPoint].a > 0.0f)
-            #endif // COLOR_WEIGHTS
-            {
-                if (pPoints[iPoint].r < X.r)
-                    X.r = pPoints[iPoint].r;
-
-                if (pPoints[iPoint].g < X.g)
-                    X.g = pPoints[iPoint].g;
-
-                if (pPoints[iPoint].b < X.b)
-                    X.b = pPoints[iPoint].b;
-
-                if (pPoints[iPoint].r > Y.r)
-                    Y.r = pPoints[iPoint].r;
-
-                if (pPoints[iPoint].g > Y.g)
-                    Y.g = pPoints[iPoint].g;
-
-                if (pPoints[iPoint].b > Y.b)
-                    Y.b = pPoints[iPoint].b;
-            }
-        }
-
-        // Diagonal axis
-        const HDRColorA AB(Y.r - X.r, Y.g - X.g, Y.b - X.b, 0.0f);
-
-        const float fAB = AB.r * AB.r + AB.g * AB.g + AB.b * AB.b;
-
-        // Single color block.. no need to root-find
-        if (fAB < FLT_MIN)
-        {
-            pX->r = X.r; pX->g = X.g; pX->b = X.b; pX->a = 1.0f;
-            pY->r = Y.r; pY->g = Y.g; pY->b = Y.b; pY->a = 1.0f;
-            return;
-        }
-
-        // Try all four axis directions, to determine which diagonal best fits data
-        const float fABInv = 1.0f / fAB;
-
-        HDRColorA Dir(AB.r * fABInv, AB.g * fABInv, AB.b * fABInv, 0.0f);
-
-        const HDRColorA Mid(
-            (X.r + Y.r) * 0.5f,
-            (X.g + Y.g) * 0.5f,
-            (X.b + Y.b) * 0.5f,
-            0.0f);
-
-        float fDir[4] = {};
-
-        for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
-        {
-            HDRColorA Pt;
-            Pt.r = (pPoints[iPoint].r - Mid.r) * Dir.r;
-            Pt.g = (pPoints[iPoint].g - Mid.g) * Dir.g;
-            Pt.b = (pPoints[iPoint].b - Mid.b) * Dir.b;
-            Pt.a = 0.0f;
-
-            float f;
-
-        #ifdef COLOR_WEIGHTS
-            f = Pt.r + Pt.g + Pt.b;
-            fDir[0] += pPoints[iPoint].a * f * f;
-
-            f = Pt.r + Pt.g - Pt.b;
-            fDir[1] += pPoints[iPoint].a * f * f;
-
-            f = Pt.r - Pt.g + Pt.b;
-            fDir[2] += pPoints[iPoint].a * f * f;
-
-            f = Pt.r - Pt.g - Pt.b;
-            fDir[3] += pPoints[iPoint].a * f * f;
-        #else
-            f = Pt.r + Pt.g + Pt.b;
-            fDir[0] += f * f;
-
-            f = Pt.r + Pt.g - Pt.b;
-            fDir[1] += f * f;
-
-            f = Pt.r - Pt.g + Pt.b;
-            fDir[2] += f * f;
-
-            f = Pt.r - Pt.g - Pt.b;
-            fDir[3] += f * f;
-        #endif // COLOR_WEIGHTS
-        }
-
-        float fDirMax = fDir[0];
-        size_t  iDirMax = 0;
-
-        for (size_t iDir = 1; iDir < 4; iDir++)
-        {
-            if (fDir[iDir] > fDirMax)
-            {
-                fDirMax = fDir[iDir];
-                iDirMax = iDir;
-            }
-        }
-
-        if (iDirMax & 2)
-        {
-            const float f = X.g; X.g = Y.g; Y.g = f;
-        }
-
-        if (iDirMax & 1)
-        {
-            const float f = X.b; X.b = Y.b; Y.b = f;
-        }
-
-
-        // Two color block.. no need to root-find
-        if (fAB < 1.0f / 4096.0f)
-        {
-            pX->r = X.r; pX->g = X.g; pX->b = X.b; pX->a = 1.0f;
-            pY->r = Y.r; pY->g = Y.g; pY->b = Y.b; pY->a = 1.0f;
-            return;
-        }
-
-        // Use Newton's Method to find local minima of sum-of-squares error.
-        auto const fSteps = static_cast<float>(cSteps - 1);
-
-        for (size_t iIteration = 0; iIteration < 8; iIteration++)
-        {
-            // Calculate new steps
-            HDRColorA pSteps[4];
-
-            for (size_t iStep = 0; iStep < cSteps; iStep++)
-            {
-                pSteps[iStep].r = X.r * pC[iStep] + Y.r * pD[iStep];
-                pSteps[iStep].g = X.g * pC[iStep] + Y.g * pD[iStep];
-                pSteps[iStep].b = X.b * pC[iStep] + Y.b * pD[iStep];
-                pSteps[iStep].a = 1.0f;
-            }
-
-
-            // Calculate color direction
-            Dir.r = Y.r - X.r;
-            Dir.g = Y.g - X.g;
-            Dir.b = Y.b - X.b;
-
-            const float fLen = (Dir.r * Dir.r + Dir.g * Dir.g + Dir.b * Dir.b);
-
-            if (fLen < (1.0f / 4096.0f))
-                break;
-
-            const float fScale = fSteps / fLen;
-
-            Dir.r *= fScale;
-            Dir.g *= fScale;
-            Dir.b *= fScale;
-
-
-            // Evaluate function, and derivatives
-            float d2X = 0.f;
-            float d2Y = 0.f;
-            HDRColorA dX = {};
-            HDRColorA dY = {};
-
-            for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
-            {
-                const float fDot = (pPoints[iPoint].r - X.r) * Dir.r +
-                    (pPoints[iPoint].g - X.g) * Dir.g +
-                    (pPoints[iPoint].b - X.b) * Dir.b;
-
-
-                uint32_t iStep;
-                if (fDot <= 0.0f)
-                    iStep = 0;
-                else if (fDot >= fSteps)
-                    iStep = cSteps - 1;
-                else
-                    iStep = uint32_t(fDot + 0.5f);
-
-
-                HDRColorA Diff;
-                Diff.r = pSteps[iStep].r - pPoints[iPoint].r;
-                Diff.g = pSteps[iStep].g - pPoints[iPoint].g;
-                Diff.b = pSteps[iStep].b - pPoints[iPoint].b;
-                Diff.a = 0.0f;
-
-            #ifdef COLOR_WEIGHTS
-                const float fC = pC[iStep] * pPoints[iPoint].a * (1.0f / 8.0f);
-                const float fD = pD[iStep] * pPoints[iPoint].a * (1.0f / 8.0f);
-            #else
-                const float fC = pC[iStep] * (1.0f / 8.0f);
-                const float fD = pD[iStep] * (1.0f / 8.0f);
-            #endif // COLOR_WEIGHTS
-
-                d2X += fC * pC[iStep];
-                dX.r += fC * Diff.r;
-                dX.g += fC * Diff.g;
-                dX.b += fC * Diff.b;
-
-                d2Y += fD * pD[iStep];
-                dY.r += fD * Diff.r;
-                dY.g += fD * Diff.g;
-                dY.b += fD * Diff.b;
-            }
-
-            // Move endpoints
-            if (d2X > 0.0f)
-            {
-                const float f = -1.0f / d2X;
-
-                X.r += dX.r * f;
-                X.g += dX.g * f;
-                X.b += dX.b * f;
-            }
-
-            if (d2Y > 0.0f)
-            {
-                const float f = -1.0f / d2Y;
-
-                Y.r += dY.r * f;
-                Y.g += dY.g * f;
-                Y.b += dY.b * f;
-            }
-
-            if ((dX.r * dX.r < fEpsilon) && (dX.g * dX.g < fEpsilon) && (dX.b * dX.b < fEpsilon) &&
-                (dY.r * dY.r < fEpsilon) && (dY.g * dY.g < fEpsilon) && (dY.b * dY.b < fEpsilon))
-            {
-                break;
-            }
-        }
-
-        pX->r = X.r; pX->g = X.g; pX->b = X.b; pX->a = 1.0f;
-        pY->r = Y.r; pY->g = Y.g; pY->b = Y.b; pY->a = 1.0f;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    inline void DecodeBC1(
-        _Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor,
-        _In_ const D3DX_BC1 *pBC,
-        bool isbc1) noexcept
-    {
-        assert(pColor && pBC);
-        static_assert(sizeof(D3DX_BC1) == 8, "D3DX_BC1 should be 8 bytes");
-
-        static XMVECTORF32 s_Scale = { { { 1.f / 31.f, 1.f / 63.f, 1.f / 31.f, 1.f } } };
-
-        XMVECTOR clr0 = XMLoadU565(reinterpret_cast<const XMU565*>(&pBC->rgb[0]));
-        XMVECTOR clr1 = XMLoadU565(reinterpret_cast<const XMU565*>(&pBC->rgb[1]));
-
-        clr0 = XMVectorMultiply(clr0, s_Scale);
-        clr1 = XMVectorMultiply(clr1, s_Scale);
-
-        clr0 = XMVectorSwizzle<2, 1, 0, 3>(clr0);
-        clr1 = XMVectorSwizzle<2, 1, 0, 3>(clr1);
-
-        clr0 = XMVectorSelect(g_XMIdentityR3, clr0, g_XMSelect1110);
-        clr1 = XMVectorSelect(g_XMIdentityR3, clr1, g_XMSelect1110);
-
-        XMVECTOR clr2, clr3;
-        if (isbc1 && (pBC->rgb[0] <= pBC->rgb[1]))
-        {
-            clr2 = XMVectorLerp(clr0, clr1, 0.5f);
-            clr3 = XMVectorZero();  // Alpha of 0
-        }
-        else
-        {
-            clr2 = XMVectorLerp(clr0, clr1, 1.f / 3.f);
-            clr3 = XMVectorLerp(clr0, clr1, 2.f / 3.f);
-        }
-
-        uint32_t dw = pBC->bitmap;
-
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i, dw >>= 2)
-        {
-            switch (dw & 3)
-            {
-            case 0: pColor[i] = clr0; break;
-            case 1: pColor[i] = clr1; break;
-            case 2: pColor[i] = clr2; break;
-
-            case 3:
-            default: pColor[i] = clr3; break;
-            }
-        }
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    void EncodeBC1(
-        _Out_ D3DX_BC1 *pBC,
-        _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA *pColor,
-        bool bColorKey,
-        float threshold,
-        uint32_t flags) noexcept
-    {
-        assert(pBC && pColor);
-        static_assert(sizeof(D3DX_BC1) == 8, "D3DX_BC1 should be 8 bytes");
-
-        // Determine if we need to colorkey this block
-        uint32_t uSteps;
-
-        if (bColorKey)
-        {
-            size_t uColorKey = 0;
-
-            for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-            {
-                if (pColor[i].a < threshold)
-                    uColorKey++;
-            }
-
-            if (NUM_PIXELS_PER_BLOCK == uColorKey)
-            {
-                pBC->rgb[0] = 0x0000;
-                pBC->rgb[1] = 0xffff;
-                pBC->bitmap = 0xffffffff;
-                return;
-            }
-
-            uSteps = (uColorKey > 0) ? 3u : 4u;
-        }
-        else
-        {
-            uSteps = 4u;
-        }
-
-        // Quantize block to R56B5, using Floyd Stienberg error diffusion.  This
-        // increases the chance that colors will map directly to the quantized
-        // axis endpoints.
-        HDRColorA Color[NUM_PIXELS_PER_BLOCK];
-        HDRColorA Error[NUM_PIXELS_PER_BLOCK];
-
-        if (flags & BC_FLAGS_DITHER_RGB)
-            memset(Error, 0x00, NUM_PIXELS_PER_BLOCK * sizeof(HDRColorA));
-
-        size_t i;
-        for (i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            HDRColorA Clr;
-            Clr.r = pColor[i].r;
-            Clr.g = pColor[i].g;
-            Clr.b = pColor[i].b;
-            Clr.a = 1.0f;
-
-            if (flags & BC_FLAGS_DITHER_RGB)
-            {
-                Clr.r += Error[i].r;
-                Clr.g += Error[i].g;
-                Clr.b += Error[i].b;
-            }
-
-            Color[i].r = static_cast<float>(static_cast<int32_t>(Clr.r * 31.0f + 0.5f)) * (1.0f / 31.0f);
-            Color[i].g = static_cast<float>(static_cast<int32_t>(Clr.g * 63.0f + 0.5f)) * (1.0f / 63.0f);
-            Color[i].b = static_cast<float>(static_cast<int32_t>(Clr.b * 31.0f + 0.5f)) * (1.0f / 31.0f);
-
-        #ifdef COLOR_WEIGHTS
-            Color[i].a = pColor[i].a;
-        #else
-            Color[i].a = 1.0f;
-        #endif // COLOR_WEIGHTS
-
-            if (flags & BC_FLAGS_DITHER_RGB)
-            {
-                HDRColorA Diff;
-                Diff.r = Color[i].a * (Clr.r - Color[i].r);
-                Diff.g = Color[i].a * (Clr.g - Color[i].g);
-                Diff.b = Color[i].a * (Clr.b - Color[i].b);
-                Diff.a = 0.0f;
-
-                if (3 != (i & 3))
-                {
-                    assert(i < 15);
-                    _Analysis_assume_(i < 15);
-                    Error[i + 1].r += Diff.r * (7.0f / 16.0f);
-                    Error[i + 1].g += Diff.g * (7.0f / 16.0f);
-                    Error[i + 1].b += Diff.b * (7.0f / 16.0f);
-                }
-
-                if (i < 12)
-                {
-                    if (i & 3)
-                    {
-                        Error[i + 3].r += Diff.r * (3.0f / 16.0f);
-                        Error[i + 3].g += Diff.g * (3.0f / 16.0f);
-                        Error[i + 3].b += Diff.b * (3.0f / 16.0f);
-                    }
-
-                    Error[i + 4].r += Diff.r * (5.0f / 16.0f);
-                    Error[i + 4].g += Diff.g * (5.0f / 16.0f);
-                    Error[i + 4].b += Diff.b * (5.0f / 16.0f);
-
-                    if (3 != (i & 3))
-                    {
-                        assert(i < 11);
-                        _Analysis_assume_(i < 11);
-                        Error[i + 5].r += Diff.r * (1.0f / 16.0f);
-                        Error[i + 5].g += Diff.g * (1.0f / 16.0f);
-                        Error[i + 5].b += Diff.b * (1.0f / 16.0f);
-                    }
-                }
-            }
-
-            if (!(flags & BC_FLAGS_UNIFORM))
-            {
-                Color[i].r *= g_Luminance.r;
-                Color[i].g *= g_Luminance.g;
-                Color[i].b *= g_Luminance.b;
-            }
-        }
-
-        // Perform 6D root finding function to find two endpoints of color axis.
-        // Then quantize and sort the endpoints depending on mode.
-        HDRColorA ColorA, ColorB, ColorC, ColorD;
-
-        OptimizeRGB(&ColorA, &ColorB, Color, uSteps, flags);
-
-        if (flags & BC_FLAGS_UNIFORM)
-        {
-            ColorC = ColorA;
-            ColorD = ColorB;
-        }
-        else
-        {
-            ColorC.r = ColorA.r * g_LuminanceInv.r;
-            ColorC.g = ColorA.g * g_LuminanceInv.g;
-            ColorC.b = ColorA.b * g_LuminanceInv.b;
-            ColorC.a = ColorA.a;
-
-            ColorD.r = ColorB.r * g_LuminanceInv.r;
-            ColorD.g = ColorB.g * g_LuminanceInv.g;
-            ColorD.b = ColorB.b * g_LuminanceInv.b;
-            ColorD.a = ColorB.a;
-        }
-
-        const uint16_t wColorA = Encode565(&ColorC);
-        const uint16_t wColorB = Encode565(&ColorD);
-
-        if ((uSteps == 4) && (wColorA == wColorB))
-        {
-            pBC->rgb[0] = wColorA;
-            pBC->rgb[1] = wColorB;
-            pBC->bitmap = 0x00000000;
-            return;
-        }
-
-        Decode565(&ColorC, wColorA);
-        Decode565(&ColorD, wColorB);
-
-        if (flags & BC_FLAGS_UNIFORM)
-        {
-            ColorA = ColorC;
-            ColorB = ColorD;
-        }
-        else
-        {
-            ColorA.r = ColorC.r * g_Luminance.r;
-            ColorA.g = ColorC.g * g_Luminance.g;
-            ColorA.b = ColorC.b * g_Luminance.b;
-
-            ColorB.r = ColorD.r * g_Luminance.r;
-            ColorB.g = ColorD.g * g_Luminance.g;
-            ColorB.b = ColorD.b * g_Luminance.b;
-        }
-
-        // Calculate color steps
-        HDRColorA Step[4];
-
-        if ((3 == uSteps) == (wColorA <= wColorB))
-        {
-            pBC->rgb[0] = wColorA;
-            pBC->rgb[1] = wColorB;
-
-            Step[0] = ColorA;
-            Step[1] = ColorB;
-        }
-        else
-        {
-            pBC->rgb[0] = wColorB;
-            pBC->rgb[1] = wColorA;
-
-            Step[0] = ColorB;
-            Step[1] = ColorA;
-        }
-
-        static const size_t pSteps3[] = { 0, 2, 1 };
-        static const size_t pSteps4[] = { 0, 2, 3, 1 };
-        const size_t *pSteps;
-
-        if (3 == uSteps)
-        {
-            pSteps = pSteps3;
-
-            HDRColorALerp(&Step[2], &Step[0], &Step[1], 0.5f);
-        }
-        else
-        {
-            pSteps = pSteps4;
-
-            HDRColorALerp(&Step[2], &Step[0], &Step[1], 1.0f / 3.0f);
-            HDRColorALerp(&Step[3], &Step[0], &Step[1], 2.0f / 3.0f);
-        }
-
-        // Calculate color direction
-        HDRColorA Dir;
-        Dir.r = Step[1].r - Step[0].r;
-        Dir.g = Step[1].g - Step[0].g;
-        Dir.b = Step[1].b - Step[0].b;
-        Dir.a = 0.0f;
-
-        const auto fSteps = static_cast<float>(uSteps - 1);
-        const float fScale = (wColorA != wColorB) ? (fSteps / (Dir.r * Dir.r + Dir.g * Dir.g + Dir.b * Dir.b)) : 0.0f;
-
-        Dir.r *= fScale;
-        Dir.g *= fScale;
-        Dir.b *= fScale;
-
-        // Encode colors
-        uint32_t dw = 0;
-        if (flags & BC_FLAGS_DITHER_RGB)
-            memset(Error, 0x00, NUM_PIXELS_PER_BLOCK * sizeof(HDRColorA));
-
-        for (i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            if ((3 == uSteps) && (pColor[i].a < threshold))
-            {
-                dw = (3u << 30) | (dw >> 2);
-            }
-            else
-            {
-                HDRColorA Clr;
-                if (flags & BC_FLAGS_UNIFORM)
-                {
-                    Clr.r = pColor[i].r;
-                    Clr.g = pColor[i].g;
-                    Clr.b = pColor[i].b;
-                }
-                else
-                {
-                    Clr.r = pColor[i].r * g_Luminance.r;
-                    Clr.g = pColor[i].g * g_Luminance.g;
-                    Clr.b = pColor[i].b * g_Luminance.b;
-                }
-                Clr.a = 1.0f;
-
-                if (flags & BC_FLAGS_DITHER_RGB)
-                {
-                    Clr.r += Error[i].r;
-                    Clr.g += Error[i].g;
-                    Clr.b += Error[i].b;
-                }
-
-                const float fDot = (Clr.r - Step[0].r) * Dir.r + (Clr.g - Step[0].g) * Dir.g + (Clr.b - Step[0].b) * Dir.b;
-
-                uint32_t iStep;
-                if (fDot <= 0.0f)
-                    iStep = 0;
-                else if (fDot >= fSteps)
-                    iStep = 1;
-                else
-                    iStep = uint32_t(pSteps[uint32_t(fDot + 0.5f)]);
-
-                dw = (iStep << 30) | (dw >> 2);
-
-                if (flags & BC_FLAGS_DITHER_RGB)
-                {
-                    HDRColorA Diff;
-                    Diff.r = Color[i].a * (Clr.r - Step[iStep].r);
-                    Diff.g = Color[i].a * (Clr.g - Step[iStep].g);
-                    Diff.b = Color[i].a * (Clr.b - Step[iStep].b);
-                    Diff.a = 0.0f;
-
-                    if (3 != (i & 3))
-                    {
-                        Error[i + 1].r += Diff.r * (7.0f / 16.0f);
-                        Error[i + 1].g += Diff.g * (7.0f / 16.0f);
-                        Error[i + 1].b += Diff.b * (7.0f / 16.0f);
-                    }
-
-                    if (i < 12)
-                    {
-                        if (i & 3)
-                        {
-                            Error[i + 3].r += Diff.r * (3.0f / 16.0f);
-                            Error[i + 3].g += Diff.g * (3.0f / 16.0f);
-                            Error[i + 3].b += Diff.b * (3.0f / 16.0f);
-                        }
-
-                        Error[i + 4].r += Diff.r * (5.0f / 16.0f);
-                        Error[i + 4].g += Diff.g * (5.0f / 16.0f);
-                        Error[i + 4].b += Diff.b * (5.0f / 16.0f);
-
-                        if (3 != (i & 3))
-                        {
-                            Error[i + 5].r += Diff.r * (1.0f / 16.0f);
-                            Error[i + 5].g += Diff.g * (1.0f / 16.0f);
-                            Error[i + 5].b += Diff.b * (1.0f / 16.0f);
-                        }
-                    }
-                }
-            }
-        }
-
-        pBC->bitmap = dw;
-    }
-
-    //-------------------------------------------------------------------------------------
-#ifdef COLOR_WEIGHTS
-    void EncodeSolidBC1(_Out_ D3DX_BC1 *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA *pColor)
-    {
-    #ifdef COLOR_AVG_0WEIGHTS
-        // Compute avg color
-        HDRColorA Color;
-        Color.r = pColor[0].r;
-        Color.g = pColor[0].g;
-        Color.b = pColor[0].b;
-
-        for (size_t i = 1; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            Color.r += pColor[i].r;
-            Color.g += pColor[i].g;
-            Color.b += pColor[i].b;
-        }
-
-        Color.r *= 1.0f / 16.0f;
-        Color.g *= 1.0f / 16.0f;
-        Color.b *= 1.0f / 16.0f;
-
-        const uint16_t wColor = Encode565(&Color);
-    #else
-        const uint16_t wColor = 0x0000;
-    #endif // COLOR_AVG_0WEIGHTS
-
-        // Encode solid block
-        pBC->rgb[0] = wColor;
-        pBC->rgb[1] = wColor;
-        pBC->bitmap = 0x00000000;
-    }
-#endif // COLOR_WEIGHTS
-}
-
-
-//=====================================================================================
-// Entry points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// BC1 Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC1(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    auto pBC1 = reinterpret_cast<const D3DX_BC1 *>(pBC);
-    DecodeBC1(pColor, pBC1, true);
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC1(uint8_t *pBC, const XMVECTOR *pColor, float threshold, uint32_t flags) noexcept
-{
-    assert(pBC && pColor);
-
-    HDRColorA Color[NUM_PIXELS_PER_BLOCK];
-
-    if (flags & BC_FLAGS_DITHER_A)
-    {
-        float fError[NUM_PIXELS_PER_BLOCK] = {};
-
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            HDRColorA clr;
-            XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(&clr), pColor[i]);
-
-            const float fAlph = clr.a + fError[i];
-
-            Color[i].r = clr.r;
-            Color[i].g = clr.g;
-            Color[i].b = clr.b;
-            Color[i].a = static_cast<float>(static_cast<int32_t>(clr.a + fError[i] + 0.5f));
-
-            const float fDiff = fAlph - Color[i].a;
-
-            if (3 != (i & 3))
-            {
-                assert(i < 15);
-                _Analysis_assume_(i < 15);
-                fError[i + 1] += fDiff * (7.0f / 16.0f);
-            }
-
-            if (i < 12)
-            {
-                if (i & 3)
-                    fError[i + 3] += fDiff * (3.0f / 16.0f);
-
-                fError[i + 4] += fDiff * (5.0f / 16.0f);
-
-                if (3 != (i & 3))
-                {
-                    assert(i < 11);
-                    _Analysis_assume_(i < 11);
-                    fError[i + 5] += fDiff * (1.0f / 16.0f);
-                }
-            }
-        }
-    }
-    else
-    {
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(&Color[i]), pColor[i]);
-        }
-    }
-
-    auto pBC1 = reinterpret_cast<D3DX_BC1 *>(pBC);
-    EncodeBC1(pBC1, Color, true, threshold, flags);
-}
-
-
-//-------------------------------------------------------------------------------------
-// BC2 Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC2(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    assert(pColor && pBC);
-    static_assert(sizeof(D3DX_BC2) == 16, "D3DX_BC2 should be 16 bytes");
-
-    auto pBC2 = reinterpret_cast<const D3DX_BC2 *>(pBC);
-
-    // RGB part
-    DecodeBC1(pColor, &pBC2->bc1, false);
-
-    // 4-bit alpha part
-    uint32_t dw = pBC2->bitmap[0];
-
-    for (size_t i = 0; i < 8; ++i, dw >>= 4)
-    {
-    #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
-        pColor[i] = XMVectorSetW(pColor[i], static_cast<float>(dw & 0xf) * (1.0f / 15.0f));
-    }
-
-    dw = pBC2->bitmap[1];
-
-    for (size_t i = 8; i < NUM_PIXELS_PER_BLOCK; ++i, dw >>= 4)
-        pColor[i] = XMVectorSetW(pColor[i], static_cast<float>(dw & 0xf) * (1.0f / 15.0f));
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC2(uint8_t *pBC, const XMVECTOR *pColor, uint32_t flags) noexcept
-{
-    assert(pBC && pColor);
-    static_assert(sizeof(D3DX_BC2) == 16, "D3DX_BC2 should be 16 bytes");
-
-    HDRColorA Color[NUM_PIXELS_PER_BLOCK];
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(&Color[i]), pColor[i]);
-    }
-
-    auto pBC2 = reinterpret_cast<D3DX_BC2 *>(pBC);
-
-    // 4-bit alpha part.  Dithered using Floyd Stienberg error diffusion.
-    pBC2->bitmap[0] = 0;
-    pBC2->bitmap[1] = 0;
-
-    float fError[NUM_PIXELS_PER_BLOCK] = {};
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        float fAlph = Color[i].a;
-        if (flags & BC_FLAGS_DITHER_A)
-            fAlph += fError[i];
-
-        const auto u = static_cast<uint32_t>(fAlph * 15.0f + 0.5f);
-
-        pBC2->bitmap[i >> 3] >>= 4;
-        pBC2->bitmap[i >> 3] |= (u << 28);
-
-        if (flags & BC_FLAGS_DITHER_A)
-        {
-            const float fDiff = fAlph - float(u) * (1.0f / 15.0f);
-
-            if (3 != (i & 3))
-            {
-                assert(i < 15);
-                _Analysis_assume_(i < 15);
-                fError[i + 1] += fDiff * (7.0f / 16.0f);
-            }
-
-            if (i < 12)
-            {
-                if (i & 3)
-                    fError[i + 3] += fDiff * (3.0f / 16.0f);
-
-                fError[i + 4] += fDiff * (5.0f / 16.0f);
-
-                if (3 != (i & 3))
-                {
-                    assert(i < 11);
-                    _Analysis_assume_(i < 11);
-                    fError[i + 5] += fDiff * (1.0f / 16.0f);
-                }
-            }
-        }
-    }
-
-    // RGB part
-#ifdef COLOR_WEIGHTS
-    if (!pBC2->bitmap[0] && !pBC2->bitmap[1])
-    {
-        EncodeSolidBC1(pBC2->dxt1, Color);
-        return;
-    }
-#endif // COLOR_WEIGHTS
-
-    EncodeBC1(&pBC2->bc1, Color, false, 0.f, flags);
-}
-
-
-//-------------------------------------------------------------------------------------
-// BC3 Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC3(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    assert(pColor && pBC);
-    static_assert(sizeof(D3DX_BC3) == 16, "D3DX_BC3 should be 16 bytes");
-
-    auto pBC3 = reinterpret_cast<const D3DX_BC3 *>(pBC);
-
-    // RGB part
-    DecodeBC1(pColor, &pBC3->bc1, false);
-
-    // Adaptive 3-bit alpha part
-    float fAlpha[8];
-
-    fAlpha[0] = static_cast<float>(pBC3->alpha[0]) * (1.0f / 255.0f);
-    fAlpha[1] = static_cast<float>(pBC3->alpha[1]) * (1.0f / 255.0f);
-
-    if (pBC3->alpha[0] > pBC3->alpha[1])
-    {
-        for (size_t i = 1; i < 7; ++i)
-            fAlpha[i + 1] = (fAlpha[0] * float(7u - i) + fAlpha[1] * float(i)) * (1.0f / 7.0f);
-    }
-    else
-    {
-        for (size_t i = 1; i < 5; ++i)
-            fAlpha[i + 1] = (fAlpha[0] * float(5u - i) + fAlpha[1] * float(i)) * (1.0f / 5.0f);
-
-        fAlpha[6] = 0.0f;
-        fAlpha[7] = 1.0f;
-    }
-
-    uint32_t dw = uint32_t(pBC3->bitmap[0]) | uint32_t(pBC3->bitmap[1] << 8) | uint32_t(pBC3->bitmap[2] << 16);
-
-    for (size_t i = 0; i < 8; ++i, dw >>= 3)
-        pColor[i] = XMVectorSetW(pColor[i], fAlpha[dw & 0x7]);
-
-    dw = uint32_t(pBC3->bitmap[3]) | uint32_t(pBC3->bitmap[4] << 8) | uint32_t(pBC3->bitmap[5] << 16);
-
-    for (size_t i = 8; i < NUM_PIXELS_PER_BLOCK; ++i, dw >>= 3)
-        pColor[i] = XMVectorSetW(pColor[i], fAlpha[dw & 0x7]);
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC3(uint8_t *pBC, const XMVECTOR *pColor, uint32_t flags) noexcept
-{
-    assert(pBC && pColor);
-    static_assert(sizeof(D3DX_BC3) == 16, "D3DX_BC3 should be 16 bytes");
-
-    HDRColorA Color[NUM_PIXELS_PER_BLOCK];
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(&Color[i]), pColor[i]);
-    }
-
-    auto pBC3 = reinterpret_cast<D3DX_BC3 *>(pBC);
-
-    // Quantize block to A8, using Floyd Stienberg error diffusion.  This
-    // increases the chance that colors will map directly to the quantized
-    // axis endpoints.
-    float fAlpha[NUM_PIXELS_PER_BLOCK] = {};
-    float fError[NUM_PIXELS_PER_BLOCK] = {};
-
-    float fMinAlpha = Color[0].a;
-    float fMaxAlpha = Color[0].a;
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        float fAlph = Color[i].a;
-        if (flags & BC_FLAGS_DITHER_A)
-            fAlph += fError[i];
-
-        fAlpha[i] = static_cast<float>(static_cast<int32_t>(fAlph * 255.0f + 0.5f)) * (1.0f / 255.0f);
-
-        if (fAlpha[i] < fMinAlpha)
-            fMinAlpha = fAlpha[i];
-        else if (fAlpha[i] > fMaxAlpha)
-            fMaxAlpha = fAlpha[i];
-
-        if (flags & BC_FLAGS_DITHER_A)
-        {
-            const float fDiff = fAlph - fAlpha[i];
-
-            if (3 != (i & 3))
-            {
-                assert(i < 15);
-                _Analysis_assume_(i < 15);
-                fError[i + 1] += fDiff * (7.0f / 16.0f);
-            }
-
-            if (i < 12)
-            {
-                if (i & 3)
-                    fError[i + 3] += fDiff * (3.0f / 16.0f);
-
-                fError[i + 4] += fDiff * (5.0f / 16.0f);
-
-                if (3 != (i & 3))
-                {
-                    assert(i < 11);
-                    _Analysis_assume_(i < 11);
-                    fError[i + 5] += fDiff * (1.0f / 16.0f);
-                }
-            }
-        }
-    }
-
-#ifdef COLOR_WEIGHTS
-    if (0.0f == fMaxAlpha)
-    {
-        EncodeSolidBC1(&pBC3->dxt1, Color);
-        pBC3->alpha[0] = 0x00;
-        pBC3->alpha[1] = 0x00;
-        memset(pBC3->bitmap, 0x00, 6);
-    }
-#endif
-
-    // RGB part
-    EncodeBC1(&pBC3->bc1, Color, false, 0.f, flags);
-
-    // Alpha part
-    if (1.0f == fMinAlpha)
-    {
-        pBC3->alpha[0] = 0xff;
-        pBC3->alpha[1] = 0xff;
-        memset(pBC3->bitmap, 0x00, 6);
-        return;
-    }
-
-    // Optimize and Quantize Min and Max values
-    const uint32_t uSteps = ((0.0f == fMinAlpha) || (1.0f == fMaxAlpha)) ? 6u : 8u;
-
-    float fAlphaA, fAlphaB;
-    OptimizeAlpha<false>(&fAlphaA, &fAlphaB, fAlpha, uSteps);
-
-    auto const bAlphaA = static_cast<uint8_t>(static_cast<int32_t>(fAlphaA * 255.0f + 0.5f));
-    auto const bAlphaB = static_cast<uint8_t>(static_cast<int32_t>(fAlphaB * 255.0f + 0.5f));
-
-    fAlphaA = static_cast<float>(bAlphaA) * (1.0f / 255.0f);
-    fAlphaB = static_cast<float>(bAlphaB) * (1.0f / 255.0f);
-
-    // Setup block
-    if ((8 == uSteps) && (bAlphaA == bAlphaB))
-    {
-        pBC3->alpha[0] = bAlphaA;
-        pBC3->alpha[1] = bAlphaB;
-        memset(pBC3->bitmap, 0x00, 6);
-        return;
-    }
-
-    static const size_t pSteps6[] = { 0, 2, 3, 4, 5, 1 };
-    static const size_t pSteps8[] = { 0, 2, 3, 4, 5, 6, 7, 1 };
-
-    const size_t *pSteps;
-    float fStep[8] = {};
-
-    if (6 == uSteps)
-    {
-        pBC3->alpha[0] = bAlphaA;
-        pBC3->alpha[1] = bAlphaB;
-
-        fStep[0] = fAlphaA;
-        fStep[1] = fAlphaB;
-
-        for (size_t i = 1; i < 5; ++i)
-            fStep[i + 1] = (fStep[0] * float(5u - i) + fStep[1] * float(i)) * (1.0f / 5.0f);
-
-        fStep[6] = 0.0f;
-        fStep[7] = 1.0f;
-
-        pSteps = pSteps6;
-    }
-    else
-    {
-        pBC3->alpha[0] = bAlphaB;
-        pBC3->alpha[1] = bAlphaA;
-
-        fStep[0] = fAlphaB;
-        fStep[1] = fAlphaA;
-
-        for (size_t i = 1; i < 7; ++i)
-            fStep[i + 1] = (fStep[0] * float(7u - i) + fStep[1] * float(i)) * (1.0f / 7.0f);
-
-        pSteps = pSteps8;
-    }
-
-    // Encode alpha bitmap
-    auto const fSteps = static_cast<float>(uSteps - 1);
-    const float fScale = (fStep[0] != fStep[1]) ? (fSteps / (fStep[1] - fStep[0])) : 0.0f;
-
-    if (flags & BC_FLAGS_DITHER_A)
-        memset(fError, 0x00, NUM_PIXELS_PER_BLOCK * sizeof(float));
-
-    for (size_t iSet = 0; iSet < 2; iSet++)
-    {
-        uint32_t dw = 0;
-
-        const size_t iMin = iSet * 8;
-        const size_t iLim = iMin + 8;
-
-        for (size_t i = iMin; i < iLim; ++i)
-        {
-            float fAlph = Color[i].a;
-            if (flags & BC_FLAGS_DITHER_A)
-                fAlph += fError[i];
-            const float fDot = (fAlph - fStep[0]) * fScale;
-
-            uint32_t iStep;
-            if (fDot <= 0.0f)
-                iStep = ((6 == uSteps) && (fAlph <= fStep[0] * 0.5f)) ? 6u : 0u;
-            else if (fDot >= fSteps)
-                iStep = ((6 == uSteps) && (fAlph >= (fStep[1] + 1.0f) * 0.5f)) ? 7u : 1u;
-            else
-                iStep = uint32_t(pSteps[uint32_t(fDot + 0.5f)]);
-
-            dw = (iStep << 21) | (dw >> 3);
-
-            if (flags & BC_FLAGS_DITHER_A)
-            {
-                const float fDiff = (fAlph - fStep[iStep]);
-
-                if (3 != (i & 3))
-                    fError[i + 1] += fDiff * (7.0f / 16.0f);
-
-                if (i < 12)
-                {
-                    if (i & 3)
-                        fError[i + 3] += fDiff * (3.0f / 16.0f);
-
-                    fError[i + 4] += fDiff * (5.0f / 16.0f);
-
-                    if (3 != (i & 3))
-                        fError[i + 5] += fDiff * (1.0f / 16.0f);
-                }
-            }
-        }
-
-        pBC3->bitmap[0 + iSet * 3] = reinterpret_cast<uint8_t *>(&dw)[0];
-        pBC3->bitmap[1 + iSet * 3] = reinterpret_cast<uint8_t *>(&dw)[1];
-        pBC3->bitmap[2 + iSet * 3] = reinterpret_cast<uint8_t *>(&dw)[2];
-    }
-}
diff --git a/thirdparty/directxtex/BC.h b/thirdparty/directxtex/BC.h
deleted file mode 100644
index cef5404..0000000
--- a/thirdparty/directxtex/BC.h
+++ /dev/null
@@ -1,339 +0,0 @@
-//-------------------------------------------------------------------------------------
-// BC.h
-//
-// Block-compression (BC) functionality
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-#include <DirectXMath.h>
-#include <DirectXPackedVector.h>
-
-namespace DirectX
-{
-//-------------------------------------------------------------------------------------
-// Macros
-//-------------------------------------------------------------------------------------
-
-// Because these are used in SAL annotations, they need to remain macros rather than const values
-#define NUM_PIXELS_PER_BLOCK 16
-
-//-------------------------------------------------------------------------------------
-// Constants
-//-------------------------------------------------------------------------------------
-
-    enum BC_FLAGS : uint32_t
-    {
-        BC_FLAGS_NONE = 0x0,
-
-        BC_FLAGS_DITHER_RGB = 0x10000,
-        // Enables dithering for RGB colors for BC1-3
-
-        BC_FLAGS_DITHER_A = 0x20000,
-        // Enables dithering for Alpha channel for BC1-3
-
-        BC_FLAGS_UNIFORM = 0x40000,
-        // By default, uses perceptual weighting for BC1-3; this flag makes it a uniform weighting
-
-        BC_FLAGS_USE_3SUBSETS = 0x80000,
-        // By default, BC7 skips mode 0 & 2; this flag adds those modes back
-
-        BC_FLAGS_FORCE_BC7_MODE6 = 0x100000,
-        // BC7 should only use mode 6; skip other modes
-    };
-
-    //-------------------------------------------------------------------------------------
-    // Structures
-    //-------------------------------------------------------------------------------------
-    class LDRColorA;
-
-    class HDRColorA
-    {
-    public:
-        float r, g, b, a;
-
-    public:
-        HDRColorA() = default;
-        HDRColorA(float _r, float _g, float _b, float _a) noexcept : r(_r), g(_g), b(_b), a(_a) {}
-
-        // binary operators
-        HDRColorA operator + (const HDRColorA& c) const noexcept
-        {
-            return HDRColorA(r + c.r, g + c.g, b + c.b, a + c.a);
-        }
-
-        HDRColorA operator - (const HDRColorA& c) const noexcept
-        {
-            return HDRColorA(r - c.r, g - c.g, b - c.b, a - c.a);
-        }
-
-        HDRColorA operator * (float f) const noexcept
-        {
-            return HDRColorA(r * f, g * f, b * f, a * f);
-        }
-
-        HDRColorA operator / (float f) const noexcept
-        {
-            const float fInv = 1.0f / f;
-            return HDRColorA(r * fInv, g * fInv, b * fInv, a * fInv);
-        }
-
-        float operator * (const HDRColorA& c) const noexcept
-        {
-            return r * c.r + g * c.g + b * c.b + a * c.a;
-        }
-
-        // assignment operators
-        HDRColorA& operator += (const HDRColorA& c) noexcept
-        {
-            r += c.r;
-            g += c.g;
-            b += c.b;
-            a += c.a;
-            return *this;
-        }
-
-        HDRColorA& operator -= (const HDRColorA& c) noexcept
-        {
-            r -= c.r;
-            g -= c.g;
-            b -= c.b;
-            a -= c.a;
-            return *this;
-        }
-
-        HDRColorA& operator *= (float f) noexcept
-        {
-            r *= f;
-            g *= f;
-            b *= f;
-            a *= f;
-            return *this;
-        }
-
-        HDRColorA& operator /= (float f) noexcept
-        {
-            const float fInv = 1.0f / f;
-            r *= fInv;
-            g *= fInv;
-            b *= fInv;
-            a *= fInv;
-            return *this;
-        }
-
-        HDRColorA& Clamp(_In_ float fMin, _In_ float fMax) noexcept
-        {
-            r = std::min<float>(fMax, std::max<float>(fMin, r));
-            g = std::min<float>(fMax, std::max<float>(fMin, g));
-            b = std::min<float>(fMax, std::max<float>(fMin, b));
-            a = std::min<float>(fMax, std::max<float>(fMin, a));
-            return *this;
-        }
-
-        HDRColorA(const LDRColorA& c) noexcept;
-        HDRColorA& operator = (const LDRColorA& c) noexcept;
-        LDRColorA ToLDRColorA() const noexcept;
-    };
-
-    inline HDRColorA* HDRColorALerp(_Out_ HDRColorA *pOut, _In_ const HDRColorA *pC1, _In_ const HDRColorA *pC2, _In_ float s) noexcept
-    {
-        pOut->r = pC1->r + s * (pC2->r - pC1->r);
-        pOut->g = pC1->g + s * (pC2->g - pC1->g);
-        pOut->b = pC1->b + s * (pC2->b - pC1->b);
-        pOut->a = pC1->a + s * (pC2->a - pC1->a);
-        return pOut;
-    }
-
-#pragma pack(push,1)
-// BC1/DXT1 compression (4 bits per texel)
-    struct D3DX_BC1
-    {
-        uint16_t    rgb[2]; // 565 colors
-        uint32_t    bitmap; // 2bpp rgb bitmap
-    };
-
-    // BC2/DXT2/3 compression (8 bits per texel)
-    struct D3DX_BC2
-    {
-        uint32_t    bitmap[2];  // 4bpp alpha bitmap
-        D3DX_BC1    bc1;        // BC1 rgb data
-    };
-
-    // BC3/DXT4/5 compression (8 bits per texel)
-    struct D3DX_BC3
-    {
-        uint8_t     alpha[2];   // alpha values
-        uint8_t     bitmap[6];  // 3bpp alpha bitmap
-        D3DX_BC1    bc1;        // BC1 rgb data
-    };
-#pragma pack(pop)
-
-//-------------------------------------------------------------------------------------
-// Templates
-//-------------------------------------------------------------------------------------
-#pragma warning(push)
-#pragma warning(disable : 4127)
-    template <bool bRange> void OptimizeAlpha(float *pX, float *pY, const float *pPoints, uint32_t cSteps) noexcept
-    {
-        static const float pC6[] = { 5.0f / 5.0f, 4.0f / 5.0f, 3.0f / 5.0f, 2.0f / 5.0f, 1.0f / 5.0f, 0.0f / 5.0f };
-        static const float pD6[] = { 0.0f / 5.0f, 1.0f / 5.0f, 2.0f / 5.0f, 3.0f / 5.0f, 4.0f / 5.0f, 5.0f / 5.0f };
-        static const float pC8[] = { 7.0f / 7.0f, 6.0f / 7.0f, 5.0f / 7.0f, 4.0f / 7.0f, 3.0f / 7.0f, 2.0f / 7.0f, 1.0f / 7.0f, 0.0f / 7.0f };
-        static const float pD8[] = { 0.0f / 7.0f, 1.0f / 7.0f, 2.0f / 7.0f, 3.0f / 7.0f, 4.0f / 7.0f, 5.0f / 7.0f, 6.0f / 7.0f, 7.0f / 7.0f };
-
-        const float *pC = (6 == cSteps) ? pC6 : pC8;
-        const float *pD = (6 == cSteps) ? pD6 : pD8;
-
-        constexpr float MAX_VALUE = 1.0f;
-        constexpr float MIN_VALUE = (bRange) ? -1.0f : 0.0f;
-
-        // Find Min and Max points, as starting point
-        float fX = MAX_VALUE;
-        float fY = MIN_VALUE;
-
-        if (8 == cSteps)
-        {
-            for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
-            {
-                if (pPoints[iPoint] < fX)
-                    fX = pPoints[iPoint];
-
-                if (pPoints[iPoint] > fY)
-                    fY = pPoints[iPoint];
-            }
-        }
-        else
-        {
-            for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
-            {
-                if (pPoints[iPoint] < fX && pPoints[iPoint] > MIN_VALUE)
-                    fX = pPoints[iPoint];
-
-                if (pPoints[iPoint] > fY && pPoints[iPoint] < MAX_VALUE)
-                    fY = pPoints[iPoint];
-            }
-
-            if (fX == fY)
-            {
-                fY = MAX_VALUE;
-            }
-        }
-
-        // Use Newton's Method to find local minima of sum-of-squares error.
-        auto const fSteps = static_cast<float>(cSteps - 1);
-
-        for (size_t iIteration = 0; iIteration < 8; iIteration++)
-        {
-            if ((fY - fX) < (1.0f / 256.0f))
-                break;
-
-            float const fScale = fSteps / (fY - fX);
-
-            // Calculate new steps
-            float pSteps[8];
-
-            for (size_t iStep = 0; iStep < cSteps; iStep++)
-                pSteps[iStep] = pC[iStep] * fX + pD[iStep] * fY;
-
-            if (6 == cSteps)
-            {
-                pSteps[6] = MIN_VALUE;
-                pSteps[7] = MAX_VALUE;
-            }
-
-            // Evaluate function, and derivatives
-            float dX = 0.0f;
-            float dY = 0.0f;
-            float d2X = 0.0f;
-            float d2Y = 0.0f;
-
-            for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
-            {
-                const float fDot = (pPoints[iPoint] - fX) * fScale;
-
-                uint32_t iStep;
-                if (fDot <= 0.0f)
-                {
-                    // D3DX10 / D3DX11 didn't take into account the proper minimum value for the bRange (BC4S/BC5S) case
-                    iStep = ((6 == cSteps) && (pPoints[iPoint] <= (fX + MIN_VALUE) * 0.5f)) ? 6u : 0u;
-                }
-                else if (fDot >= fSteps)
-                {
-                    iStep = ((6 == cSteps) && (pPoints[iPoint] >= (fY + MAX_VALUE) * 0.5f)) ? 7u : (cSteps - 1);
-                }
-                else
-                {
-                    iStep = uint32_t(fDot + 0.5f);
-                }
-
-                if (iStep < cSteps)
-                {
-                    // D3DX had this computation backwards (pPoints[iPoint] - pSteps[iStep])
-                    // this fix improves RMS of the alpha component
-                    const float fDiff = pSteps[iStep] - pPoints[iPoint];
-
-                    dX += pC[iStep] * fDiff;
-                    d2X += pC[iStep] * pC[iStep];
-
-                    dY += pD[iStep] * fDiff;
-                    d2Y += pD[iStep] * pD[iStep];
-                }
-            }
-
-            // Move endpoints
-            if (d2X > 0.0f)
-                fX -= dX / d2X;
-
-            if (d2Y > 0.0f)
-                fY -= dY / d2Y;
-
-            if (fX > fY)
-            {
-                const float f = fX; fX = fY; fY = f;
-            }
-
-            if ((dX * dX < (1.0f / 64.0f)) && (dY * dY < (1.0f / 64.0f)))
-                break;
-        }
-
-        *pX = (fX < MIN_VALUE) ? MIN_VALUE : (fX > MAX_VALUE) ? MAX_VALUE : fX;
-        *pY = (fY < MIN_VALUE) ? MIN_VALUE : (fY > MAX_VALUE) ? MAX_VALUE : fY;
-    }
-#pragma warning(pop)
-
-//-------------------------------------------------------------------------------------
-// Functions
-//-------------------------------------------------------------------------------------
-
-    typedef void (*BC_DECODE)(XMVECTOR *pColor, const uint8_t *pBC);
-    typedef void (*BC_ENCODE)(uint8_t *pDXT, const XMVECTOR *pColor, uint32_t flags);
-
-    void D3DXDecodeBC1(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
-    void D3DXDecodeBC2(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
-    void D3DXDecodeBC3(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
-    void D3DXDecodeBC4U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
-    void D3DXDecodeBC4S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
-    void D3DXDecodeBC5U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
-    void D3DXDecodeBC5S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
-    void D3DXDecodeBC6HU(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
-    void D3DXDecodeBC6HS(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
-    void D3DXDecodeBC7(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
-
-    void D3DXEncodeBC1(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ float threshold, _In_ uint32_t flags) noexcept;
-        // BC1 requires one additional parameter, so it doesn't match signature of BC_ENCODE above
-
-    void D3DXEncodeBC2(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
-    void D3DXEncodeBC3(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
-    void D3DXEncodeBC4U(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
-    void D3DXEncodeBC4S(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
-    void D3DXEncodeBC5U(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
-    void D3DXEncodeBC5S(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
-    void D3DXEncodeBC6HU(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
-    void D3DXEncodeBC6HS(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
-    void D3DXEncodeBC7(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
-
-} // namespace
diff --git a/thirdparty/directxtex/BC4BC5.cpp b/thirdparty/directxtex/BC4BC5.cpp
deleted file mode 100644
index 263db98..0000000
--- a/thirdparty/directxtex/BC4BC5.cpp
+++ /dev/null
@@ -1,562 +0,0 @@
-//-------------------------------------------------------------------------------------
-// BC4BC5.cpp
-//
-// Block-compression (BC) functionality for BC4 and BC5 (DirectX 10 texture compression)
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#include "BC.h"
-
-using namespace DirectX;
-
-//------------------------------------------------------------------------------------
-// Constants
-//------------------------------------------------------------------------------------
-
-// Because these are used in SAL annotations, they need to remain macros rather than const values
-#define BLOCK_LEN 4
-// length of each block in texel
-
-#define BLOCK_SIZE (BLOCK_LEN * BLOCK_LEN)
-// total texels in a 4x4 block.
-
-namespace
-{
-    //------------------------------------------------------------------------------------
-    // Structures
-    //-------------------------------------------------------------------------------------
-
-#pragma warning(push)
-#pragma warning(disable : 4201)
-
-    // BC4U/BC5U
-    struct BC4_UNORM
-    {
-        float R(size_t uOffset) const noexcept
-        {
-            const size_t uIndex = GetIndex(uOffset);
-            return DecodeFromIndex(uIndex);
-        }
-
-        float DecodeFromIndex(size_t uIndex) const noexcept
-        {
-            if (uIndex == 0)
-                return float(red_0) / 255.0f;
-            if (uIndex == 1)
-                return float(red_1) / 255.0f;
-            const float fred_0 = float(red_0) / 255.0f;
-            const float fred_1 = float(red_1) / 255.0f;
-            if (red_0 > red_1)
-            {
-                uIndex -= 1;
-                return (fred_0 * float(7u - uIndex) + fred_1 * float(uIndex)) / 7.0f;
-            }
-            else
-            {
-                if (uIndex == 6)
-                    return 0.0f;
-                if (uIndex == 7)
-                    return 1.0f;
-                uIndex -= 1;
-                return (fred_0 * float(5u - uIndex) + fred_1 * float(uIndex)) / 5.0f;
-            }
-        }
-
-        size_t GetIndex(size_t uOffset) const noexcept
-        {
-            return static_cast<size_t>((data >> (3 * uOffset + 16)) & 0x07);
-        }
-
-        void SetIndex(size_t uOffset, size_t uIndex) noexcept
-        {
-            data &= ~(uint64_t(0x07) << (3 * uOffset + 16));
-            data |= (uint64_t(uIndex) << (3 * uOffset + 16));
-        }
-
-        union
-        {
-            struct
-            {
-                uint8_t red_0;
-                uint8_t red_1;
-                uint8_t indices[6];
-            };
-            uint64_t data;
-        };
-    };
-
-    // BC4S/BC5S
-    struct BC4_SNORM
-    {
-        float R(size_t uOffset) const noexcept
-        {
-            const size_t uIndex = GetIndex(uOffset);
-            return DecodeFromIndex(uIndex);
-        }
-
-        float DecodeFromIndex(size_t uIndex) const noexcept
-        {
-            const int8_t sred_0 = (red_0 == -128) ? -127 : red_0;
-            const int8_t sred_1 = (red_1 == -128) ? -127 : red_1;
-
-            if (uIndex == 0)
-                return float(sred_0) / 127.0f;
-            if (uIndex == 1)
-                return float(sred_1) / 127.0f;
-            const float fred_0 = float(sred_0) / 127.0f;
-            const float fred_1 = float(sred_1) / 127.0f;
-            if (red_0 > red_1)
-            {
-                uIndex -= 1;
-                return (fred_0 * float(7u - uIndex) + fred_1 * float(uIndex)) / 7.0f;
-            }
-            else
-            {
-                if (uIndex == 6)
-                    return -1.0f;
-                if (uIndex == 7)
-                    return 1.0f;
-                uIndex -= 1;
-                return (fred_0 * float(5u - uIndex) + fred_1 * float(uIndex)) / 5.0f;
-            }
-        }
-
-        size_t GetIndex(size_t uOffset) const noexcept
-        {
-            return static_cast<size_t>((data >> (3 * uOffset + 16)) & 0x07);
-        }
-
-        void SetIndex(size_t uOffset, size_t uIndex) noexcept
-        {
-            data &= ~(uint64_t(0x07) << (3 * uOffset + 16));
-            data |= (uint64_t(uIndex) << (3 * uOffset + 16));
-        }
-
-        union
-        {
-            struct
-            {
-                int8_t red_0;
-                int8_t red_1;
-                uint8_t indices[6];
-            };
-            uint64_t data;
-        };
-    };
-
-#pragma warning(pop)
-
-    //-------------------------------------------------------------------------------------
-    // Convert a floating point value to an 8-bit SNORM
-    //-------------------------------------------------------------------------------------
-    void inline FloatToSNorm(_In_ float fVal, _Out_ int8_t *piSNorm) noexcept
-    {
-        constexpr uint32_t dwMostNeg = (1 << (8 * sizeof(int8_t) - 1));
-
-        if (isnan(fVal))
-            fVal = 0;
-        else
-            if (fVal > 1)
-                fVal = 1;    // Clamp to 1
-            else
-                if (fVal < -1)
-                    fVal = -1;    // Clamp to -1
-
-        fVal = fVal * static_cast<int8_t>(dwMostNeg - 1);
-
-        if (fVal >= 0)
-            fVal += .5f;
-        else
-            fVal -= .5f;
-
-        *piSNorm = static_cast<int8_t>(fVal);
-    }
-
-
-    //------------------------------------------------------------------------------
-    void FindEndPointsBC4U(
-        _In_reads_(BLOCK_SIZE) const float theTexelsU[],
-        _Out_ uint8_t &endpointU_0,
-        _Out_ uint8_t &endpointU_1) noexcept
-    {
-        // The boundary of codec for signed/unsigned format
-        constexpr float MIN_NORM = 0.f;
-        constexpr float MAX_NORM = 1.f;
-
-        // Find max/min of input texels
-        float fBlockMax = theTexelsU[0];
-        float fBlockMin = theTexelsU[0];
-        for (size_t i = 0; i < BLOCK_SIZE; ++i)
-        {
-            if (theTexelsU[i] < fBlockMin)
-            {
-                fBlockMin = theTexelsU[i];
-            }
-            else if (theTexelsU[i] > fBlockMax)
-            {
-                fBlockMax = theTexelsU[i];
-            }
-        }
-
-        //  If there are boundary values in input texels, should use 4 interpolated color values to guarantee
-        //  the exact code of the boundary values.
-        const bool bUsing4BlockCodec = (MIN_NORM == fBlockMin || MAX_NORM == fBlockMax);
-
-        // Using Optimize
-        float fStart, fEnd;
-
-        if (!bUsing4BlockCodec)
-        {
-            // 6 interpolated color values
-            OptimizeAlpha<false>(&fStart, &fEnd, theTexelsU, 8);
-
-            auto iStart = static_cast<uint8_t>(fStart * 255.0f);
-            auto iEnd = static_cast<uint8_t>(fEnd * 255.0f);
-
-            endpointU_0 = iEnd;
-            endpointU_1 = iStart;
-        }
-        else
-        {
-            // 4 interpolated color values
-            OptimizeAlpha<false>(&fStart, &fEnd, theTexelsU, 6);
-
-            auto iStart = static_cast<uint8_t>(fStart * 255.0f);
-            auto iEnd = static_cast<uint8_t>(fEnd * 255.0f);
-
-            endpointU_1 = iEnd;
-            endpointU_0 = iStart;
-        }
-    }
-
-    void FindEndPointsBC4S(
-        _In_reads_(BLOCK_SIZE) const float theTexelsU[],
-        _Out_ int8_t &endpointU_0,
-        _Out_ int8_t &endpointU_1) noexcept
-    {
-        //  The boundary of codec for signed/unsigned format
-        constexpr float MIN_NORM = -1.f;
-        constexpr float MAX_NORM = 1.f;
-
-        // Find max/min of input texels
-        float fBlockMax = theTexelsU[0];
-        float fBlockMin = theTexelsU[0];
-        for (size_t i = 0; i < BLOCK_SIZE; ++i)
-        {
-            if (theTexelsU[i] < fBlockMin)
-            {
-                fBlockMin = theTexelsU[i];
-            }
-            else if (theTexelsU[i] > fBlockMax)
-            {
-                fBlockMax = theTexelsU[i];
-            }
-        }
-
-        //  If there are boundary values in input texels, should use 4 interpolated color values to guarantee
-        //  the exact code of the boundary values.
-        const bool bUsing4BlockCodec = (MIN_NORM == fBlockMin || MAX_NORM == fBlockMax);
-
-        // Using Optimize
-        float fStart, fEnd;
-
-        if (!bUsing4BlockCodec)
-        {
-            // 6 interpolated color values
-            OptimizeAlpha<true>(&fStart, &fEnd, theTexelsU, 8);
-
-            int8_t iStart, iEnd;
-            FloatToSNorm(fStart, &iStart);
-            FloatToSNorm(fEnd, &iEnd);
-
-            endpointU_0 = iEnd;
-            endpointU_1 = iStart;
-        }
-        else
-        {
-            // 4 interpolated color values
-            OptimizeAlpha<true>(&fStart, &fEnd, theTexelsU, 6);
-
-            int8_t iStart, iEnd;
-            FloatToSNorm(fStart, &iStart);
-            FloatToSNorm(fEnd, &iEnd);
-
-            endpointU_1 = iEnd;
-            endpointU_0 = iStart;
-        }
-    }
-
-
-    //------------------------------------------------------------------------------
-    inline void FindEndPointsBC5U(
-        _In_reads_(BLOCK_SIZE) const float theTexelsU[],
-        _In_reads_(BLOCK_SIZE) const float theTexelsV[],
-        _Out_ uint8_t &endpointU_0,
-        _Out_ uint8_t &endpointU_1,
-        _Out_ uint8_t &endpointV_0,
-        _Out_ uint8_t &endpointV_1) noexcept
-    {
-        //Encoding the U and V channel by BC4 codec separately.
-        FindEndPointsBC4U(theTexelsU, endpointU_0, endpointU_1);
-        FindEndPointsBC4U(theTexelsV, endpointV_0, endpointV_1);
-    }
-
-    inline void FindEndPointsBC5S(
-        _In_reads_(BLOCK_SIZE) const float theTexelsU[],
-        _In_reads_(BLOCK_SIZE) const float theTexelsV[],
-        _Out_ int8_t &endpointU_0,
-        _Out_ int8_t &endpointU_1,
-        _Out_ int8_t &endpointV_0,
-        _Out_ int8_t &endpointV_1) noexcept
-    {
-        //Encoding the U and V channel by BC4 codec separately.
-        FindEndPointsBC4S(theTexelsU, endpointU_0, endpointU_1);
-        FindEndPointsBC4S(theTexelsV, endpointV_0, endpointV_1);
-    }
-
-
-    //------------------------------------------------------------------------------
-    void FindClosestUNORM(
-        _Inout_ BC4_UNORM* pBC,
-        _In_reads_(NUM_PIXELS_PER_BLOCK) const float theTexelsU[]) noexcept
-    {
-        float rGradient[8];
-        for (size_t i = 0; i < 8; ++i)
-        {
-            rGradient[i] = pBC->DecodeFromIndex(i);
-        }
-
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            size_t uBestIndex = 0;
-            float fBestDelta = 100000;
-            for (size_t uIndex = 0; uIndex < 8; uIndex++)
-            {
-                const float fCurrentDelta = fabsf(rGradient[uIndex] - theTexelsU[i]);
-                if (fCurrentDelta < fBestDelta)
-                {
-                    uBestIndex = uIndex;
-                    fBestDelta = fCurrentDelta;
-                }
-            }
-            pBC->SetIndex(i, uBestIndex);
-        }
-    }
-
-    void FindClosestSNORM(
-        _Inout_ BC4_SNORM* pBC,
-        _In_reads_(NUM_PIXELS_PER_BLOCK) const float theTexelsU[]) noexcept
-    {
-        float rGradient[8];
-        for (size_t i = 0; i < 8; ++i)
-        {
-            rGradient[i] = pBC->DecodeFromIndex(i);
-        }
-
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            size_t uBestIndex = 0;
-            float fBestDelta = 100000;
-            for (size_t uIndex = 0; uIndex < 8; uIndex++)
-            {
-                const float fCurrentDelta = fabsf(rGradient[uIndex] - theTexelsU[i]);
-                if (fCurrentDelta < fBestDelta)
-                {
-                    uBestIndex = uIndex;
-                    fBestDelta = fCurrentDelta;
-                }
-            }
-            pBC->SetIndex(i, uBestIndex);
-        }
-    }
-}
-
-
-//=====================================================================================
-// Entry points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// BC4 Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC4U(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    assert(pColor && pBC);
-    static_assert(sizeof(BC4_UNORM) == 8, "BC4_UNORM should be 8 bytes");
-
-    auto pBC4 = reinterpret_cast<const BC4_UNORM*>(pBC);
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-    #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
-        pColor[i] = XMVectorSet(pBC4->R(i), 0, 0, 1.0f);
-    }
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC4S(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    assert(pColor && pBC);
-    static_assert(sizeof(BC4_SNORM) == 8, "BC4_SNORM should be 8 bytes");
-
-    auto pBC4 = reinterpret_cast<const BC4_SNORM*>(pBC);
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-    #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
-        pColor[i] = XMVectorSet(pBC4->R(i), 0, 0, 1.0f);
-    }
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC4U(uint8_t *pBC, const XMVECTOR *pColor, uint32_t flags) noexcept
-{
-    UNREFERENCED_PARAMETER(flags);
-
-    assert(pBC && pColor);
-    static_assert(sizeof(BC4_UNORM) == 8, "BC4_UNORM should be 8 bytes");
-
-    memset(pBC, 0, sizeof(BC4_UNORM));
-    auto pBC4 = reinterpret_cast<BC4_UNORM*>(pBC);
-    float theTexelsU[NUM_PIXELS_PER_BLOCK];
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        theTexelsU[i] = XMVectorGetX(pColor[i]);
-    }
-
-    FindEndPointsBC4U(theTexelsU, pBC4->red_0, pBC4->red_1);
-    FindClosestUNORM(pBC4, theTexelsU);
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC4S(uint8_t *pBC, const XMVECTOR *pColor, uint32_t flags) noexcept
-{
-    UNREFERENCED_PARAMETER(flags);
-
-    assert(pBC && pColor);
-    static_assert(sizeof(BC4_SNORM) == 8, "BC4_SNORM should be 8 bytes");
-
-    memset(pBC, 0, sizeof(BC4_UNORM));
-    auto pBC4 = reinterpret_cast<BC4_SNORM*>(pBC);
-    float theTexelsU[NUM_PIXELS_PER_BLOCK];
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        theTexelsU[i] = XMVectorGetX(pColor[i]);
-    }
-
-    FindEndPointsBC4S(theTexelsU, pBC4->red_0, pBC4->red_1);
-    FindClosestSNORM(pBC4, theTexelsU);
-}
-
-
-//-------------------------------------------------------------------------------------
-// BC5 Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC5U(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    assert(pColor && pBC);
-    static_assert(sizeof(BC4_UNORM) == 8, "BC4_UNORM should be 8 bytes");
-
-    auto pBCR = reinterpret_cast<const BC4_UNORM*>(pBC);
-    auto pBCG = reinterpret_cast<const BC4_UNORM*>(pBC + sizeof(BC4_UNORM));
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-    #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
-        pColor[i] = XMVectorSet(pBCR->R(i), pBCG->R(i), 0, 1.0f);
-    }
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC5S(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    assert(pColor && pBC);
-    static_assert(sizeof(BC4_SNORM) == 8, "BC4_SNORM should be 8 bytes");
-
-    auto pBCR = reinterpret_cast<const BC4_SNORM*>(pBC);
-    auto pBCG = reinterpret_cast<const BC4_SNORM*>(pBC + sizeof(BC4_SNORM));
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-    #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
-        pColor[i] = XMVectorSet(pBCR->R(i), pBCG->R(i), 0, 1.0f);
-    }
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC5U(uint8_t *pBC, const XMVECTOR *pColor, uint32_t flags) noexcept
-{
-    UNREFERENCED_PARAMETER(flags);
-
-    assert(pBC && pColor);
-    static_assert(sizeof(BC4_UNORM) == 8, "BC4_UNORM should be 8 bytes");
-
-    memset(pBC, 0, sizeof(BC4_UNORM) * 2);
-    auto pBCR = reinterpret_cast<BC4_UNORM*>(pBC);
-    auto pBCG = reinterpret_cast<BC4_UNORM*>(pBC + sizeof(BC4_UNORM));
-    float theTexelsU[NUM_PIXELS_PER_BLOCK];
-    float theTexelsV[NUM_PIXELS_PER_BLOCK];
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        XMFLOAT4A clr;
-        XMStoreFloat4A(&clr, pColor[i]);
-        theTexelsU[i] = clr.x;
-        theTexelsV[i] = clr.y;
-    }
-
-    FindEndPointsBC5U(
-        theTexelsU,
-        theTexelsV,
-        pBCR->red_0,
-        pBCR->red_1,
-        pBCG->red_0,
-        pBCG->red_1);
-
-    FindClosestUNORM(pBCR, theTexelsU);
-    FindClosestUNORM(pBCG, theTexelsV);
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC5S(uint8_t *pBC, const XMVECTOR *pColor, uint32_t flags) noexcept
-{
-    UNREFERENCED_PARAMETER(flags);
-
-    assert(pBC && pColor);
-    static_assert(sizeof(BC4_SNORM) == 8, "BC4_SNORM should be 8 bytes");
-
-    memset(pBC, 0, sizeof(BC4_UNORM) * 2);
-    auto pBCR = reinterpret_cast<BC4_SNORM*>(pBC);
-    auto pBCG = reinterpret_cast<BC4_SNORM*>(pBC + sizeof(BC4_SNORM));
-    float theTexelsU[NUM_PIXELS_PER_BLOCK];
-    float theTexelsV[NUM_PIXELS_PER_BLOCK];
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        XMFLOAT4A clr;
-        XMStoreFloat4A(&clr, pColor[i]);
-        theTexelsU[i] = clr.x;
-        theTexelsV[i] = clr.y;
-    }
-
-    FindEndPointsBC5S(
-        theTexelsU,
-        theTexelsV,
-        pBCR->red_0,
-        pBCR->red_1,
-        pBCG->red_0,
-        pBCG->red_1);
-
-    FindClosestSNORM(pBCR, theTexelsU);
-    FindClosestSNORM(pBCG, theTexelsV);
-}
diff --git a/thirdparty/directxtex/BC6HBC7.cpp b/thirdparty/directxtex/BC6HBC7.cpp
deleted file mode 100644
index 132f86e..0000000
--- a/thirdparty/directxtex/BC6HBC7.cpp
+++ /dev/null
@@ -1,3634 +0,0 @@
-//-------------------------------------------------------------------------------------
-// BC6HBC7.cpp
-//
-// Block-compression (BC) functionality for BC6H and BC7 (DirectX 11 texture compression)
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#include "BC.h"
-
-using namespace DirectX;
-using namespace DirectX::PackedVector;
-
-//-------------------------------------------------------------------------------------
-// Macros
-//-------------------------------------------------------------------------------------
-
-#define SIGN_EXTEND(x,nb) ((((x)&(1<<((nb)-1)))?((~0)^((1<<(nb))-1)):0)|(x))
-
-// Because these are used in SAL annotations, they need to remain macros rather than const values
-#define BC6H_MAX_REGIONS 2
-#define BC6H_MAX_INDICES 16
-#define BC7_MAX_REGIONS 3
-#define BC7_MAX_INDICES 16
-
-namespace
-{
-    //-------------------------------------------------------------------------------------
-    // Constants
-    //-------------------------------------------------------------------------------------
-
-    constexpr uint16_t F16S_MASK = 0x8000;   // f16 sign mask
-    constexpr uint16_t F16EM_MASK = 0x7fff;   // f16 exp & mantissa mask
-    constexpr uint16_t F16MAX = 0x7bff;   // MAXFLT bit pattern for XMHALF
-
-    constexpr size_t BC6H_NUM_CHANNELS = 3;
-    constexpr size_t BC6H_MAX_SHAPES = 32;
-
-    constexpr size_t BC7_NUM_CHANNELS = 4;
-    constexpr size_t BC7_MAX_SHAPES = 64;
-
-    constexpr int32_t BC67_WEIGHT_MAX = 64;
-    constexpr uint32_t BC67_WEIGHT_SHIFT = 6;
-    constexpr int32_t BC67_WEIGHT_ROUND = 32;
-
-    constexpr float fEpsilon = (0.25f / 64.0f) * (0.25f / 64.0f);
-    constexpr float pC3[] = { 2.0f / 2.0f, 1.0f / 2.0f, 0.0f / 2.0f };
-    constexpr float pD3[] = { 0.0f / 2.0f, 1.0f / 2.0f, 2.0f / 2.0f };
-    constexpr float pC4[] = { 3.0f / 3.0f, 2.0f / 3.0f, 1.0f / 3.0f, 0.0f / 3.0f };
-    constexpr float pD4[] = { 0.0f / 3.0f, 1.0f / 3.0f, 2.0f / 3.0f, 3.0f / 3.0f };
-
-    // Partition, Shape, Pixel (index into 4x4 block)
-    const uint8_t g_aPartitionTable[3][64][16] =
-    {
-        {   // 1 Region case has no subsets (all 0)
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
-        },
-
-        {   // BC6H/BC7 Partition Set for 2 Subsets
-            { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 }, // Shape 0
-            { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1 }, // Shape 1
-            { 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 }, // Shape 2
-            { 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1 }, // Shape 3
-            { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1 }, // Shape 4
-            { 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 }, // Shape 5
-            { 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 }, // Shape 6
-            { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1 }, // Shape 7
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1 }, // Shape 8
-            { 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // Shape 9
-            { 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1 }, // Shape 10
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1 }, // Shape 11
-            { 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // Shape 12
-            { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 }, // Shape 13
-            { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // Shape 14
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1 }, // Shape 15
-            { 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1 }, // Shape 16
-            { 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, // Shape 17
-            { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0 }, // Shape 18
-            { 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0 }, // Shape 19
-            { 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, // Shape 20
-            { 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0 }, // Shape 21
-            { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0 }, // Shape 22
-            { 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1 }, // Shape 23
-            { 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 }, // Shape 24
-            { 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0 }, // Shape 25
-            { 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0 }, // Shape 26
-            { 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0 }, // Shape 27
-            { 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0 }, // Shape 28
-            { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 }, // Shape 29
-            { 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0 }, // Shape 30
-            { 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0 }, // Shape 31
-
-                                                                // BC7 Partition Set for 2 Subsets (second-half)
-            { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 }, // Shape 32
-            { 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1 }, // Shape 33
-            { 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0 }, // Shape 34
-            { 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0 }, // Shape 35
-            { 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0 }, // Shape 36
-            { 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0 }, // Shape 37
-            { 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1 }, // Shape 38
-            { 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 }, // Shape 39
-            { 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0 }, // Shape 40
-            { 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0 }, // Shape 41
-            { 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0 }, // Shape 42
-            { 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0 }, // Shape 43
-            { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 }, // Shape 44
-            { 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1 }, // Shape 45
-            { 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1 }, // Shape 46
-            { 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0 }, // Shape 47
-            { 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0 }, // Shape 48
-            { 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 }, // Shape 49
-            { 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0 }, // Shape 50
-            { 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0 }, // Shape 51
-            { 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1 }, // Shape 52
-            { 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1 }, // Shape 53
-            { 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0 }, // Shape 54
-            { 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0 }, // Shape 55
-            { 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1 }, // Shape 56
-            { 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1 }, // Shape 57
-            { 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1 }, // Shape 58
-            { 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1 }, // Shape 59
-            { 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 }, // Shape 60
-            { 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 }, // Shape 61
-            { 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0 }, // Shape 62
-            { 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1 }  // Shape 63
-        },
-
-        {   // BC7 Partition Set for 3 Subsets
-            { 0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 1, 2, 2, 2, 2 }, // Shape 0
-            { 0, 0, 0, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1 }, // Shape 1
-            { 0, 0, 0, 0, 2, 0, 0, 1, 2, 2, 1, 1, 2, 2, 1, 1 }, // Shape 2
-            { 0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 1, 0, 1, 1, 1 }, // Shape 3
-            { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2 }, // Shape 4
-            { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 2, 2 }, // Shape 5
-            { 0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1 }, // Shape 6
-            { 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1 }, // Shape 7
-            { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2 }, // Shape 8
-            { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2 }, // Shape 9
-            { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2 }, // Shape 10
-            { 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2 }, // Shape 11
-            { 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2 }, // Shape 12
-            { 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2 }, // Shape 13
-            { 0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 2 }, // Shape 14
-            { 0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 0 }, // Shape 15
-            { 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2 }, // Shape 16
-            { 0, 1, 1, 1, 0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0 }, // Shape 17
-            { 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2 }, // Shape 18
-            { 0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1 }, // Shape 19
-            { 0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2, 0, 2, 2, 2 }, // Shape 20
-            { 0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 1, 2, 2, 2, 1 }, // Shape 21
-            { 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2 }, // Shape 22
-            { 0, 0, 0, 0, 1, 1, 0, 0, 2, 2, 1, 0, 2, 2, 1, 0 }, // Shape 23
-            { 0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1, 0, 0, 0, 0 }, // Shape 24
-            { 0, 0, 1, 2, 0, 0, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2 }, // Shape 25
-            { 0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1, 0, 1, 1, 0 }, // Shape 26
-            { 0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1 }, // Shape 27
-            { 0, 0, 2, 2, 1, 1, 0, 2, 1, 1, 0, 2, 0, 0, 2, 2 }, // Shape 28
-            { 0, 1, 1, 0, 0, 1, 1, 0, 2, 0, 0, 2, 2, 2, 2, 2 }, // Shape 29
-            { 0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1 }, // Shape 30
-            { 0, 0, 0, 0, 2, 0, 0, 0, 2, 2, 1, 1, 2, 2, 2, 1 }, // Shape 31
-            { 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 2, 2, 2 }, // Shape 32
-            { 0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 2, 0, 0, 1, 1 }, // Shape 33
-            { 0, 0, 1, 1, 0, 0, 1, 2, 0, 0, 2, 2, 0, 2, 2, 2 }, // Shape 34
-            { 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0 }, // Shape 35
-            { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0 }, // Shape 36
-            { 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0 }, // Shape 37
-            { 0, 1, 2, 0, 2, 0, 1, 2, 1, 2, 0, 1, 0, 1, 2, 0 }, // Shape 38
-            { 0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2, 0, 0, 1, 1 }, // Shape 39
-            { 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0, 1, 1 }, // Shape 40
-            { 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2 }, // Shape 41
-            { 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1 }, // Shape 42
-            { 0, 0, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2, 1, 1, 2, 2 }, // Shape 43
-            { 0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 1, 1 }, // Shape 44
-            { 0, 2, 2, 0, 1, 2, 2, 1, 0, 2, 2, 0, 1, 2, 2, 1 }, // Shape 45
-            { 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 0, 1 }, // Shape 46
-            { 0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1 }, // Shape 47
-            { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2 }, // Shape 48
-            { 0, 2, 2, 2, 0, 1, 1, 1, 0, 2, 2, 2, 0, 1, 1, 1 }, // Shape 49
-            { 0, 0, 0, 2, 1, 1, 1, 2, 0, 0, 0, 2, 1, 1, 1, 2 }, // Shape 50
-            { 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2 }, // Shape 51
-            { 0, 2, 2, 2, 0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2 }, // Shape 52
-            { 0, 0, 0, 2, 1, 1, 1, 2, 1, 1, 1, 2, 0, 0, 0, 2 }, // Shape 53
-            { 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2 }, // Shape 54
-            { 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2 }, // Shape 55
-            { 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2 }, // Shape 56
-            { 0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2 }, // Shape 57
-            { 0, 0, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2 }, // Shape 58
-            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2 }, // Shape 59
-            { 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1 }, // Shape 60
-            { 0, 2, 2, 2, 1, 2, 2, 2, 0, 2, 2, 2, 1, 2, 2, 2 }, // Shape 61
-            { 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, // Shape 62
-            { 0, 1, 1, 1, 2, 0, 1, 1, 2, 2, 0, 1, 2, 2, 2, 0 }  // Shape 63
-        }
-    };
-
-    // Partition, Shape, Fixup
-    const uint8_t g_aFixUp[3][64][3] =
-    {
-        {   // No fix-ups for 1st subset for BC6H or BC7
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },
-            { 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 },{ 0, 0, 0 }
-        },
-
-        {   // BC6H/BC7 Partition Set Fixups for 2 Subsets
-            { 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },
-            { 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },
-            { 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },
-            { 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },
-            { 0,15, 0 },{ 0, 2, 0 },{ 0, 8, 0 },{ 0, 2, 0 },
-            { 0, 2, 0 },{ 0, 8, 0 },{ 0, 8, 0 },{ 0,15, 0 },
-            { 0, 2, 0 },{ 0, 8, 0 },{ 0, 2, 0 },{ 0, 2, 0 },
-            { 0, 8, 0 },{ 0, 8, 0 },{ 0, 2, 0 },{ 0, 2, 0 },
-
-            // BC7 Partition Set Fixups for 2 Subsets (second-half)
-            { 0,15, 0 },{ 0,15, 0 },{ 0, 6, 0 },{ 0, 8, 0 },
-            { 0, 2, 0 },{ 0, 8, 0 },{ 0,15, 0 },{ 0,15, 0 },
-            { 0, 2, 0 },{ 0, 8, 0 },{ 0, 2, 0 },{ 0, 2, 0 },
-            { 0, 2, 0 },{ 0,15, 0 },{ 0,15, 0 },{ 0, 6, 0 },
-            { 0, 6, 0 },{ 0, 2, 0 },{ 0, 6, 0 },{ 0, 8, 0 },
-            { 0,15, 0 },{ 0,15, 0 },{ 0, 2, 0 },{ 0, 2, 0 },
-            { 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },{ 0,15, 0 },
-            { 0,15, 0 },{ 0, 2, 0 },{ 0, 2, 0 },{ 0,15, 0 }
-        },
-
-        {   // BC7 Partition Set Fixups for 3 Subsets
-            { 0, 3,15 },{ 0, 3, 8 },{ 0,15, 8 },{ 0,15, 3 },
-            { 0, 8,15 },{ 0, 3,15 },{ 0,15, 3 },{ 0,15, 8 },
-            { 0, 8,15 },{ 0, 8,15 },{ 0, 6,15 },{ 0, 6,15 },
-            { 0, 6,15 },{ 0, 5,15 },{ 0, 3,15 },{ 0, 3, 8 },
-            { 0, 3,15 },{ 0, 3, 8 },{ 0, 8,15 },{ 0,15, 3 },
-            { 0, 3,15 },{ 0, 3, 8 },{ 0, 6,15 },{ 0,10, 8 },
-            { 0, 5, 3 },{ 0, 8,15 },{ 0, 8, 6 },{ 0, 6,10 },
-            { 0, 8,15 },{ 0, 5,15 },{ 0,15,10 },{ 0,15, 8 },
-            { 0, 8,15 },{ 0,15, 3 },{ 0, 3,15 },{ 0, 5,10 },
-            { 0, 6,10 },{ 0,10, 8 },{ 0, 8, 9 },{ 0,15,10 },
-            { 0,15, 6 },{ 0, 3,15 },{ 0,15, 8 },{ 0, 5,15 },
-            { 0,15, 3 },{ 0,15, 6 },{ 0,15, 6 },{ 0,15, 8 },
-            { 0, 3,15 },{ 0,15, 3 },{ 0, 5,15 },{ 0, 5,15 },
-            { 0, 5,15 },{ 0, 8,15 },{ 0, 5,15 },{ 0,10,15 },
-            { 0, 5,15 },{ 0,10,15 },{ 0, 8,15 },{ 0,13,15 },
-            { 0,15, 3 },{ 0,12,15 },{ 0, 3,15 },{ 0, 3, 8 }
-        }
-    };
-
-    const int g_aWeights2[] = { 0, 21, 43, 64 };
-    const int g_aWeights3[] = { 0, 9, 18, 27, 37, 46, 55, 64 };
-    const int g_aWeights4[] = { 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64 };
-}
-
-namespace DirectX
-{
-    class LDRColorA
-    {
-    public:
-        uint8_t r, g, b, a;
-
-        LDRColorA() = default;
-        LDRColorA(uint8_t _r, uint8_t _g, uint8_t _b, uint8_t _a) noexcept : r(_r), g(_g), b(_b), a(_a) {}
-
-        const uint8_t& operator [] (_In_range_(0, 3) size_t uElement) const noexcept
-        {
-            switch (uElement)
-            {
-            case 0: return r;
-            case 1: return g;
-            case 2: return b;
-            case 3: return a;
-            default: assert(false); return r;
-            }
-        }
-
-        uint8_t& operator [] (_In_range_(0, 3) size_t uElement) noexcept
-        {
-            switch (uElement)
-            {
-            case 0: return r;
-            case 1: return g;
-            case 2: return b;
-            case 3: return a;
-            default: assert(false); return r;
-            }
-        }
-
-        LDRColorA operator = (_In_ const HDRColorA& c) noexcept
-        {
-            LDRColorA ret;
-            HDRColorA tmp(c);
-            tmp = tmp.Clamp(0.0f, 1.0f) * 255.0f;
-            ret.r = uint8_t(tmp.r + 0.001f);
-            ret.g = uint8_t(tmp.g + 0.001f);
-            ret.b = uint8_t(tmp.b + 0.001f);
-            ret.a = uint8_t(tmp.a + 0.001f);
-            return ret;
-        }
-
-        static void InterpolateRGB(_In_ const LDRColorA& c0, _In_ const LDRColorA& c1, _In_ size_t wc, _In_ _In_range_(2, 4) size_t wcprec, _Out_ LDRColorA& out) noexcept
-        {
-            const int* aWeights = nullptr;
-            switch (wcprec)
-            {
-            case 2: aWeights = g_aWeights2; assert(wc < 4); _Analysis_assume_(wc < 4); break;
-            case 3: aWeights = g_aWeights3; assert(wc < 8); _Analysis_assume_(wc < 8); break;
-            case 4: aWeights = g_aWeights4; assert(wc < 16); _Analysis_assume_(wc < 16); break;
-            default: assert(false); out.r = out.g = out.b = 0; return;
-            }
-            out.r = uint8_t((uint32_t(c0.r) * uint32_t(BC67_WEIGHT_MAX - aWeights[wc]) + uint32_t(c1.r) * uint32_t(aWeights[wc]) + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT);
-            out.g = uint8_t((uint32_t(c0.g) * uint32_t(BC67_WEIGHT_MAX - aWeights[wc]) + uint32_t(c1.g) * uint32_t(aWeights[wc]) + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT);
-            out.b = uint8_t((uint32_t(c0.b) * uint32_t(BC67_WEIGHT_MAX - aWeights[wc]) + uint32_t(c1.b) * uint32_t(aWeights[wc]) + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT);
-        }
-
-        static void InterpolateA(_In_ const LDRColorA& c0, _In_ const LDRColorA& c1, _In_ size_t wa, _In_range_(2, 4) _In_ size_t waprec, _Out_ LDRColorA& out) noexcept
-        {
-            const int* aWeights = nullptr;
-            switch (waprec)
-            {
-            case 2: aWeights = g_aWeights2; assert(wa < 4); _Analysis_assume_(wa < 4); break;
-            case 3: aWeights = g_aWeights3; assert(wa < 8); _Analysis_assume_(wa < 8); break;
-            case 4: aWeights = g_aWeights4; assert(wa < 16); _Analysis_assume_(wa < 16); break;
-            default: assert(false); out.a = 0; return;
-            }
-            out.a = uint8_t((uint32_t(c0.a) * uint32_t(BC67_WEIGHT_MAX - aWeights[wa]) + uint32_t(c1.a) * uint32_t(aWeights[wa]) + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT);
-        }
-
-        static void Interpolate(_In_ const LDRColorA& c0, _In_ const LDRColorA& c1, _In_ size_t wc, _In_ size_t wa, _In_ _In_range_(2, 4) size_t wcprec, _In_ _In_range_(2, 4) size_t waprec, _Out_ LDRColorA& out) noexcept
-        {
-            InterpolateRGB(c0, c1, wc, wcprec, out);
-            InterpolateA(c0, c1, wa, waprec, out);
-        }
-    };
-
-    static_assert(sizeof(LDRColorA) == 4, "Unexpected packing");
-
-    struct LDREndPntPair
-    {
-        LDRColorA A;
-        LDRColorA B;
-    };
-
-    inline HDRColorA::HDRColorA(const LDRColorA& c) noexcept
-    {
-        r = float(c.r) * (1.0f / 255.0f);
-        g = float(c.g) * (1.0f / 255.0f);
-        b = float(c.b) * (1.0f / 255.0f);
-        a = float(c.a) * (1.0f / 255.0f);
-    }
-
-    inline HDRColorA& HDRColorA::operator = (const LDRColorA& c) noexcept
-    {
-        r = static_cast<float>(c.r);
-        g = static_cast<float>(c.g);
-        b = static_cast<float>(c.b);
-        a = static_cast<float>(c.a);
-        return *this;
-    }
-
-    inline LDRColorA HDRColorA::ToLDRColorA() const noexcept
-    {
-        return LDRColorA(static_cast<uint8_t>(r + 0.01f), static_cast<uint8_t>(g + 0.01f), static_cast<uint8_t>(b + 0.01f), static_cast<uint8_t>(a + 0.01f));
-    }
-}
-
-namespace
-{
-    class INTColor
-    {
-    public:
-        int r, g, b;
-        int pad;
-
-    public:
-        INTColor() = default;
-        INTColor(int nr, int ng, int nb) noexcept : r(nr), g(ng), b(nb), pad(0) {}
-
-        INTColor& operator += (_In_ const INTColor& c) noexcept
-        {
-            r += c.r;
-            g += c.g;
-            b += c.b;
-            return *this;
-        }
-
-        INTColor& operator -= (_In_ const INTColor& c) noexcept
-        {
-            r -= c.r;
-            g -= c.g;
-            b -= c.b;
-            return *this;
-        }
-
-        INTColor& operator &= (_In_ const INTColor& c) noexcept
-        {
-            r &= c.r;
-            g &= c.g;
-            b &= c.b;
-            return *this;
-        }
-
-        int& operator [] (_In_ uint8_t i) noexcept
-        {
-            assert(i < sizeof(INTColor) / sizeof(int));
-            _Analysis_assume_(i < sizeof(INTColor) / sizeof(int));
-            return reinterpret_cast<int*>(this)[i];
-        }
-
-        void Set(_In_ const HDRColorA& c, _In_ bool bSigned) noexcept
-        {
-            PackedVector::XMHALF4 aF16;
-
-            const XMVECTOR v = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(&c));
-            XMStoreHalf4(&aF16, v);
-
-            r = F16ToINT(aF16.x, bSigned);
-            g = F16ToINT(aF16.y, bSigned);
-            b = F16ToINT(aF16.z, bSigned);
-        }
-
-        INTColor& Clamp(_In_ int iMin, _In_ int iMax) noexcept
-        {
-            r = std::min<int>(iMax, std::max<int>(iMin, r));
-            g = std::min<int>(iMax, std::max<int>(iMin, g));
-            b = std::min<int>(iMax, std::max<int>(iMin, b));
-            return *this;
-        }
-
-        INTColor& SignExtend(_In_ const LDRColorA& Prec) noexcept
-        {
-            r = SIGN_EXTEND(r, int(Prec.r));
-            g = SIGN_EXTEND(g, int(Prec.g));
-            b = SIGN_EXTEND(b, int(Prec.b));
-            return *this;
-        }
-
-        void ToF16(_Out_writes_(3) PackedVector::HALF aF16[3], _In_ bool bSigned) const noexcept
-        {
-            aF16[0] = INT2F16(r, bSigned);
-            aF16[1] = INT2F16(g, bSigned);
-            aF16[2] = INT2F16(b, bSigned);
-        }
-
-    private:
-        static int F16ToINT(_In_ const PackedVector::HALF& f, _In_ bool bSigned) noexcept
-        {
-            uint16_t input = *reinterpret_cast<const uint16_t*>(&f);
-            int out, s;
-            if (bSigned)
-            {
-                s = input & F16S_MASK;
-                input &= F16EM_MASK;
-                if (input > F16MAX) out = F16MAX;
-                else out = input;
-                out = s ? -out : out;
-            }
-            else
-            {
-                if (input & F16S_MASK) out = 0;
-                else out = input;
-            }
-            return out;
-        }
-
-        static PackedVector::HALF INT2F16(_In_ int input, _In_ bool bSigned) noexcept
-        {
-            PackedVector::HALF h;
-            uint16_t out;
-            if (bSigned)
-            {
-                int s = 0;
-                if (input < 0)
-                {
-                    s = F16S_MASK;
-                    input = -input;
-                }
-                out = uint16_t(s | input);
-            }
-            else
-            {
-                assert(input >= 0 && input <= F16MAX);
-                out = static_cast<uint16_t>(input);
-            }
-
-            *reinterpret_cast<uint16_t*>(&h) = out;
-            return h;
-        }
-    };
-
-    static_assert(sizeof(INTColor) == 16, "Unexpected packing");
-
-    struct INTEndPntPair
-    {
-        INTColor A;
-        INTColor B;
-    };
-
-    template< size_t SizeInBytes >
-    class CBits
-    {
-    public:
-        uint8_t GetBit(_Inout_ size_t& uStartBit) const noexcept
-        {
-            assert(uStartBit < 128);
-            _Analysis_assume_(uStartBit < 128);
-            const size_t uIndex = uStartBit >> 3;
-            auto const ret = static_cast<uint8_t>((m_uBits[uIndex] >> (uStartBit - (uIndex << 3))) & 0x01);
-            uStartBit++;
-            return ret;
-        }
-
-        uint8_t GetBits(_Inout_ size_t& uStartBit, _In_ size_t uNumBits) const noexcept
-        {
-            if (uNumBits == 0) return 0;
-            assert(uStartBit + uNumBits <= 128 && uNumBits <= 8);
-            _Analysis_assume_(uStartBit + uNumBits <= 128 && uNumBits <= 8);
-            uint8_t ret;
-            const size_t uIndex = uStartBit >> 3;
-            const size_t uBase = uStartBit - (uIndex << 3);
-            if (uBase + uNumBits > 8)
-            {
-                const size_t uFirstIndexBits = 8 - uBase;
-                const size_t uNextIndexBits = uNumBits - uFirstIndexBits;
-                ret = static_cast<uint8_t>((unsigned(m_uBits[uIndex]) >> uBase) | ((unsigned(m_uBits[uIndex + 1]) & ((1u << uNextIndexBits) - 1)) << uFirstIndexBits));
-            }
-            else
-            {
-                ret = static_cast<uint8_t>((m_uBits[uIndex] >> uBase) & ((1 << uNumBits) - 1));
-            }
-            assert(ret < (1 << uNumBits));
-            uStartBit += uNumBits;
-            return ret;
-        }
-
-        void SetBit(_Inout_ size_t& uStartBit, _In_ uint8_t uValue) noexcept
-        {
-            assert(uStartBit < 128 && uValue < 2);
-            _Analysis_assume_(uStartBit < 128 && uValue < 2);
-            size_t uIndex = uStartBit >> 3;
-            const size_t uBase = uStartBit - (uIndex << 3);
-            m_uBits[uIndex] &= ~(1 << uBase);
-            m_uBits[uIndex] |= uValue << uBase;
-            uStartBit++;
-        }
-
-        void SetBits(_Inout_ size_t& uStartBit, _In_ size_t uNumBits, _In_ uint8_t uValue) noexcept
-        {
-            if (uNumBits == 0)
-                return;
-            assert(uStartBit + uNumBits <= 128 && uNumBits <= 8);
-            _Analysis_assume_(uStartBit + uNumBits <= 128 && uNumBits <= 8);
-            assert(uValue < (1 << uNumBits));
-            size_t uIndex = uStartBit >> 3;
-            const size_t uBase = uStartBit - (uIndex << 3);
-            if (uBase + uNumBits > 8)
-            {
-                const size_t uFirstIndexBits = 8 - uBase;
-                const size_t uNextIndexBits = uNumBits - uFirstIndexBits;
-                m_uBits[uIndex] &= ~(((1 << uFirstIndexBits) - 1) << uBase);
-                m_uBits[uIndex] |= uValue << uBase;
-                m_uBits[uIndex + 1] &= ~((1 << uNextIndexBits) - 1);
-                m_uBits[uIndex + 1] |= uValue >> uFirstIndexBits;
-            }
-            else
-            {
-                m_uBits[uIndex] &= ~(((1 << uNumBits) - 1) << uBase);
-                m_uBits[uIndex] |= uValue << uBase;
-            }
-            uStartBit += uNumBits;
-        }
-
-    private:
-        uint8_t m_uBits[SizeInBytes];
-    };
-
-    // BC6H compression (16 bits per texel)
-    class D3DX_BC6H : private CBits< 16 >
-    {
-    public:
-        void Decode(_In_ bool bSigned, _Out_writes_(NUM_PIXELS_PER_BLOCK) HDRColorA* pOut) const noexcept;
-        void Encode(_In_ bool bSigned, _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA* const pIn) noexcept;
-
-    private:
-    #pragma warning(push)
-    #pragma warning(disable : 4480)
-        enum EField : uint8_t
-        {
-            NA, // N/A
-            M,  // Mode
-            D,  // Shape
-            RW,
-            RX,
-            RY,
-            RZ,
-            GW,
-            GX,
-            GY,
-            GZ,
-            BW,
-            BX,
-            BY,
-            BZ,
-        };
-    #pragma warning(pop)
-
-        struct ModeDescriptor
-        {
-            EField m_eField;
-            uint8_t   m_uBit;
-        };
-
-        struct ModeInfo
-        {
-            uint8_t uMode;
-            uint8_t uPartitions;
-            bool bTransformed;
-            uint8_t uIndexPrec;
-            LDRColorA RGBAPrec[BC6H_MAX_REGIONS][2];
-        };
-
-    #pragma warning(push)
-    #pragma warning(disable : 4512)
-        struct EncodeParams
-        {
-            float fBestErr;
-            const bool bSigned;
-            uint8_t uMode;
-            uint8_t uShape;
-            const HDRColorA* const aHDRPixels;
-            INTEndPntPair aUnqEndPts[BC6H_MAX_SHAPES][BC6H_MAX_REGIONS];
-            INTColor aIPixels[NUM_PIXELS_PER_BLOCK];
-
-            EncodeParams(const HDRColorA* const aOriginal, bool bSignedFormat) noexcept :
-                fBestErr(FLT_MAX), bSigned(bSignedFormat), uMode(0), uShape(0), aHDRPixels(aOriginal), aUnqEndPts{}, aIPixels{}
-            {
-                for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-                {
-                    aIPixels[i].Set(aOriginal[i], bSigned);
-                }
-            }
-        };
-    #pragma warning(pop)
-
-        static int Quantize(_In_ int iValue, _In_ int prec, _In_ bool bSigned) noexcept;
-        static int Unquantize(_In_ int comp, _In_ uint8_t uBitsPerComp, _In_ bool bSigned) noexcept;
-        static int FinishUnquantize(_In_ int comp, _In_ bool bSigned) noexcept;
-
-        static bool EndPointsFit(_In_ const EncodeParams* pEP, _In_reads_(BC6H_MAX_REGIONS) const INTEndPntPair aEndPts[]) noexcept;
-
-        void GeneratePaletteQuantized(_In_ const EncodeParams* pEP, _In_ const INTEndPntPair& endPts,
-            _Out_writes_(BC6H_MAX_INDICES) INTColor aPalette[]) const noexcept;
-        float MapColorsQuantized(_In_ const EncodeParams* pEP, _In_reads_(np) const INTColor aColors[], _In_ size_t np, _In_ const INTEndPntPair &endPts) const noexcept;
-        float PerturbOne(_In_ const EncodeParams* pEP, _In_reads_(np) const INTColor aColors[], _In_ size_t np, _In_ uint8_t ch,
-            _In_ const INTEndPntPair& oldEndPts, _Out_ INTEndPntPair& newEndPts, _In_ float fOldErr, _In_ int do_b) const noexcept;
-        void OptimizeOne(_In_ const EncodeParams* pEP, _In_reads_(np) const INTColor aColors[], _In_ size_t np, _In_ float aOrgErr,
-            _In_ const INTEndPntPair &aOrgEndPts, _Out_ INTEndPntPair &aOptEndPts) const noexcept;
-        void OptimizeEndPoints(_In_ const EncodeParams* pEP, _In_reads_(BC6H_MAX_REGIONS) const float aOrgErr[],
-            _In_reads_(BC6H_MAX_REGIONS) const INTEndPntPair aOrgEndPts[],
-            _Out_writes_all_(BC6H_MAX_REGIONS) INTEndPntPair aOptEndPts[]) const noexcept;
-        static void SwapIndices(_In_ const EncodeParams* pEP, _Inout_updates_all_(BC6H_MAX_REGIONS) INTEndPntPair aEndPts[],
-            _In_reads_(NUM_PIXELS_PER_BLOCK) size_t aIndices[]) noexcept;
-        void AssignIndices(_In_ const EncodeParams* pEP, _In_reads_(BC6H_MAX_REGIONS) const INTEndPntPair aEndPts[],
-            _Out_writes_(NUM_PIXELS_PER_BLOCK) size_t aIndices[],
-            _Out_writes_(BC6H_MAX_REGIONS) float aTotErr[]) const noexcept;
-        void QuantizeEndPts(_In_ const EncodeParams* pEP, _Out_writes_(BC6H_MAX_REGIONS) INTEndPntPair* qQntEndPts) const noexcept;
-        void EmitBlock(_In_ const EncodeParams* pEP, _In_reads_(BC6H_MAX_REGIONS) const INTEndPntPair aEndPts[],
-            _In_reads_(NUM_PIXELS_PER_BLOCK) const size_t aIndices[]) noexcept;
-        void Refine(_Inout_ EncodeParams* pEP) noexcept;
-
-        static void GeneratePaletteUnquantized(_In_ const EncodeParams* pEP, _In_ size_t uRegion, _Out_writes_(BC6H_MAX_INDICES) INTColor aPalette[]) noexcept;
-        float MapColors(_In_ const EncodeParams* pEP, _In_ size_t uRegion, _In_ size_t np, _In_reads_(np) const size_t* auIndex) const noexcept;
-        float RoughMSE(_Inout_ EncodeParams* pEP) const noexcept;
-
-    private:
-        static constexpr uint8_t c_NumModes = 14;
-        static constexpr uint8_t c_NumModeInfo = 32;
-
-        static const ModeDescriptor ms_aDesc[c_NumModes][82];
-        static const ModeInfo ms_aInfo[c_NumModes];
-        static const int ms_aModeToInfo[c_NumModeInfo];
-    };
-
-    // BC67 compression (16b bits per texel)
-    class D3DX_BC7 : private CBits< 16 >
-    {
-    public:
-        void Decode(_Out_writes_(NUM_PIXELS_PER_BLOCK) HDRColorA* pOut) const noexcept;
-        void Encode(uint32_t flags, _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA* const pIn) noexcept;
-
-    private:
-        struct ModeInfo
-        {
-            uint8_t uPartitions;
-            uint8_t uPartitionBits;
-            uint8_t uPBits;
-            uint8_t uRotationBits;
-            uint8_t uIndexModeBits;
-            uint8_t uIndexPrec;
-            uint8_t uIndexPrec2;
-            LDRColorA RGBAPrec;
-            LDRColorA RGBAPrecWithP;
-        };
-
-    #pragma warning(push)
-    #pragma warning(disable : 4512)
-        struct EncodeParams
-        {
-            uint8_t uMode;
-            LDREndPntPair aEndPts[BC7_MAX_SHAPES][BC7_MAX_REGIONS];
-            LDRColorA aLDRPixels[NUM_PIXELS_PER_BLOCK];
-            const HDRColorA* const aHDRPixels;
-
-            EncodeParams(const HDRColorA* const aOriginal) noexcept : uMode(0), aEndPts{}, aLDRPixels{}, aHDRPixels(aOriginal) {}
-        };
-    #pragma warning(pop)
-
-        static uint8_t Quantize(_In_ uint8_t comp, _In_ uint8_t uPrec) noexcept
-        {
-            assert(0 < uPrec && uPrec <= 8);
-            const uint8_t rnd = std::min<uint8_t>(255u, static_cast<uint8_t>(unsigned(comp) + (1u << (7 - uPrec))));
-            return uint8_t(rnd >> (8u - uPrec));
-        }
-
-        static LDRColorA Quantize(_In_ const LDRColorA& c, _In_ const LDRColorA& RGBAPrec) noexcept
-        {
-            LDRColorA q;
-            q.r = Quantize(c.r, RGBAPrec.r);
-            q.g = Quantize(c.g, RGBAPrec.g);
-            q.b = Quantize(c.b, RGBAPrec.b);
-            if (RGBAPrec.a)
-                q.a = Quantize(c.a, RGBAPrec.a);
-            else
-                q.a = 255;
-            return q;
-        }
-
-        static uint8_t Unquantize(_In_ uint8_t comp, _In_ size_t uPrec) noexcept
-        {
-            assert(0 < uPrec && uPrec <= 8);
-            comp = static_cast<uint8_t>(unsigned(comp) << (8 - uPrec));
-            return uint8_t(comp | (comp >> uPrec));
-        }
-
-        static LDRColorA Unquantize(_In_ const LDRColorA& c, _In_ const LDRColorA& RGBAPrec) noexcept
-        {
-            LDRColorA q;
-            q.r = Unquantize(c.r, RGBAPrec.r);
-            q.g = Unquantize(c.g, RGBAPrec.g);
-            q.b = Unquantize(c.b, RGBAPrec.b);
-            q.a = RGBAPrec.a > 0 ? Unquantize(c.a, RGBAPrec.a) : 255u;
-            return q;
-        }
-
-        void GeneratePaletteQuantized(_In_ const EncodeParams* pEP, _In_ size_t uIndexMode, _In_ const LDREndPntPair& endpts,
-            _Out_writes_(BC7_MAX_INDICES) LDRColorA aPalette[]) const noexcept;
-        float PerturbOne(_In_ const EncodeParams* pEP, _In_reads_(np) const LDRColorA colors[], _In_ size_t np, _In_ size_t uIndexMode,
-            _In_ size_t ch, _In_ const LDREndPntPair &old_endpts,
-            _Out_ LDREndPntPair &new_endpts, _In_ float old_err, _In_ uint8_t do_b) const noexcept;
-        void Exhaustive(_In_ const EncodeParams* pEP, _In_reads_(np) const LDRColorA aColors[], _In_ size_t np, _In_ size_t uIndexMode,
-            _In_ size_t ch, _Inout_ float& fOrgErr, _Inout_ LDREndPntPair& optEndPt) const noexcept;
-        void OptimizeOne(_In_ const EncodeParams* pEP, _In_reads_(np) const LDRColorA colors[], _In_ size_t np, _In_ size_t uIndexMode,
-            _In_ float orig_err, _In_ const LDREndPntPair &orig_endpts, _Out_ LDREndPntPair &opt_endpts) const noexcept;
-        void OptimizeEndPoints(_In_ const EncodeParams* pEP, _In_ size_t uShape, _In_ size_t uIndexMode,
-            _In_reads_(BC7_MAX_REGIONS) const float orig_err[],
-            _In_reads_(BC7_MAX_REGIONS) const LDREndPntPair orig_endpts[],
-            _Out_writes_(BC7_MAX_REGIONS) LDREndPntPair opt_endpts[]) const noexcept;
-        void AssignIndices(_In_ const EncodeParams* pEP, _In_ size_t uShape, _In_ size_t uIndexMode,
-            _In_reads_(BC7_MAX_REGIONS) LDREndPntPair endpts[],
-            _Out_writes_(NUM_PIXELS_PER_BLOCK) size_t aIndices[], _Out_writes_(NUM_PIXELS_PER_BLOCK) size_t aIndices2[],
-            _Out_writes_(BC7_MAX_REGIONS) float afTotErr[]) const noexcept;
-        void EmitBlock(_In_ const EncodeParams* pEP, _In_ size_t uShape, _In_ size_t uRotation, _In_ size_t uIndexMode,
-            _In_reads_(BC7_MAX_REGIONS) const LDREndPntPair aEndPts[],
-            _In_reads_(NUM_PIXELS_PER_BLOCK) const size_t aIndex[],
-            _In_reads_(NUM_PIXELS_PER_BLOCK) const size_t aIndex2[]) noexcept;
-        void FixEndpointPBits(_In_ const EncodeParams* pEP, _In_reads_(BC7_MAX_REGIONS) const LDREndPntPair *pOrigEndpoints, _Out_writes_(BC7_MAX_REGIONS) LDREndPntPair *pFixedEndpoints) noexcept;
-        float Refine(_In_ const EncodeParams* pEP, _In_ size_t uShape, _In_ size_t uRotation, _In_ size_t uIndexMode) noexcept;
-
-        float MapColors(_In_ const EncodeParams* pEP, _In_reads_(np) const LDRColorA aColors[], _In_ size_t np, _In_ size_t uIndexMode,
-            _In_ const LDREndPntPair& endPts, _In_ float fMinErr) const noexcept;
-        static float RoughMSE(_Inout_ EncodeParams* pEP, _In_ size_t uShape, _In_ size_t uIndexMode) noexcept;
-
-    private:
-        static constexpr uint8_t c_NumModes = 8;
-
-        static const ModeInfo ms_aInfo[c_NumModes];
-    };
-}
-
-// BC6H Compression
-const D3DX_BC6H::ModeDescriptor D3DX_BC6H::ms_aDesc[D3DX_BC6H::c_NumModes][82] =
-{
-    {   // Mode 1 (0x00) - 10 5 5 5
-        { M, 0}, { M, 1}, {GY, 4}, {BY, 4}, {BZ, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {RW, 8}, {RW, 9}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GW, 8}, {GW, 9}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BW, 8}, {BW, 9}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {GZ, 4}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {BZ, 0}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BZ, 1}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {RY, 4},
-        {BZ, 2}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {RZ, 4}, {BZ, 3}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 2 (0x01) - 7 6 6 6
-        { M, 0}, { M, 1}, {GY, 5}, {GZ, 4}, {GZ, 5}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {BZ, 0}, {BZ, 1}, {BY, 4}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {BY, 5}, {BZ, 2}, {GY, 4}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BZ, 3}, {BZ, 5}, {BZ, 4}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {RX, 5}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {GX, 5}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BX, 5}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {RY, 4},
-        {RY, 5}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {RZ, 4}, {RZ, 5}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 3 (0x02) - 11 5 4 4
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {RW, 8}, {RW, 9}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GW, 8}, {GW, 9}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BW, 8}, {BW, 9}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {RW,10}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GW,10},
-        {BZ, 0}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BW,10},
-        {BZ, 1}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {RY, 4},
-        {BZ, 2}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {RZ, 4}, {BZ, 3}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 4 (0x06) - 11 4 5 4
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {RW, 8}, {RW, 9}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GW, 8}, {GW, 9}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BW, 8}, {BW, 9}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RW,10},
-        {GZ, 4}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {GW,10}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BW,10},
-        {BZ, 1}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {BZ, 0},
-        {BZ, 2}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {GY, 4}, {BZ, 3}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 5 (0x0a) - 11 4 4 5
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {RW, 8}, {RW, 9}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GW, 8}, {GW, 9}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BW, 8}, {BW, 9}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RW,10},
-        {BY, 4}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GW,10},
-        {BZ, 0}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BW,10}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {BZ, 1},
-        {BZ, 2}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {BZ, 4}, {BZ, 3}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 6 (0x0e) - 9 5 5 5
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {RW, 8}, {BY, 4}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GW, 8}, {GY, 4}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BW, 8}, {BZ, 4}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {GZ, 4}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {BZ, 0}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BZ, 1}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {RY, 4},
-        {BZ, 2}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {RZ, 4}, {BZ, 3}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 7 (0x12) - 8 6 5 5
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {GZ, 4}, {BY, 4}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {BZ, 2}, {GY, 4}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BZ, 3}, {BZ, 4}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {RX, 5}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {BZ, 0}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BZ, 1}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {RY, 4},
-        {RY, 5}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {RZ, 4}, {RZ, 5}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 8 (0x16) - 8 5 6 5
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {BZ, 0}, {BY, 4}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GY, 5}, {GY, 4}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {GZ, 5}, {BZ, 4}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {GZ, 4}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {GX, 5}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BZ, 1}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {RY, 4},
-        {BZ, 2}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {RZ, 4}, {BZ, 3}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 9 (0x1a) - 8 5 5 6
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {BZ, 1}, {BY, 4}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {BY, 5}, {GY, 4}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BZ, 5}, {BZ, 4}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {GZ, 4}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {BZ, 0}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BX, 5}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {RY, 4},
-        {BZ, 2}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {RZ, 4}, {BZ, 3}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 10 (0x1e) - 6 6 6 6
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {GZ, 4}, {BZ, 0}, {BZ, 1}, {BY, 4}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GY, 5}, {BY, 5}, {BZ, 2}, {GY, 4}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {GZ, 5}, {BZ, 3}, {BZ, 5}, {BZ, 4}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {RX, 5}, {GY, 0}, {GY, 1}, {GY, 2}, {GY, 3}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {GX, 5}, {GZ, 0}, {GZ, 1}, {GZ, 2}, {GZ, 3}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BX, 5}, {BY, 0}, {BY, 1}, {BY, 2}, {BY, 3}, {RY, 0}, {RY, 1}, {RY, 2}, {RY, 3}, {RY, 4},
-        {RY, 5}, {RZ, 0}, {RZ, 1}, {RZ, 2}, {RZ, 3}, {RZ, 4}, {RZ, 5}, { D, 0}, { D, 1}, { D, 2},
-        { D, 3}, { D, 4},
-    },
-
-    {   // Mode 11 (0x03) - 10 10
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {RW, 8}, {RW, 9}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GW, 8}, {GW, 9}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BW, 8}, {BW, 9}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {RX, 5}, {RX, 6}, {RX, 7}, {RX, 8}, {RX, 9}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {GX, 5}, {GX, 6}, {GX, 7}, {GX, 8}, {GX, 9}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BX, 5}, {BX, 6}, {BX, 7}, {BX, 8}, {BX, 9}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0},
-        {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0},
-        {NA, 0}, {NA, 0},
-    },
-
-    {   // Mode 12 (0x07) - 11 9
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {RW, 8}, {RW, 9}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GW, 8}, {GW, 9}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BW, 8}, {BW, 9}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {RX, 5}, {RX, 6}, {RX, 7}, {RX, 8}, {RW,10}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {GX, 5}, {GX, 6}, {GX, 7}, {GX, 8}, {GW,10}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BX, 5}, {BX, 6}, {BX, 7}, {BX, 8}, {BW,10}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0},
-        {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0},
-        {NA, 0}, {NA, 0},
-    },
-
-    {   // Mode 13 (0x0b) - 12 8
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {RW, 8}, {RW, 9}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GW, 8}, {GW, 9}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BW, 8}, {BW, 9}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RX, 4},
-        {RX, 5}, {RX, 6}, {RX, 7}, {RW,11}, {RW,10}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GX, 4},
-        {GX, 5}, {GX, 6}, {GX, 7}, {GW,11}, {GW,10}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BX, 4},
-        {BX, 5}, {BX, 6}, {BX, 7}, {BW,11}, {BW,10}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0},
-        {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0},
-        {NA, 0}, {NA, 0},
-    },
-
-    {   // Mode 14 (0x0f) - 16 4
-        { M, 0}, { M, 1}, { M, 2}, { M, 3}, { M, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
-        {RW, 5}, {RW, 6}, {RW, 7}, {RW, 8}, {RW, 9}, {GW, 0}, {GW, 1}, {GW, 2}, {GW, 3}, {GW, 4},
-        {GW, 5}, {GW, 6}, {GW, 7}, {GW, 8}, {GW, 9}, {BW, 0}, {BW, 1}, {BW, 2}, {BW, 3}, {BW, 4},
-        {BW, 5}, {BW, 6}, {BW, 7}, {BW, 8}, {BW, 9}, {RX, 0}, {RX, 1}, {RX, 2}, {RX, 3}, {RW,15},
-        {RW,14}, {RW,13}, {RW,12}, {RW,11}, {RW,10}, {GX, 0}, {GX, 1}, {GX, 2}, {GX, 3}, {GW,15},
-        {GW,14}, {GW,13}, {GW,12}, {GW,11}, {GW,10}, {BX, 0}, {BX, 1}, {BX, 2}, {BX, 3}, {BW,15},
-        {BW,14}, {BW,13}, {BW,12}, {BW,11}, {BW,10}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0},
-        {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0}, {NA, 0},
-        {NA, 0}, {NA, 0},
-    },
-};
-
-// Mode, Partitions, Transformed, IndexPrec, RGBAPrec
-const D3DX_BC6H::ModeInfo D3DX_BC6H::ms_aInfo[D3DX_BC6H::c_NumModes] =
-{
-    {0x00, 1, true,  3, { { LDRColorA(10,10,10,0), LDRColorA(5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 1
-    {0x01, 1, true,  3, { { LDRColorA(7, 7, 7,0), LDRColorA(6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 2
-    {0x02, 1, true,  3, { { LDRColorA(11,11,11,0), LDRColorA(5, 4, 4,0) }, { LDRColorA(5,4,4,0), LDRColorA(5,4,4,0) } } }, // Mode 3
-    {0x06, 1, true,  3, { { LDRColorA(11,11,11,0), LDRColorA(4, 5, 4,0) }, { LDRColorA(4,5,4,0), LDRColorA(4,5,4,0) } } }, // Mode 4
-    {0x0a, 1, true,  3, { { LDRColorA(11,11,11,0), LDRColorA(4, 4, 5,0) }, { LDRColorA(4,4,5,0), LDRColorA(4,4,5,0) } } }, // Mode 5
-    {0x0e, 1, true,  3, { { LDRColorA(9, 9, 9,0), LDRColorA(5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 6
-    {0x12, 1, true,  3, { { LDRColorA(8, 8, 8,0), LDRColorA(6, 5, 5,0) }, { LDRColorA(6,5,5,0), LDRColorA(6,5,5,0) } } }, // Mode 7
-    {0x16, 1, true,  3, { { LDRColorA(8, 8, 8,0), LDRColorA(5, 6, 5,0) }, { LDRColorA(5,6,5,0), LDRColorA(5,6,5,0) } } }, // Mode 8
-    {0x1a, 1, true,  3, { { LDRColorA(8, 8, 8,0), LDRColorA(5, 5, 6,0) }, { LDRColorA(5,5,6,0), LDRColorA(5,5,6,0) } } }, // Mode 9
-    {0x1e, 1, false, 3, { { LDRColorA(6, 6, 6,0), LDRColorA(6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 10
-    {0x03, 0, false, 4, { { LDRColorA(10,10,10,0), LDRColorA(10,10,10,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 11
-    {0x07, 0, true,  4, { { LDRColorA(11,11,11,0), LDRColorA(9, 9, 9,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 12
-    {0x0b, 0, true,  4, { { LDRColorA(12,12,12,0), LDRColorA(8, 8, 8,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 13
-    {0x0f, 0, true,  4, { { LDRColorA(16,16,16,0), LDRColorA(4, 4, 4,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 14
-};
-
-const int D3DX_BC6H::ms_aModeToInfo[D3DX_BC6H::c_NumModeInfo] =
-{
-     0, // Mode 1   - 0x00
-     1, // Mode 2   - 0x01
-     2, // Mode 3   - 0x02
-    10, // Mode 11  - 0x03
-    -1, // Invalid  - 0x04
-    -1, // Invalid  - 0x05
-     3, // Mode 4   - 0x06
-    11, // Mode 12  - 0x07
-    -1, // Invalid  - 0x08
-    -1, // Invalid  - 0x09
-     4, // Mode 5   - 0x0a
-    12, // Mode 13  - 0x0b
-    -1, // Invalid  - 0x0c
-    -1, // Invalid  - 0x0d
-     5, // Mode 6   - 0x0e
-    13, // Mode 14  - 0x0f
-    -1, // Invalid  - 0x10
-    -1, // Invalid  - 0x11
-     6, // Mode 7   - 0x12
-    -1, // Reserved - 0x13
-    -1, // Invalid  - 0x14
-    -1, // Invalid  - 0x15
-     7, // Mode 8   - 0x16
-    -1, // Reserved - 0x17
-    -1, // Invalid  - 0x18
-    -1, // Invalid  - 0x19
-     8, // Mode 9   - 0x1a
-    -1, // Reserved - 0x1b
-    -1, // Invalid  - 0x1c
-    -1, // Invalid  - 0x1d
-     9, // Mode 10  - 0x1e
-    -1, // Resreved - 0x1f
-};
-
-// BC7 compression: uPartitions, uPartitionBits, uPBits, uRotationBits, uIndexModeBits, uIndexPrec, uIndexPrec2, RGBAPrec, RGBAPrecWithP
-const D3DX_BC7::ModeInfo D3DX_BC7::ms_aInfo[D3DX_BC7::c_NumModes] =
-{
-    {2, 4, 6, 0, 0, 3, 0, LDRColorA(4,4,4,0), LDRColorA(5,5,5,0)},
-        // Mode 0: Color only, 3 Subsets, RGBP 4441 (unique P-bit), 3-bit indecies, 16 partitions
-    {1, 6, 2, 0, 0, 3, 0, LDRColorA(6,6,6,0), LDRColorA(7,7,7,0)},
-        // Mode 1: Color only, 2 Subsets, RGBP 6661 (shared P-bit), 3-bit indecies, 64 partitions
-    {2, 6, 0, 0, 0, 2, 0, LDRColorA(5,5,5,0), LDRColorA(5,5,5,0)},
-        // Mode 2: Color only, 3 Subsets, RGB 555, 2-bit indecies, 64 partitions
-    {1, 6, 4, 0, 0, 2, 0, LDRColorA(7,7,7,0), LDRColorA(8,8,8,0)},
-        // Mode 3: Color only, 2 Subsets, RGBP 7771 (unique P-bit), 2-bits indecies, 64 partitions
-    {0, 0, 0, 2, 1, 2, 3, LDRColorA(5,5,5,6), LDRColorA(5,5,5,6)},
-        // Mode 4: Color w/ Separate Alpha, 1 Subset, RGB 555, A6, 16x2/16x3-bit indices, 2-bit rotation, 1-bit index selector
-    {0, 0, 0, 2, 0, 2, 2, LDRColorA(7,7,7,8), LDRColorA(7,7,7,8)},
-        // Mode 5: Color w/ Separate Alpha, 1 Subset, RGB 777, A8, 16x2/16x2-bit indices, 2-bit rotation
-    {0, 0, 2, 0, 0, 4, 0, LDRColorA(7,7,7,7), LDRColorA(8,8,8,8)},
-        // Mode 6: Color+Alpha, 1 Subset, RGBAP 77771 (unique P-bit), 16x4-bit indecies
-    {1, 6, 4, 0, 0, 2, 0, LDRColorA(5,5,5,5), LDRColorA(6,6,6,6)}
-        // Mode 7: Color+Alpha, 2 Subsets, RGBAP 55551 (unique P-bit), 2-bit indices, 64 partitions
-};
-
-
-namespace
-{
-    //-------------------------------------------------------------------------------------
-    // Helper functions
-    //-------------------------------------------------------------------------------------
-    inline bool IsFixUpOffset(_In_range_(0, 2) size_t uPartitions, _In_range_(0, 63) size_t uShape, _In_range_(0, 15) size_t uOffset) noexcept
-    {
-        assert(uPartitions < 3 && uShape < 64 && uOffset < 16);
-        _Analysis_assume_(uPartitions < 3 && uShape < 64 && uOffset < 16);
-        for (size_t p = 0; p <= uPartitions; p++)
-        {
-            if (uOffset == g_aFixUp[uPartitions][uShape][p])
-            {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    inline void TransformForward(_Inout_updates_all_(BC6H_MAX_REGIONS) INTEndPntPair aEndPts[]) noexcept
-    {
-        aEndPts[0].B -= aEndPts[0].A;
-        aEndPts[1].A -= aEndPts[0].A;
-        aEndPts[1].B -= aEndPts[0].A;
-    }
-
-    inline void TransformInverse(_Inout_updates_all_(BC6H_MAX_REGIONS) INTEndPntPair aEndPts[], _In_ const LDRColorA& Prec, _In_ bool bSigned) noexcept
-    {
-        const INTColor WrapMask((1 << Prec.r) - 1, (1 << Prec.g) - 1, (1 << Prec.b) - 1);
-        aEndPts[0].B += aEndPts[0].A; aEndPts[0].B &= WrapMask;
-        aEndPts[1].A += aEndPts[0].A; aEndPts[1].A &= WrapMask;
-        aEndPts[1].B += aEndPts[0].A; aEndPts[1].B &= WrapMask;
-        if (bSigned)
-        {
-            aEndPts[0].B.SignExtend(Prec);
-            aEndPts[1].A.SignExtend(Prec);
-            aEndPts[1].B.SignExtend(Prec);
-        }
-    }
-
-    inline float Norm(_In_ const INTColor& a, _In_ const INTColor& b) noexcept
-    {
-        const float dr = float(a.r) - float(b.r);
-        const float dg = float(a.g) - float(b.g);
-        const float db = float(a.b) - float(b.b);
-        return dr * dr + dg * dg + db * db;
-    }
-
-    // return # of bits needed to store n. handle signed or unsigned cases properly
-    inline int NBits(_In_ int n, _In_ bool bIsSigned) noexcept
-    {
-        int nb;
-        if (n == 0)
-        {
-            return 0;	// no bits needed for 0, signed or not
-        }
-        else if (n > 0)
-        {
-            for (nb = 0; n; ++nb, n >>= 1);
-            return nb + (bIsSigned ? 1 : 0);
-        }
-        else
-        {
-            assert(bIsSigned);
-            for (nb = 0; n < -1; ++nb, n >>= 1);
-            return nb + 1;
-        }
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    float OptimizeRGB(
-        _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA* const pPoints,
-        _Out_ HDRColorA* pX,
-        _Out_ HDRColorA* pY,
-        _In_range_(3, 4) uint32_t cSteps,
-        size_t cPixels,
-        _In_reads_(cPixels) const size_t* pIndex) noexcept
-    {
-        constexpr float fError = FLT_MAX;
-        const float *pC = (3 == cSteps) ? pC3 : pC4;
-        const float *pD = (3 == cSteps) ? pD3 : pD4;
-
-        // Find Min and Max points, as starting point
-        HDRColorA X(FLT_MAX, FLT_MAX, FLT_MAX, 0.0f);
-        HDRColorA Y(-FLT_MAX, -FLT_MAX, -FLT_MAX, 0.0f);
-
-        for (size_t iPoint = 0; iPoint < cPixels; iPoint++)
-        {
-            if (pPoints[pIndex[iPoint]].r < X.r) X.r = pPoints[pIndex[iPoint]].r;
-            if (pPoints[pIndex[iPoint]].g < X.g) X.g = pPoints[pIndex[iPoint]].g;
-            if (pPoints[pIndex[iPoint]].b < X.b) X.b = pPoints[pIndex[iPoint]].b;
-            if (pPoints[pIndex[iPoint]].r > Y.r) Y.r = pPoints[pIndex[iPoint]].r;
-            if (pPoints[pIndex[iPoint]].g > Y.g) Y.g = pPoints[pIndex[iPoint]].g;
-            if (pPoints[pIndex[iPoint]].b > Y.b) Y.b = pPoints[pIndex[iPoint]].b;
-        }
-
-        // Diagonal axis
-        HDRColorA AB;
-        AB.r = Y.r - X.r;
-        AB.g = Y.g - X.g;
-        AB.b = Y.b - X.b;
-
-        const float fAB = AB.r * AB.r + AB.g * AB.g + AB.b * AB.b;
-
-        // Single color block.. no need to root-find
-        if (fAB < FLT_MIN)
-        {
-            pX->r = X.r; pX->g = X.g; pX->b = X.b;
-            pY->r = Y.r; pY->g = Y.g; pY->b = Y.b;
-            return 0.0f;
-        }
-
-        // Try all four axis directions, to determine which diagonal best fits data
-        const float fABInv = 1.0f / fAB;
-
-        HDRColorA Dir;
-        Dir.r = AB.r * fABInv;
-        Dir.g = AB.g * fABInv;
-        Dir.b = AB.b * fABInv;
-
-        HDRColorA Mid;
-        Mid.r = (X.r + Y.r) * 0.5f;
-        Mid.g = (X.g + Y.g) * 0.5f;
-        Mid.b = (X.b + Y.b) * 0.5f;
-
-        float fDir[4];
-        fDir[0] = fDir[1] = fDir[2] = fDir[3] = 0.0f;
-
-        for (size_t iPoint = 0; iPoint < cPixels; iPoint++)
-        {
-            HDRColorA Pt;
-            Pt.r = (pPoints[pIndex[iPoint]].r - Mid.r) * Dir.r;
-            Pt.g = (pPoints[pIndex[iPoint]].g - Mid.g) * Dir.g;
-            Pt.b = (pPoints[pIndex[iPoint]].b - Mid.b) * Dir.b;
-
-            float f;
-            f = Pt.r + Pt.g + Pt.b; fDir[0] += f * f;
-            f = Pt.r + Pt.g - Pt.b; fDir[1] += f * f;
-            f = Pt.r - Pt.g + Pt.b; fDir[2] += f * f;
-            f = Pt.r - Pt.g - Pt.b; fDir[3] += f * f;
-        }
-
-        float fDirMax = fDir[0];
-        size_t  iDirMax = 0;
-
-        for (size_t iDir = 1; iDir < 4; iDir++)
-        {
-            if (fDir[iDir] > fDirMax)
-            {
-                fDirMax = fDir[iDir];
-                iDirMax = iDir;
-            }
-        }
-
-        if (iDirMax & 2) std::swap(X.g, Y.g);
-        if (iDirMax & 1) std::swap(X.b, Y.b);
-
-        // Two color block.. no need to root-find
-        if (fAB < 1.0f / 4096.0f)
-        {
-            pX->r = X.r; pX->g = X.g; pX->b = X.b;
-            pY->r = Y.r; pY->g = Y.g; pY->b = Y.b;
-            return 0.0f;
-        }
-
-        // Use Newton's Method to find local minima of sum-of-squares error.
-        auto const fSteps = static_cast<float>(cSteps - 1);
-
-        for (size_t iIteration = 0; iIteration < 8; iIteration++)
-        {
-            // Calculate new steps
-            HDRColorA pSteps[4] = {};
-
-            for (size_t iStep = 0; iStep < cSteps; iStep++)
-            {
-                pSteps[iStep].r = X.r * pC[iStep] + Y.r * pD[iStep];
-                pSteps[iStep].g = X.g * pC[iStep] + Y.g * pD[iStep];
-                pSteps[iStep].b = X.b * pC[iStep] + Y.b * pD[iStep];
-            }
-
-            // Calculate color direction
-            Dir.r = Y.r - X.r;
-            Dir.g = Y.g - X.g;
-            Dir.b = Y.b - X.b;
-
-            const float fLen = (Dir.r * Dir.r + Dir.g * Dir.g + Dir.b * Dir.b);
-
-            if (fLen < (1.0f / 4096.0f))
-                break;
-
-            const float fScale = fSteps / fLen;
-
-            Dir.r *= fScale;
-            Dir.g *= fScale;
-            Dir.b *= fScale;
-
-            // Evaluate function, and derivatives
-            float d2X = 0.0f, d2Y = 0.0f;
-            HDRColorA dX(0.0f, 0.0f, 0.0f, 0.0f), dY(0.0f, 0.0f, 0.0f, 0.0f);
-
-            for (size_t iPoint = 0; iPoint < cPixels; iPoint++)
-            {
-                const float fDot = (pPoints[pIndex[iPoint]].r - X.r) * Dir.r +
-                    (pPoints[pIndex[iPoint]].g - X.g) * Dir.g +
-                    (pPoints[pIndex[iPoint]].b - X.b) * Dir.b;
-
-                uint32_t iStep;
-                if (fDot <= 0.0f)
-                    iStep = 0;
-                else if (fDot >= fSteps)
-                    iStep = cSteps - 1;
-                else
-                    iStep = uint32_t(fDot + 0.5f);
-
-                HDRColorA Diff;
-                Diff.r = pSteps[iStep].r - pPoints[pIndex[iPoint]].r;
-                Diff.g = pSteps[iStep].g - pPoints[pIndex[iPoint]].g;
-                Diff.b = pSteps[iStep].b - pPoints[pIndex[iPoint]].b;
-
-                const float fC = pC[iStep] * (1.0f / 8.0f);
-                const float fD = pD[iStep] * (1.0f / 8.0f);
-
-                d2X += fC * pC[iStep];
-                dX.r += fC * Diff.r;
-                dX.g += fC * Diff.g;
-                dX.b += fC * Diff.b;
-
-                d2Y += fD * pD[iStep];
-                dY.r += fD * Diff.r;
-                dY.g += fD * Diff.g;
-                dY.b += fD * Diff.b;
-            }
-
-            // Move endpoints
-            if (d2X > 0.0f)
-            {
-                const float f = -1.0f / d2X;
-
-                X.r += dX.r * f;
-                X.g += dX.g * f;
-                X.b += dX.b * f;
-            }
-
-            if (d2Y > 0.0f)
-            {
-                const float f = -1.0f / d2Y;
-
-                Y.r += dY.r * f;
-                Y.g += dY.g * f;
-                Y.b += dY.b * f;
-            }
-
-            if ((dX.r * dX.r < fEpsilon) && (dX.g * dX.g < fEpsilon) && (dX.b * dX.b < fEpsilon) &&
-                (dY.r * dY.r < fEpsilon) && (dY.g * dY.g < fEpsilon) && (dY.b * dY.b < fEpsilon))
-            {
-                break;
-            }
-        }
-
-        pX->r = X.r; pX->g = X.g; pX->b = X.b;
-        pY->r = Y.r; pY->g = Y.g; pY->b = Y.b;
-        return fError;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    float OptimizeRGBA(
-        _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA* const pPoints,
-        _Out_ HDRColorA* pX,
-        _Out_ HDRColorA* pY,
-        _In_range_(3, 4) uint32_t cSteps,
-        size_t cPixels,
-        _In_reads_(cPixels) const size_t* pIndex) noexcept
-    {
-        constexpr float fError = FLT_MAX;
-        const float *pC = (3 == cSteps) ? pC3 : pC4;
-        const float *pD = (3 == cSteps) ? pD3 : pD4;
-
-        // Find Min and Max points, as starting point
-        HDRColorA X(1.0f, 1.0f, 1.0f, 1.0f);
-        HDRColorA Y(0.0f, 0.0f, 0.0f, 0.0f);
-
-        for (size_t iPoint = 0; iPoint < cPixels; iPoint++)
-        {
-            if (pPoints[pIndex[iPoint]].r < X.r) X.r = pPoints[pIndex[iPoint]].r;
-            if (pPoints[pIndex[iPoint]].g < X.g) X.g = pPoints[pIndex[iPoint]].g;
-            if (pPoints[pIndex[iPoint]].b < X.b) X.b = pPoints[pIndex[iPoint]].b;
-            if (pPoints[pIndex[iPoint]].a < X.a) X.a = pPoints[pIndex[iPoint]].a;
-            if (pPoints[pIndex[iPoint]].r > Y.r) Y.r = pPoints[pIndex[iPoint]].r;
-            if (pPoints[pIndex[iPoint]].g > Y.g) Y.g = pPoints[pIndex[iPoint]].g;
-            if (pPoints[pIndex[iPoint]].b > Y.b) Y.b = pPoints[pIndex[iPoint]].b;
-            if (pPoints[pIndex[iPoint]].a > Y.a) Y.a = pPoints[pIndex[iPoint]].a;
-        }
-
-        // Diagonal axis
-        const HDRColorA AB = Y - X;
-        const float fAB = AB * AB;
-
-        // Single color block.. no need to root-find
-        if (fAB < FLT_MIN)
-        {
-            *pX = X;
-            *pY = Y;
-            return 0.0f;
-        }
-
-        // Try all four axis directions, to determine which diagonal best fits data
-        const float fABInv = 1.0f / fAB;
-        HDRColorA Dir = AB * fABInv;
-        const HDRColorA Mid = (X + Y) * 0.5f;
-
-        float fDir[8];
-        fDir[0] = fDir[1] = fDir[2] = fDir[3] = fDir[4] = fDir[5] = fDir[6] = fDir[7] = 0.0f;
-
-        for (size_t iPoint = 0; iPoint < cPixels; iPoint++)
-        {
-            HDRColorA Pt;
-            Pt.r = (pPoints[pIndex[iPoint]].r - Mid.r) * Dir.r;
-            Pt.g = (pPoints[pIndex[iPoint]].g - Mid.g) * Dir.g;
-            Pt.b = (pPoints[pIndex[iPoint]].b - Mid.b) * Dir.b;
-            Pt.a = (pPoints[pIndex[iPoint]].a - Mid.a) * Dir.a;
-
-            float f;
-            f = Pt.r + Pt.g + Pt.b + Pt.a; fDir[0] += f * f;
-            f = Pt.r + Pt.g + Pt.b - Pt.a; fDir[1] += f * f;
-            f = Pt.r + Pt.g - Pt.b + Pt.a; fDir[2] += f * f;
-            f = Pt.r + Pt.g - Pt.b - Pt.a; fDir[3] += f * f;
-            f = Pt.r - Pt.g + Pt.b + Pt.a; fDir[4] += f * f;
-            f = Pt.r - Pt.g + Pt.b - Pt.a; fDir[5] += f * f;
-            f = Pt.r - Pt.g - Pt.b + Pt.a; fDir[6] += f * f;
-            f = Pt.r - Pt.g - Pt.b - Pt.a; fDir[7] += f * f;
-        }
-
-        float fDirMax = fDir[0];
-        size_t  iDirMax = 0;
-
-        for (size_t iDir = 1; iDir < 8; iDir++)
-        {
-            if (fDir[iDir] > fDirMax)
-            {
-                fDirMax = fDir[iDir];
-                iDirMax = iDir;
-            }
-        }
-
-        if (iDirMax & 4) std::swap(X.g, Y.g);
-        if (iDirMax & 2) std::swap(X.b, Y.b);
-        if (iDirMax & 1) std::swap(X.a, Y.a);
-
-        // Two color block.. no need to root-find
-        if (fAB < 1.0f / 4096.0f)
-        {
-            *pX = X;
-            *pY = Y;
-            return 0.0f;
-        }
-
-        // Use Newton's Method to find local minima of sum-of-squares error.
-        const auto fSteps = static_cast<float>(cSteps - 1u);
-
-        for (size_t iIteration = 0; iIteration < 8 && fError > 0.0f; iIteration++)
-        {
-            // Calculate new steps
-            HDRColorA pSteps[BC7_MAX_INDICES];
-
-            LDRColorA lX, lY;
-            lX = (X * 255.0f).ToLDRColorA();
-            lY = (Y * 255.0f).ToLDRColorA();
-
-            for (size_t iStep = 0; iStep < cSteps; iStep++)
-            {
-                pSteps[iStep] = X * pC[iStep] + Y * pD[iStep];
-                //LDRColorA::Interpolate(lX, lY, i, i, wcprec, waprec, aSteps[i]);
-            }
-
-            // Calculate color direction
-            Dir = Y - X;
-            const float fLen = Dir * Dir;
-            if (fLen < (1.0f / 4096.0f))
-                break;
-
-            const float fScale = fSteps / fLen;
-            Dir *= fScale;
-
-            // Evaluate function, and derivatives
-            float d2X = 0.0f, d2Y = 0.0f;
-            HDRColorA dX(0.0f, 0.0f, 0.0f, 0.0f), dY(0.0f, 0.0f, 0.0f, 0.0f);
-
-            for (size_t iPoint = 0; iPoint < cPixels; ++iPoint)
-            {
-                const float fDot = (pPoints[pIndex[iPoint]] - X) * Dir;
-
-                uint32_t iStep;
-                if (fDot <= 0.0f)
-                    iStep = 0;
-                else if (fDot >= fSteps)
-                    iStep = cSteps - 1;
-                else
-                    iStep = uint32_t(fDot + 0.5f);
-
-                const HDRColorA Diff = pSteps[iStep] - pPoints[pIndex[iPoint]];
-                const float fC = pC[iStep] * (1.0f / 8.0f);
-                const float fD = pD[iStep] * (1.0f / 8.0f);
-
-                d2X += fC * pC[iStep];
-                dX += Diff * fC;
-
-                d2Y += fD * pD[iStep];
-                dY += Diff * fD;
-            }
-
-            // Move endpoints
-            if (d2X > 0.0f)
-            {
-                const float f = -1.0f / d2X;
-                X += dX * f;
-            }
-
-            if (d2Y > 0.0f)
-            {
-                const float f = -1.0f / d2Y;
-                Y += dY * f;
-            }
-
-            if ((dX * dX < fEpsilon) && (dY * dY < fEpsilon))
-                break;
-        }
-
-        *pX = X;
-        *pY = Y;
-        return fError;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    float ComputeError(
-        _Inout_ const LDRColorA& pixel,
-        _In_reads_(1 << uIndexPrec) const LDRColorA aPalette[],
-        uint8_t uIndexPrec,
-        uint8_t uIndexPrec2,
-        _Out_opt_ size_t* pBestIndex = nullptr,
-        _Out_opt_ size_t* pBestIndex2 = nullptr) noexcept
-    {
-        const size_t uNumIndices = size_t(1) << uIndexPrec;
-        const size_t uNumIndices2 = size_t(1) << uIndexPrec2;
-        float fTotalErr = 0;
-        float fBestErr = FLT_MAX;
-
-        if (pBestIndex)
-            *pBestIndex = 0;
-        if (pBestIndex2)
-            *pBestIndex2 = 0;
-
-        const XMVECTOR vpixel = XMLoadUByte4(reinterpret_cast<const XMUBYTE4*>(&pixel));
-
-        if (uIndexPrec2 == 0)
-        {
-            for (size_t i = 0; i < uNumIndices && fBestErr > 0; i++)
-            {
-                XMVECTOR tpixel = XMLoadUByte4(reinterpret_cast<const XMUBYTE4*>(&aPalette[i]));
-                // Compute ErrorMetric
-                tpixel = XMVectorSubtract(vpixel, tpixel);
-                const float fErr = XMVectorGetX(XMVector4Dot(tpixel, tpixel));
-                if (fErr > fBestErr)	// error increased, so we're done searching
-                    break;
-                if (fErr < fBestErr)
-                {
-                    fBestErr = fErr;
-                    if (pBestIndex)
-                        *pBestIndex = i;
-                }
-            }
-            fTotalErr += fBestErr;
-        }
-        else
-        {
-            for (size_t i = 0; i < uNumIndices && fBestErr > 0; i++)
-            {
-                XMVECTOR tpixel = XMLoadUByte4(reinterpret_cast<const XMUBYTE4*>(&aPalette[i]));
-                // Compute ErrorMetricRGB
-                tpixel = XMVectorSubtract(vpixel, tpixel);
-                const float fErr = XMVectorGetX(XMVector3Dot(tpixel, tpixel));
-                if (fErr > fBestErr)	// error increased, so we're done searching
-                    break;
-                if (fErr < fBestErr)
-                {
-                    fBestErr = fErr;
-                    if (pBestIndex)
-                        *pBestIndex = i;
-                }
-            }
-            fTotalErr += fBestErr;
-            fBestErr = FLT_MAX;
-            for (size_t i = 0; i < uNumIndices2 && fBestErr > 0; i++)
-            {
-                // Compute ErrorMetricAlpha
-                const float ea = float(pixel.a) - float(aPalette[i].a);
-                const float fErr = ea*ea;
-                if (fErr > fBestErr)	// error increased, so we're done searching
-                    break;
-                if (fErr < fBestErr)
-                {
-                    fBestErr = fErr;
-                    if (pBestIndex2)
-                        *pBestIndex2 = i;
-                }
-            }
-            fTotalErr += fBestErr;
-        }
-
-        return fTotalErr;
-    }
-
-
-    void FillWithErrorColors(_Out_writes_(NUM_PIXELS_PER_BLOCK) HDRColorA* pOut) noexcept
-    {
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-        #ifdef _DEBUG
-            // Use Magenta in debug as a highly-visible error color
-            pOut[i] = HDRColorA(1.0f, 0.0f, 1.0f, 1.0f);
-        #else
-            // In production use, default to black
-            pOut[i] = HDRColorA(0.0f, 0.0f, 0.0f, 1.0f);
-        #endif
-        }
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// BC6H Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
-{
-    assert(pOut);
-
-    size_t uStartBit = 0;
-    uint8_t uMode = GetBits(uStartBit, 2u);
-    if (uMode != 0x00 && uMode != 0x01)
-    {
-        uMode = static_cast<uint8_t>((unsigned(GetBits(uStartBit, 3)) << 2) | uMode);
-    }
-
-    assert(uMode < c_NumModeInfo);
-    _Analysis_assume_(uMode < c_NumModeInfo);
-
-    if (ms_aModeToInfo[uMode] >= 0)
-    {
-        assert(static_cast<unsigned int>(ms_aModeToInfo[uMode]) < c_NumModes);
-        _Analysis_assume_(ms_aModeToInfo[uMode] < c_NumModes);
-        const ModeDescriptor* desc = ms_aDesc[ms_aModeToInfo[uMode]];
-        const ModeInfo& info = ms_aInfo[ms_aModeToInfo[uMode]];
-
-        INTEndPntPair aEndPts[BC6H_MAX_REGIONS] = {};
-        uint32_t uShape = 0;
-
-        // Read header
-        const size_t uHeaderBits = info.uPartitions > 0 ? 82u : 65u;
-        while (uStartBit < uHeaderBits)
-        {
-            const size_t uCurBit = uStartBit;
-            if (GetBit(uStartBit))
-            {
-                switch (desc[uCurBit].m_eField)
-                {
-                case D:  uShape |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case RW: aEndPts[0].A.r |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case RX: aEndPts[0].B.r |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case RY: aEndPts[1].A.r |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case RZ: aEndPts[1].B.r |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case GW: aEndPts[0].A.g |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case GX: aEndPts[0].B.g |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case GY: aEndPts[1].A.g |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case GZ: aEndPts[1].B.g |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case BW: aEndPts[0].A.b |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case BX: aEndPts[0].B.b |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case BY: aEndPts[1].A.b |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                case BZ: aEndPts[1].B.b |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
-                default:
-                    {
-                    #ifdef _DEBUG
-                        OutputDebugStringA("BC6H: Invalid header bits encountered during decoding\n");
-                    #endif
-                        FillWithErrorColors(pOut);
-                        return;
-                    }
-                }
-            }
-        }
-
-        assert(uShape < 64);
-        _Analysis_assume_(uShape < 64);
-
-        // Sign extend necessary end points
-        if (bSigned)
-        {
-            aEndPts[0].A.SignExtend(info.RGBAPrec[0][0]);
-        }
-        if (bSigned || info.bTransformed)
-        {
-            assert(info.uPartitions < BC6H_MAX_REGIONS);
-            _Analysis_assume_(info.uPartitions < BC6H_MAX_REGIONS);
-            for (size_t p = 0; p <= info.uPartitions; ++p)
-            {
-                if (p != 0)
-                {
-                    aEndPts[p].A.SignExtend(info.RGBAPrec[p][0]);
-                }
-                aEndPts[p].B.SignExtend(info.RGBAPrec[p][1]);
-            }
-        }
-
-        // Inverse transform the end points
-        if (info.bTransformed)
-        {
-            TransformInverse(aEndPts, info.RGBAPrec[0][0], bSigned);
-        }
-
-        // Read indices
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            const size_t uNumBits = IsFixUpOffset(info.uPartitions, uShape, i) ? info.uIndexPrec - 1u : info.uIndexPrec;
-            if (uStartBit + uNumBits > 128)
-            {
-            #ifdef _DEBUG
-                OutputDebugStringA("BC6H: Invalid block encountered during decoding\n");
-            #endif
-                FillWithErrorColors(pOut);
-                return;
-            }
-            const uint8_t uIndex = GetBits(uStartBit, uNumBits);
-
-            if (uIndex >= ((info.uPartitions > 0) ? 8 : 16))
-            {
-            #ifdef _DEBUG
-                OutputDebugStringA("BC6H: Invalid index encountered during decoding\n");
-            #endif
-                FillWithErrorColors(pOut);
-                return;
-            }
-
-            const size_t uRegion = g_aPartitionTable[info.uPartitions][uShape][i];
-            assert(uRegion < BC6H_MAX_REGIONS);
-            _Analysis_assume_(uRegion < BC6H_MAX_REGIONS);
-
-            // Unquantize endpoints and interpolate
-            const int r1 = Unquantize(aEndPts[uRegion].A.r, info.RGBAPrec[0][0].r, bSigned);
-            const int g1 = Unquantize(aEndPts[uRegion].A.g, info.RGBAPrec[0][0].g, bSigned);
-            const int b1 = Unquantize(aEndPts[uRegion].A.b, info.RGBAPrec[0][0].b, bSigned);
-            const int r2 = Unquantize(aEndPts[uRegion].B.r, info.RGBAPrec[0][0].r, bSigned);
-            const int g2 = Unquantize(aEndPts[uRegion].B.g, info.RGBAPrec[0][0].g, bSigned);
-            const int b2 = Unquantize(aEndPts[uRegion].B.b, info.RGBAPrec[0][0].b, bSigned);
-            const int* aWeights = info.uPartitions > 0 ? g_aWeights3 : g_aWeights4;
-            INTColor fc;
-            fc.r = FinishUnquantize((r1 * (BC67_WEIGHT_MAX - aWeights[uIndex]) + r2 * aWeights[uIndex] + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT, bSigned);
-            fc.g = FinishUnquantize((g1 * (BC67_WEIGHT_MAX - aWeights[uIndex]) + g2 * aWeights[uIndex] + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT, bSigned);
-            fc.b = FinishUnquantize((b1 * (BC67_WEIGHT_MAX - aWeights[uIndex]) + b2 * aWeights[uIndex] + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT, bSigned);
-
-            HALF rgb[3];
-            fc.ToF16(rgb, bSigned);
-
-            pOut[i].r = XMConvertHalfToFloat(rgb[0]);
-            pOut[i].g = XMConvertHalfToFloat(rgb[1]);
-            pOut[i].b = XMConvertHalfToFloat(rgb[2]);
-            pOut[i].a = 1.0f;
-        }
-    }
-    else
-    {
-    #ifdef _DEBUG
-        const char* warnstr = "BC6H: Invalid mode encountered during decoding\n";
-        switch (uMode)
-        {
-        case 0x13:  warnstr = "BC6H: Reserved mode 10011 encountered during decoding\n"; break;
-        case 0x17:  warnstr = "BC6H: Reserved mode 10111 encountered during decoding\n"; break;
-        case 0x1B:  warnstr = "BC6H: Reserved mode 11011 encountered during decoding\n"; break;
-        case 0x1F:  warnstr = "BC6H: Reserved mode 11111 encountered during decoding\n"; break;
-        }
-        OutputDebugStringA(warnstr);
-    #endif
-        // Per the BC6H format spec, we must return opaque black
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            pOut[i] = HDRColorA(0.0f, 0.0f, 0.0f, 1.0f);
-        }
-    }
-}
-
-
-_Use_decl_annotations_
-void D3DX_BC6H::Encode(bool bSigned, const HDRColorA* const pIn) noexcept
-{
-    assert(pIn);
-
-    EncodeParams EP(pIn, bSigned);
-
-    for (EP.uMode = 0; EP.uMode < c_NumModes && EP.fBestErr > 0; ++EP.uMode)
-    {
-        const uint8_t uShapes = ms_aInfo[EP.uMode].uPartitions ? 32u : 1u;
-        // Number of rough cases to look at. reasonable values of this are 1, uShapes/4, and uShapes
-        // uShapes/4 gets nearly all the cases; you can increase that a bit (say by 3 or 4) if you really want to squeeze the last bit out
-        const size_t uItems = std::max<size_t>(1u, size_t(uShapes >> 2));
-        float afRoughMSE[BC6H_MAX_SHAPES];
-        uint8_t auShape[BC6H_MAX_SHAPES];
-
-        // pick the best uItems shapes and refine these.
-        for (EP.uShape = 0; EP.uShape < uShapes; ++EP.uShape)
-        {
-            size_t uShape = EP.uShape;
-            afRoughMSE[uShape] = RoughMSE(&EP);
-            auShape[uShape] = static_cast<uint8_t>(uShape);
-        }
-
-        // Bubble up the first uItems items
-        for (size_t i = 0; i < uItems; i++)
-        {
-            for (size_t j = i + 1; j < uShapes; j++)
-            {
-                if (afRoughMSE[i] > afRoughMSE[j])
-                {
-                    std::swap(afRoughMSE[i], afRoughMSE[j]);
-                    std::swap(auShape[i], auShape[j]);
-                }
-            }
-        }
-
-        for (size_t i = 0; i < uItems && EP.fBestErr > 0; i++)
-        {
-            EP.uShape = auShape[i];
-            Refine(&EP);
-        }
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-int D3DX_BC6H::Quantize(int iValue, int prec, bool bSigned) noexcept
-{
-    assert(prec > 1);	// didn't bother to make it work for 1
-    int q, s = 0;
-    if (bSigned)
-    {
-        assert(iValue >= -F16MAX && iValue <= F16MAX);
-        if (iValue < 0)
-        {
-            s = 1;
-            iValue = -iValue;
-        }
-        q = (prec >= 16) ? iValue : (iValue << (prec - 1)) / (F16MAX + 1);
-        if (s)
-            q = -q;
-        assert(q > -(1 << (prec - 1)) && q < (1 << (prec - 1)));
-    }
-    else
-    {
-        assert(iValue >= 0 && iValue <= F16MAX);
-        q = (prec >= 15) ? iValue : (iValue << prec) / (F16MAX + 1);
-        assert(q >= 0 && q < (1 << prec));
-    }
-
-    return q;
-}
-
-
-_Use_decl_annotations_
-int D3DX_BC6H::Unquantize(int comp, uint8_t uBitsPerComp, bool bSigned) noexcept
-{
-    int unq = 0, s = 0;
-    if (bSigned)
-    {
-        if (uBitsPerComp >= 16)
-        {
-            unq = comp;
-        }
-        else
-        {
-            if (comp < 0)
-            {
-                s = 1;
-                comp = -comp;
-            }
-
-            if (comp == 0) unq = 0;
-            else if (comp >= ((1 << (uBitsPerComp - 1)) - 1)) unq = 0x7FFF;
-            else unq = ((comp << 15) + 0x4000) >> (uBitsPerComp - 1);
-
-            if (s) unq = -unq;
-        }
-    }
-    else
-    {
-        if (uBitsPerComp >= 15) unq = comp;
-        else if (comp == 0) unq = 0;
-        else if (comp == ((1 << uBitsPerComp) - 1)) unq = 0xFFFF;
-        else unq = ((comp << 16) + 0x8000) >> uBitsPerComp;
-    }
-
-    return unq;
-}
-
-
-_Use_decl_annotations_
-int D3DX_BC6H::FinishUnquantize(int comp, bool bSigned) noexcept
-{
-    if (bSigned)
-    {
-        return (comp < 0) ? -(((-comp) * 31) >> 5) : (comp * 31) >> 5;  // scale the magnitude by 31/32
-    }
-    else
-    {
-        return (comp * 31) >> 6;                                        // scale the magnitude by 31/64
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool D3DX_BC6H::EndPointsFit(const EncodeParams* pEP, const INTEndPntPair aEndPts[]) noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const bool bTransformed = ms_aInfo[pEP->uMode].bTransformed;
-    const bool bIsSigned = pEP->bSigned;
-    const LDRColorA& Prec0 = ms_aInfo[pEP->uMode].RGBAPrec[0][0];
-    const LDRColorA& Prec1 = ms_aInfo[pEP->uMode].RGBAPrec[0][1];
-    const LDRColorA& Prec2 = ms_aInfo[pEP->uMode].RGBAPrec[1][0];
-    const LDRColorA& Prec3 = ms_aInfo[pEP->uMode].RGBAPrec[1][1];
-
-    INTColor aBits[4];
-    aBits[0].r = NBits(aEndPts[0].A.r, bIsSigned);
-    aBits[0].g = NBits(aEndPts[0].A.g, bIsSigned);
-    aBits[0].b = NBits(aEndPts[0].A.b, bIsSigned);
-    aBits[1].r = NBits(aEndPts[0].B.r, bTransformed || bIsSigned);
-    aBits[1].g = NBits(aEndPts[0].B.g, bTransformed || bIsSigned);
-    aBits[1].b = NBits(aEndPts[0].B.b, bTransformed || bIsSigned);
-    if (aBits[0].r > Prec0.r || aBits[1].r > Prec1.r ||
-        aBits[0].g > Prec0.g || aBits[1].g > Prec1.g ||
-        aBits[0].b > Prec0.b || aBits[1].b > Prec1.b)
-        return false;
-
-    if (ms_aInfo[pEP->uMode].uPartitions)
-    {
-        aBits[2].r = NBits(aEndPts[1].A.r, bTransformed || bIsSigned);
-        aBits[2].g = NBits(aEndPts[1].A.g, bTransformed || bIsSigned);
-        aBits[2].b = NBits(aEndPts[1].A.b, bTransformed || bIsSigned);
-        aBits[3].r = NBits(aEndPts[1].B.r, bTransformed || bIsSigned);
-        aBits[3].g = NBits(aEndPts[1].B.g, bTransformed || bIsSigned);
-        aBits[3].b = NBits(aEndPts[1].B.b, bTransformed || bIsSigned);
-
-        if (aBits[2].r > Prec2.r || aBits[3].r > Prec3.r ||
-            aBits[2].g > Prec2.g || aBits[3].g > Prec3.g ||
-            aBits[2].b > Prec2.b || aBits[3].b > Prec3.b)
-            return false;
-    }
-
-    return true;
-}
-
-
-_Use_decl_annotations_
-void D3DX_BC6H::GeneratePaletteQuantized(const EncodeParams* pEP, const INTEndPntPair& endPts, INTColor aPalette[]) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const size_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
-    const size_t uNumIndices = size_t(1) << uIndexPrec;
-    assert(uNumIndices > 0);
-    _Analysis_assume_(uNumIndices > 0);
-    const LDRColorA& Prec = ms_aInfo[pEP->uMode].RGBAPrec[0][0];
-
-    // scale endpoints
-    INTEndPntPair unqEndPts;
-    unqEndPts.A.r = Unquantize(endPts.A.r, Prec.r, pEP->bSigned);
-    unqEndPts.A.g = Unquantize(endPts.A.g, Prec.g, pEP->bSigned);
-    unqEndPts.A.b = Unquantize(endPts.A.b, Prec.b, pEP->bSigned);
-    unqEndPts.B.r = Unquantize(endPts.B.r, Prec.r, pEP->bSigned);
-    unqEndPts.B.g = Unquantize(endPts.B.g, Prec.g, pEP->bSigned);
-    unqEndPts.B.b = Unquantize(endPts.B.b, Prec.b, pEP->bSigned);
-
-    // interpolate
-    const int* aWeights = nullptr;
-    switch (uIndexPrec)
-    {
-    case 3: aWeights = g_aWeights3; assert(uNumIndices <= 8); _Analysis_assume_(uNumIndices <= 8); break;
-    case 4: aWeights = g_aWeights4; assert(uNumIndices <= 16); _Analysis_assume_(uNumIndices <= 16); break;
-    default:
-        assert(false);
-        for (size_t i = 0; i < uNumIndices; ++i)
-        {
-        #pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool")
-            aPalette[i] = INTColor(0, 0, 0);
-        }
-        return;
-    }
-
-    for (size_t i = 0; i < uNumIndices; ++i)
-    {
-        aPalette[i].r = FinishUnquantize(
-            (unqEndPts.A.r * (BC67_WEIGHT_MAX - aWeights[i]) + unqEndPts.B.r * aWeights[i] + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT,
-            pEP->bSigned);
-        aPalette[i].g = FinishUnquantize(
-            (unqEndPts.A.g * (BC67_WEIGHT_MAX - aWeights[i]) + unqEndPts.B.g * aWeights[i] + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT,
-            pEP->bSigned);
-        aPalette[i].b = FinishUnquantize(
-            (unqEndPts.A.b * (BC67_WEIGHT_MAX - aWeights[i]) + unqEndPts.B.b * aWeights[i] + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT,
-            pEP->bSigned);
-    }
-}
-
-
-// given a collection of colors and quantized endpoints, generate a palette, choose best entries, and return a single toterr
-_Use_decl_annotations_
-float D3DX_BC6H::MapColorsQuantized(const EncodeParams* pEP, const INTColor aColors[], size_t np, const INTEndPntPair &endPts) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
-    auto const uNumIndices = static_cast<const uint8_t>(1u << uIndexPrec);
-    INTColor aPalette[BC6H_MAX_INDICES];
-    GeneratePaletteQuantized(pEP, endPts, aPalette);
-
-    float fTotErr = 0;
-    for (size_t i = 0; i < np; ++i)
-    {
-        const XMVECTOR vcolors = XMLoadSInt4(reinterpret_cast<const XMINT4*>(&aColors[i]));
-
-        // Compute ErrorMetricRGB
-        XMVECTOR tpal = XMLoadSInt4(reinterpret_cast<const XMINT4*>(&aPalette[0]));
-        tpal = XMVectorSubtract(vcolors, tpal);
-        float fBestErr = XMVectorGetX(XMVector3Dot(tpal, tpal));
-
-        for (int j = 1; j < uNumIndices && fBestErr > 0; ++j)
-        {
-            // Compute ErrorMetricRGB
-            tpal = XMLoadSInt4(reinterpret_cast<const XMINT4*>(&aPalette[j]));
-            tpal = XMVectorSubtract(vcolors, tpal);
-            const float fErr = XMVectorGetX(XMVector3Dot(tpal, tpal));
-            if (fErr > fBestErr) break;     // error increased, so we're done searching
-            if (fErr < fBestErr) fBestErr = fErr;
-        }
-        fTotErr += fBestErr;
-    }
-    return fTotErr;
-}
-
-
-_Use_decl_annotations_
-float D3DX_BC6H::PerturbOne(const EncodeParams* pEP, const INTColor aColors[], size_t np, uint8_t ch,
-    const INTEndPntPair& oldEndPts, INTEndPntPair& newEndPts, float fOldErr, int do_b) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    uint8_t uPrec;
-    switch (ch)
-    {
-    case 0: uPrec = ms_aInfo[pEP->uMode].RGBAPrec[0][0].r; break;
-    case 1: uPrec = ms_aInfo[pEP->uMode].RGBAPrec[0][0].g; break;
-    case 2: uPrec = ms_aInfo[pEP->uMode].RGBAPrec[0][0].b; break;
-    default: assert(false); newEndPts = oldEndPts; return FLT_MAX;
-    }
-    INTEndPntPair tmpEndPts;
-    float fMinErr = fOldErr;
-    int beststep = 0;
-
-    // copy real endpoints so we can perturb them
-    tmpEndPts = newEndPts = oldEndPts;
-
-    // do a logarithmic search for the best error for this endpoint (which)
-    for (int step = 1 << (uPrec - 1); step; step >>= 1)
-    {
-        bool bImproved = false;
-        for (int sign = -1; sign <= 1; sign += 2)
-        {
-            if (do_b == 0)
-            {
-                tmpEndPts.A[ch] = newEndPts.A[ch] + sign * step;
-                if (tmpEndPts.A[ch] < 0 || tmpEndPts.A[ch] >= (1 << uPrec))
-                    continue;
-            }
-            else
-            {
-                tmpEndPts.B[ch] = newEndPts.B[ch] + sign * step;
-                if (tmpEndPts.B[ch] < 0 || tmpEndPts.B[ch] >= (1 << uPrec))
-                    continue;
-            }
-
-            const float fErr = MapColorsQuantized(pEP, aColors, np, tmpEndPts);
-
-            if (fErr < fMinErr)
-            {
-                bImproved = true;
-                fMinErr = fErr;
-                beststep = sign * step;
-            }
-        }
-        // if this was an improvement, move the endpoint and continue search from there
-        if (bImproved)
-        {
-            if (do_b == 0)
-                newEndPts.A[ch] += beststep;
-            else
-                newEndPts.B[ch] += beststep;
-        }
-    }
-    return fMinErr;
-}
-
-
-_Use_decl_annotations_
-void D3DX_BC6H::OptimizeOne(const EncodeParams* pEP, const INTColor aColors[], size_t np, float aOrgErr,
-    const INTEndPntPair &aOrgEndPts, INTEndPntPair &aOptEndPts) const noexcept
-{
-    assert(pEP);
-    float aOptErr = aOrgErr;
-    aOptEndPts.A = aOrgEndPts.A;
-    aOptEndPts.B = aOrgEndPts.B;
-
-    INTEndPntPair new_a, new_b;
-    INTEndPntPair newEndPts;
-    int do_b;
-
-    // now optimize each channel separately
-    for (uint8_t ch = 0; ch < BC6H_NUM_CHANNELS; ++ch)
-    {
-        // figure out which endpoint when perturbed gives the most improvement and start there
-        // if we just alternate, we can easily end up in a local minima
-        const float fErr0 = PerturbOne(pEP, aColors, np, ch, aOptEndPts, new_a, aOptErr, 0);	// perturb endpt A
-        const float fErr1 = PerturbOne(pEP, aColors, np, ch, aOptEndPts, new_b, aOptErr, 1);	// perturb endpt B
-
-        if (fErr0 < fErr1)
-        {
-            if (fErr0 >= aOptErr) continue;
-            aOptEndPts.A[ch] = new_a.A[ch];
-            aOptErr = fErr0;
-            do_b = 1;		// do B next
-        }
-        else
-        {
-            if (fErr1 >= aOptErr) continue;
-            aOptEndPts.B[ch] = new_b.B[ch];
-            aOptErr = fErr1;
-            do_b = 0;		// do A next
-        }
-
-        // now alternate endpoints and keep trying until there is no improvement
-        for (;;)
-        {
-            const float fErr = PerturbOne(pEP, aColors, np, ch, aOptEndPts, newEndPts, aOptErr, do_b);
-            if (fErr >= aOptErr)
-                break;
-            if (do_b == 0)
-                aOptEndPts.A[ch] = newEndPts.A[ch];
-            else
-                aOptEndPts.B[ch] = newEndPts.B[ch];
-            aOptErr = fErr;
-            do_b = 1 - do_b;	// now move the other endpoint
-        }
-    }
-}
-
-
-_Use_decl_annotations_
-void D3DX_BC6H::OptimizeEndPoints(const EncodeParams* pEP, const float aOrgErr[], const INTEndPntPair aOrgEndPts[], INTEndPntPair aOptEndPts[]) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC6H_MAX_REGIONS);
-    _Analysis_assume_(uPartitions < BC6H_MAX_REGIONS);
-    INTColor aPixels[NUM_PIXELS_PER_BLOCK];
-
-    for (size_t p = 0; p <= uPartitions; ++p)
-    {
-        // collect the pixels in the region
-        size_t np = 0;
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            if (g_aPartitionTable[p][pEP->uShape][i] == p)
-            {
-                aPixels[np++] = pEP->aIPixels[i];
-            }
-        }
-
-        OptimizeOne(pEP, aPixels, np, aOrgErr[p], aOrgEndPts[p], aOptEndPts[p]);
-    }
-}
-
-
-// Swap endpoints as needed to ensure that the indices at fix up have a 0 high-order bit
-_Use_decl_annotations_
-void D3DX_BC6H::SwapIndices(const EncodeParams* pEP, INTEndPntPair aEndPts[], size_t aIndices[]) noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const size_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    const size_t uNumIndices = size_t(1) << ms_aInfo[pEP->uMode].uIndexPrec;
-    const size_t uHighIndexBit = uNumIndices >> 1;
-
-    assert(uPartitions < BC6H_MAX_REGIONS && pEP->uShape < BC6H_MAX_SHAPES);
-    _Analysis_assume_(uPartitions < BC6H_MAX_REGIONS && pEP->uShape < BC6H_MAX_SHAPES);
-
-    for (size_t p = 0; p <= uPartitions; ++p)
-    {
-        const size_t i = g_aFixUp[uPartitions][pEP->uShape][p];
-        assert(g_aPartitionTable[uPartitions][pEP->uShape][i] == p);
-        if (aIndices[i] & uHighIndexBit)
-        {
-            // high bit is set, swap the aEndPts and indices for this region
-            std::swap(aEndPts[p].A, aEndPts[p].B);
-
-            for (size_t j = 0; j < NUM_PIXELS_PER_BLOCK; ++j)
-                if (g_aPartitionTable[uPartitions][pEP->uShape][j] == p)
-                    aIndices[j] = uNumIndices - 1 - aIndices[j];
-        }
-    }
-}
-
-
-// assign indices given a tile, shape, and quantized endpoints, return toterr for each region
-_Use_decl_annotations_
-void D3DX_BC6H::AssignIndices(const EncodeParams* pEP, const INTEndPntPair aEndPts[], size_t aIndices[], float aTotErr[]) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    auto const uNumIndices = static_cast<const uint8_t>(1u << ms_aInfo[pEP->uMode].uIndexPrec);
-
-    assert(uPartitions < BC6H_MAX_REGIONS && pEP->uShape < BC6H_MAX_SHAPES);
-    _Analysis_assume_(uPartitions < BC6H_MAX_REGIONS && pEP->uShape < BC6H_MAX_SHAPES);
-
-    // build list of possibles
-    INTColor aPalette[BC6H_MAX_REGIONS][BC6H_MAX_INDICES];
-
-    for (size_t p = 0; p <= uPartitions; ++p)
-    {
-        GeneratePaletteQuantized(pEP, aEndPts[p], aPalette[p]);
-        aTotErr[p] = 0;
-    }
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        const uint8_t uRegion = g_aPartitionTable[uPartitions][pEP->uShape][i];
-        assert(uRegion < BC6H_MAX_REGIONS);
-        _Analysis_assume_(uRegion < BC6H_MAX_REGIONS);
-        float fBestErr = Norm(pEP->aIPixels[i], aPalette[uRegion][0]);
-        aIndices[i] = 0;
-
-        for (uint8_t j = 1; j < uNumIndices && fBestErr > 0; ++j)
-        {
-            const float fErr = Norm(pEP->aIPixels[i], aPalette[uRegion][j]);
-            if (fErr > fBestErr) break;	// error increased, so we're done searching
-            if (fErr < fBestErr)
-            {
-                fBestErr = fErr;
-                aIndices[i] = j;
-            }
-        }
-        aTotErr[uRegion] += fBestErr;
-    }
-}
-
-
-_Use_decl_annotations_
-void D3DX_BC6H::QuantizeEndPts(const EncodeParams* pEP, INTEndPntPair* aQntEndPts) const noexcept
-{
-    assert(pEP && aQntEndPts);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const INTEndPntPair* aUnqEndPts = pEP->aUnqEndPts[pEP->uShape];
-    const LDRColorA& Prec = ms_aInfo[pEP->uMode].RGBAPrec[0][0];
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC6H_MAX_REGIONS);
-    _Analysis_assume_(uPartitions < BC6H_MAX_REGIONS);
-
-    for (size_t p = 0; p <= uPartitions; ++p)
-    {
-        aQntEndPts[p].A.r = Quantize(aUnqEndPts[p].A.r, Prec.r, pEP->bSigned);
-        aQntEndPts[p].A.g = Quantize(aUnqEndPts[p].A.g, Prec.g, pEP->bSigned);
-        aQntEndPts[p].A.b = Quantize(aUnqEndPts[p].A.b, Prec.b, pEP->bSigned);
-        aQntEndPts[p].B.r = Quantize(aUnqEndPts[p].B.r, Prec.r, pEP->bSigned);
-        aQntEndPts[p].B.g = Quantize(aUnqEndPts[p].B.g, Prec.g, pEP->bSigned);
-        aQntEndPts[p].B.b = Quantize(aUnqEndPts[p].B.b, Prec.b, pEP->bSigned);
-    }
-}
-
-
-_Use_decl_annotations_
-void D3DX_BC6H::EmitBlock(const EncodeParams* pEP, const INTEndPntPair aEndPts[], const size_t aIndices[]) noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uRealMode = ms_aInfo[pEP->uMode].uMode;
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    const uint8_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
-    const size_t uHeaderBits = uPartitions > 0 ? 82u : 65u;
-    const ModeDescriptor* desc = ms_aDesc[pEP->uMode];
-    size_t uStartBit = 0;
-
-    while (uStartBit < uHeaderBits)
-    {
-        switch (desc[uStartBit].m_eField)
-        {
-        case M:  SetBit(uStartBit, uint8_t(uRealMode >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case D:  SetBit(uStartBit, uint8_t(pEP->uShape >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case RW: SetBit(uStartBit, uint8_t(aEndPts[0].A.r >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case RX: SetBit(uStartBit, uint8_t(aEndPts[0].B.r >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case RY: SetBit(uStartBit, uint8_t(aEndPts[1].A.r >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case RZ: SetBit(uStartBit, uint8_t(aEndPts[1].B.r >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case GW: SetBit(uStartBit, uint8_t(aEndPts[0].A.g >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case GX: SetBit(uStartBit, uint8_t(aEndPts[0].B.g >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case GY: SetBit(uStartBit, uint8_t(aEndPts[1].A.g >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case GZ: SetBit(uStartBit, uint8_t(aEndPts[1].B.g >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case BW: SetBit(uStartBit, uint8_t(aEndPts[0].A.b >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case BX: SetBit(uStartBit, uint8_t(aEndPts[0].B.b >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case BY: SetBit(uStartBit, uint8_t(aEndPts[1].A.b >> desc[uStartBit].m_uBit) & 0x01u); break;
-        case BZ: SetBit(uStartBit, uint8_t(aEndPts[1].B.b >> desc[uStartBit].m_uBit) & 0x01u); break;
-        default: assert(false);
-        }
-    }
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        if (IsFixUpOffset(ms_aInfo[pEP->uMode].uPartitions, pEP->uShape, i))
-            SetBits(uStartBit, uIndexPrec - 1u, static_cast<uint8_t>(aIndices[i]));
-        else
-            SetBits(uStartBit, uIndexPrec, static_cast<uint8_t>(aIndices[i]));
-    }
-    assert(uStartBit == 128);
-}
-
-
-_Use_decl_annotations_
-void D3DX_BC6H::Refine(EncodeParams* pEP) noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC6H_MAX_REGIONS);
-    _Analysis_assume_(uPartitions < BC6H_MAX_REGIONS);
-
-    const bool bTransformed = ms_aInfo[pEP->uMode].bTransformed;
-    float aOrgErr[BC6H_MAX_REGIONS], aOptErr[BC6H_MAX_REGIONS];
-    INTEndPntPair aOrgEndPts[BC6H_MAX_REGIONS], aOptEndPts[BC6H_MAX_REGIONS];
-    size_t aOrgIdx[NUM_PIXELS_PER_BLOCK], aOptIdx[NUM_PIXELS_PER_BLOCK];
-
-    QuantizeEndPts(pEP, aOrgEndPts);
-    AssignIndices(pEP, aOrgEndPts, aOrgIdx, aOrgErr);
-    SwapIndices(pEP, aOrgEndPts, aOrgIdx);
-
-    if (bTransformed) TransformForward(aOrgEndPts);
-    if (EndPointsFit(pEP, aOrgEndPts))
-    {
-        if (bTransformed) TransformInverse(aOrgEndPts, ms_aInfo[pEP->uMode].RGBAPrec[0][0], pEP->bSigned);
-        OptimizeEndPoints(pEP, aOrgErr, aOrgEndPts, aOptEndPts);
-        AssignIndices(pEP, aOptEndPts, aOptIdx, aOptErr);
-        SwapIndices(pEP, aOptEndPts, aOptIdx);
-
-        float fOrgTotErr = 0.0f, fOptTotErr = 0.0f;
-        for (size_t p = 0; p <= uPartitions; ++p)
-        {
-            fOrgTotErr += aOrgErr[p];
-            fOptTotErr += aOptErr[p];
-        }
-
-        if (bTransformed) TransformForward(aOptEndPts);
-        if (EndPointsFit(pEP, aOptEndPts) && fOptTotErr < fOrgTotErr && fOptTotErr < pEP->fBestErr)
-        {
-            pEP->fBestErr = fOptTotErr;
-            EmitBlock(pEP, aOptEndPts, aOptIdx);
-        }
-        else if (fOrgTotErr < pEP->fBestErr)
-        {
-            // either it stopped fitting when we optimized it, or there was no improvement
-            // so go back to the unoptimized endpoints which we know will fit
-            if (bTransformed) TransformForward(aOrgEndPts);
-            pEP->fBestErr = fOrgTotErr;
-            EmitBlock(pEP, aOrgEndPts, aOrgIdx);
-        }
-    }
-}
-
-
-_Use_decl_annotations_
-void D3DX_BC6H::GeneratePaletteUnquantized(const EncodeParams* pEP, size_t uRegion, INTColor aPalette[]) noexcept
-{
-    assert(pEP);
-    assert(uRegion < BC6H_MAX_REGIONS && pEP->uShape < BC6H_MAX_SHAPES);
-    _Analysis_assume_(uRegion < BC6H_MAX_REGIONS && pEP->uShape < BC6H_MAX_SHAPES);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const INTEndPntPair& endPts = pEP->aUnqEndPts[pEP->uShape][uRegion];
-    const uint8_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
-    auto const uNumIndices = static_cast<const uint8_t>(1u << uIndexPrec);
-    assert(uNumIndices > 0);
-    _Analysis_assume_(uNumIndices > 0);
-
-    const int* aWeights = nullptr;
-    switch (uIndexPrec)
-    {
-    case 3: aWeights = g_aWeights3; assert(uNumIndices <= 8); _Analysis_assume_(uNumIndices <= 8); break;
-    case 4: aWeights = g_aWeights4; assert(uNumIndices <= 16); _Analysis_assume_(uNumIndices <= 16); break;
-    default:
-        assert(false);
-        for (size_t i = 0; i < uNumIndices; ++i)
-        {
-        #pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool")
-            aPalette[i] = INTColor(0, 0, 0);
-        }
-        return;
-    }
-
-    for (size_t i = 0; i < uNumIndices; ++i)
-    {
-        aPalette[i].r = (endPts.A.r * (BC67_WEIGHT_MAX - aWeights[i]) + endPts.B.r * aWeights[i] + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT;
-        aPalette[i].g = (endPts.A.g * (BC67_WEIGHT_MAX - aWeights[i]) + endPts.B.g * aWeights[i] + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT;
-        aPalette[i].b = (endPts.A.b * (BC67_WEIGHT_MAX - aWeights[i]) + endPts.B.b * aWeights[i] + BC67_WEIGHT_ROUND) >> BC67_WEIGHT_SHIFT;
-    }
-}
-
-
-_Use_decl_annotations_
-float D3DX_BC6H::MapColors(const EncodeParams* pEP, size_t uRegion, size_t np, const size_t* auIndex) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
-    auto const uNumIndices = static_cast<const uint8_t>(1u << uIndexPrec);
-    INTColor aPalette[BC6H_MAX_INDICES];
-    GeneratePaletteUnquantized(pEP, uRegion, aPalette);
-
-    float fTotalErr = 0.0f;
-    for (size_t i = 0; i < np; ++i)
-    {
-        float fBestErr = Norm(pEP->aIPixels[auIndex[i]], aPalette[0]);
-        for (uint8_t j = 1; j < uNumIndices && fBestErr > 0.0f; ++j)
-        {
-            const float fErr = Norm(pEP->aIPixels[auIndex[i]], aPalette[j]);
-            if (fErr > fBestErr) break;      // error increased, so we're done searching
-            if (fErr < fBestErr) fBestErr = fErr;
-        }
-        fTotalErr += fBestErr;
-    }
-
-    return fTotalErr;
-}
-
-_Use_decl_annotations_
-float D3DX_BC6H::RoughMSE(EncodeParams* pEP) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uShape < BC6H_MAX_SHAPES);
-    _Analysis_assume_(pEP->uShape < BC6H_MAX_SHAPES);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    INTEndPntPair* aEndPts = pEP->aUnqEndPts[pEP->uShape];
-
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC6H_MAX_REGIONS);
-    _Analysis_assume_(uPartitions < BC6H_MAX_REGIONS);
-
-    size_t auPixIdx[NUM_PIXELS_PER_BLOCK];
-
-    float fError = 0.0f;
-    for (size_t p = 0; p <= uPartitions; ++p)
-    {
-        size_t np = 0;
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            if (g_aPartitionTable[uPartitions][pEP->uShape][i] == p)
-            {
-                auPixIdx[np++] = i;
-            }
-        }
-
-        // handle simple cases
-        assert(np > 0);
-        if (np == 1)
-        {
-            aEndPts[p].A = pEP->aIPixels[auPixIdx[0]];
-            aEndPts[p].B = pEP->aIPixels[auPixIdx[0]];
-            continue;
-        }
-        else if (np == 2)
-        {
-            aEndPts[p].A = pEP->aIPixels[auPixIdx[0]];
-            aEndPts[p].B = pEP->aIPixels[auPixIdx[1]];
-            continue;
-        }
-
-        HDRColorA epA, epB;
-        OptimizeRGB(pEP->aHDRPixels, &epA, &epB, 4, np, auPixIdx);
-        aEndPts[p].A.Set(epA, pEP->bSigned);
-        aEndPts[p].B.Set(epB, pEP->bSigned);
-        if (pEP->bSigned)
-        {
-            aEndPts[p].A.Clamp(-F16MAX, F16MAX);
-            aEndPts[p].B.Clamp(-F16MAX, F16MAX);
-        }
-        else
-        {
-            aEndPts[p].A.Clamp(0, F16MAX);
-            aEndPts[p].B.Clamp(0, F16MAX);
-        }
-
-        fError += MapColors(pEP, p, np, auPixIdx);
-    }
-
-    return fError;
-}
-
-
-//-------------------------------------------------------------------------------------
-// BC7 Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
-{
-    assert(pOut);
-
-    size_t uFirst = 0;
-    while (uFirst < 128 && !GetBit(uFirst)) {}
-    const uint8_t uMode = uint8_t(uFirst - 1);
-
-    if (uMode < 8)
-    {
-        const uint8_t uPartitions = ms_aInfo[uMode].uPartitions;
-        assert(uPartitions < BC7_MAX_REGIONS);
-        _Analysis_assume_(uPartitions < BC7_MAX_REGIONS);
-
-        auto const uNumEndPts = static_cast<const uint8_t>((unsigned(uPartitions) + 1u) << 1);
-        const uint8_t uIndexPrec = ms_aInfo[uMode].uIndexPrec;
-        const uint8_t uIndexPrec2 = ms_aInfo[uMode].uIndexPrec2;
-        size_t i;
-        size_t uStartBit = size_t(uMode) + 1;
-        uint8_t P[6];
-        const uint8_t uShape = GetBits(uStartBit, ms_aInfo[uMode].uPartitionBits);
-        assert(uShape < BC7_MAX_SHAPES);
-        _Analysis_assume_(uShape < BC7_MAX_SHAPES);
-
-        const uint8_t uRotation = GetBits(uStartBit, ms_aInfo[uMode].uRotationBits);
-        assert(uRotation < 4);
-
-        const uint8_t uIndexMode = GetBits(uStartBit, ms_aInfo[uMode].uIndexModeBits);
-        assert(uIndexMode < 2);
-
-        LDRColorA c[BC7_MAX_REGIONS << 1];
-        const LDRColorA RGBAPrec = ms_aInfo[uMode].RGBAPrec;
-        const LDRColorA RGBAPrecWithP = ms_aInfo[uMode].RGBAPrecWithP;
-
-        assert(uNumEndPts <= (BC7_MAX_REGIONS << 1));
-
-        // Red channel
-        for (i = 0; i < uNumEndPts; i++)
-        {
-            if (uStartBit + RGBAPrec.r > 128)
-            {
-            #ifdef _DEBUG
-                OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
-            #endif
-                FillWithErrorColors(pOut);
-                return;
-            }
-
-            c[i].r = GetBits(uStartBit, RGBAPrec.r);
-        }
-
-        // Green channel
-        for (i = 0; i < uNumEndPts; i++)
-        {
-            if (uStartBit + RGBAPrec.g > 128)
-            {
-            #ifdef _DEBUG
-                OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
-            #endif
-                FillWithErrorColors(pOut);
-                return;
-            }
-
-            c[i].g = GetBits(uStartBit, RGBAPrec.g);
-        }
-
-        // Blue channel
-        for (i = 0; i < uNumEndPts; i++)
-        {
-            if (uStartBit + RGBAPrec.b > 128)
-            {
-            #ifdef _DEBUG
-                OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
-            #endif
-                FillWithErrorColors(pOut);
-                return;
-            }
-
-            c[i].b = GetBits(uStartBit, RGBAPrec.b);
-        }
-
-        // Alpha channel
-        for (i = 0; i < uNumEndPts; i++)
-        {
-            if (uStartBit + RGBAPrec.a > 128)
-            {
-            #ifdef _DEBUG
-                OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
-            #endif
-                FillWithErrorColors(pOut);
-                return;
-            }
-
-            c[i].a = RGBAPrec.a ? GetBits(uStartBit, RGBAPrec.a) : 255u;
-        }
-
-        // P-bits
-        assert(ms_aInfo[uMode].uPBits <= 6);
-        _Analysis_assume_(ms_aInfo[uMode].uPBits <= 6);
-        for (i = 0; i < ms_aInfo[uMode].uPBits; i++)
-        {
-            if (uStartBit > 127)
-            {
-            #ifdef _DEBUG
-                OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
-            #endif
-                FillWithErrorColors(pOut);
-                return;
-            }
-
-            P[i] = GetBit(uStartBit);
-        }
-
-        if (ms_aInfo[uMode].uPBits)
-        {
-            for (i = 0; i < uNumEndPts; i++)
-            {
-                size_t pi = i * ms_aInfo[uMode].uPBits / uNumEndPts;
-                for (uint8_t ch = 0; ch < BC7_NUM_CHANNELS; ch++)
-                {
-                    if (RGBAPrec[ch] != RGBAPrecWithP[ch])
-                    {
-                        c[i][ch] = static_cast<uint8_t>((unsigned(c[i][ch]) << 1) | P[pi]);
-                    }
-                }
-            }
-        }
-
-        for (i = 0; i < uNumEndPts; i++)
-        {
-            c[i] = Unquantize(c[i], RGBAPrecWithP);
-        }
-
-        uint8_t w1[NUM_PIXELS_PER_BLOCK], w2[NUM_PIXELS_PER_BLOCK];
-
-        // read color indices
-        for (i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-        {
-            const size_t uNumBits = IsFixUpOffset(ms_aInfo[uMode].uPartitions, uShape, i) ? uIndexPrec - 1u : uIndexPrec;
-            if (uStartBit + uNumBits > 128)
-            {
-            #ifdef _DEBUG
-                OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
-            #endif
-                FillWithErrorColors(pOut);
-                return;
-            }
-            w1[i] = GetBits(uStartBit, uNumBits);
-        }
-
-        // read alpha indices
-        if (uIndexPrec2)
-        {
-            for (i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-            {
-                const size_t uNumBits = i ? uIndexPrec2 : uIndexPrec2 - 1u;
-                if (uStartBit + uNumBits > 128)
-                {
-                #ifdef _DEBUG
-                    OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
-                #endif
-                    FillWithErrorColors(pOut);
-                    return;
-                }
-                w2[i] = GetBits(uStartBit, uNumBits);
-            }
-        }
-
-        for (i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-        {
-            const uint8_t uRegion = g_aPartitionTable[uPartitions][uShape][i];
-            LDRColorA outPixel;
-            if (uIndexPrec2 == 0)
-            {
-                LDRColorA::Interpolate(c[uRegion << 1], c[(uRegion << 1) + 1], w1[i], w1[i], uIndexPrec, uIndexPrec, outPixel);
-            }
-            else
-            {
-                if (uIndexMode == 0)
-                {
-                    LDRColorA::Interpolate(c[uRegion << 1], c[(uRegion << 1) + 1], w1[i], w2[i], uIndexPrec, uIndexPrec2, outPixel);
-                }
-                else
-                {
-                    LDRColorA::Interpolate(c[uRegion << 1], c[(uRegion << 1) + 1], w2[i], w1[i], uIndexPrec2, uIndexPrec, outPixel);
-                }
-            }
-
-            switch (uRotation)
-            {
-            case 1: std::swap(outPixel.r, outPixel.a); break;
-            case 2: std::swap(outPixel.g, outPixel.a); break;
-            case 3: std::swap(outPixel.b, outPixel.a); break;
-            }
-
-            pOut[i] = HDRColorA(outPixel);
-        }
-    }
-    else
-    {
-    #ifdef _DEBUG
-        OutputDebugStringA("BC7: Reserved mode 8 encountered during decoding\n");
-    #endif
-        // Per the BC7 format spec, we must return transparent black
-        memset(pOut, 0, sizeof(HDRColorA) * NUM_PIXELS_PER_BLOCK);
-    }
-}
-
-_Use_decl_annotations_
-void D3DX_BC7::Encode(uint32_t flags, const HDRColorA* const pIn) noexcept
-{
-    assert(pIn);
-
-    D3DX_BC7 final = *this;
-    EncodeParams EP(pIn);
-    float fMSEBest = FLT_MAX;
-    uint32_t alphaMask = 0xFF;
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-    {
-        EP.aLDRPixels[i].r = uint8_t(std::max<float>(0.0f, std::min<float>(255.0f, pIn[i].r * 255.0f + 0.01f)));
-        EP.aLDRPixels[i].g = uint8_t(std::max<float>(0.0f, std::min<float>(255.0f, pIn[i].g * 255.0f + 0.01f)));
-        EP.aLDRPixels[i].b = uint8_t(std::max<float>(0.0f, std::min<float>(255.0f, pIn[i].b * 255.0f + 0.01f)));
-        EP.aLDRPixels[i].a = uint8_t(std::max<float>(0.0f, std::min<float>(255.0f, pIn[i].a * 255.0f + 0.01f)));
-        alphaMask &= EP.aLDRPixels[i].a;
-    }
-
-    const bool bHasAlpha = (alphaMask != 0xFF);
-
-    for (EP.uMode = 0; EP.uMode < 8 && fMSEBest > 0; ++EP.uMode)
-    {
-        if (!(flags & BC_FLAGS_USE_3SUBSETS) && (EP.uMode == 0 || EP.uMode == 2))
-        {
-            // 3 subset modes tend to be used rarely and add significant compression time
-            continue;
-        }
-
-        if ((flags & TEX_COMPRESS_BC7_QUICK) && (EP.uMode != 6))
-        {
-            // Use only mode 6
-            continue;
-        }
-
-        if ((!bHasAlpha) && (EP.uMode == 7))
-        {
-            // There is no value in using mode 7 for completely opaque blocks (the other 2 subset modes handle this case for opaque blocks), so skip it for a small perf win.
-            continue;
-        }
-
-        const size_t uShapes = size_t(1) << ms_aInfo[EP.uMode].uPartitionBits;
-        assert(uShapes <= BC7_MAX_SHAPES);
-        _Analysis_assume_(uShapes <= BC7_MAX_SHAPES);
-
-        const size_t uNumRots = size_t(1) << ms_aInfo[EP.uMode].uRotationBits;
-        const size_t uNumIdxMode = size_t(1) << ms_aInfo[EP.uMode].uIndexModeBits;
-        // Number of rough cases to look at. reasonable values of this are 1, uShapes/4, and uShapes
-        // uShapes/4 gets nearly all the cases; you can increase that a bit (say by 3 or 4) if you really want to squeeze the last bit out
-        const size_t uItems = std::max<size_t>(1, uShapes >> 2);
-        float afRoughMSE[BC7_MAX_SHAPES];
-        size_t auShape[BC7_MAX_SHAPES];
-
-        for (size_t r = 0; r < uNumRots && fMSEBest > 0; ++r)
-        {
-            switch (r)
-            {
-            case 1: for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++) std::swap(EP.aLDRPixels[i].r, EP.aLDRPixels[i].a); break;
-            case 2: for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++) std::swap(EP.aLDRPixels[i].g, EP.aLDRPixels[i].a); break;
-            case 3: for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++) std::swap(EP.aLDRPixels[i].b, EP.aLDRPixels[i].a); break;
-            }
-
-            for (size_t im = 0; im < uNumIdxMode && fMSEBest > 0; ++im)
-            {
-                // pick the best uItems shapes and refine these.
-                for (size_t s = 0; s < uShapes; s++)
-                {
-                    afRoughMSE[s] = RoughMSE(&EP, s, im);
-                    auShape[s] = s;
-                }
-
-                // Bubble up the first uItems items
-                for (size_t i = 0; i < uItems; i++)
-                {
-                    for (size_t j = i + 1; j < uShapes; j++)
-                    {
-                        if (afRoughMSE[i] > afRoughMSE[j])
-                        {
-                            std::swap(afRoughMSE[i], afRoughMSE[j]);
-                            std::swap(auShape[i], auShape[j]);
-                        }
-                    }
-                }
-
-                for (size_t i = 0; i < uItems && fMSEBest > 0; i++)
-                {
-                    const float fMSE = Refine(&EP, auShape[i], r, im);
-                    if (fMSE < fMSEBest)
-                    {
-                        final = *this;
-                        fMSEBest = fMSE;
-                    }
-                }
-            }
-
-            switch (r)
-            {
-            case 1: for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++) std::swap(EP.aLDRPixels[i].r, EP.aLDRPixels[i].a); break;
-            case 2: for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++) std::swap(EP.aLDRPixels[i].g, EP.aLDRPixels[i].a); break;
-            case 3: for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++) std::swap(EP.aLDRPixels[i].b, EP.aLDRPixels[i].a); break;
-            }
-        }
-    }
-
-    *this = final;
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void D3DX_BC7::GeneratePaletteQuantized(const EncodeParams* pEP, size_t uIndexMode, const LDREndPntPair& endPts, LDRColorA aPalette[]) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const size_t uIndexPrec = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec2 : ms_aInfo[pEP->uMode].uIndexPrec;
-    const size_t uIndexPrec2 = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec : ms_aInfo[pEP->uMode].uIndexPrec2;
-    const size_t uNumIndices = size_t(1) << uIndexPrec;
-    const size_t uNumIndices2 = size_t(1) << uIndexPrec2;
-    assert(uNumIndices > 0 && uNumIndices2 > 0);
-    _Analysis_assume_(uNumIndices > 0 && uNumIndices2 > 0);
-    assert((uNumIndices <= BC7_MAX_INDICES) && (uNumIndices2 <= BC7_MAX_INDICES));
-    _Analysis_assume_((uNumIndices <= BC7_MAX_INDICES) && (uNumIndices2 <= BC7_MAX_INDICES));
-
-    const LDRColorA a = Unquantize(endPts.A, ms_aInfo[pEP->uMode].RGBAPrecWithP);
-    const LDRColorA b = Unquantize(endPts.B, ms_aInfo[pEP->uMode].RGBAPrecWithP);
-    if (uIndexPrec2 == 0)
-    {
-        for (size_t i = 0; i < uNumIndices; i++)
-            LDRColorA::Interpolate(a, b, i, i, uIndexPrec, uIndexPrec, aPalette[i]);
-    }
-    else
-    {
-        for (size_t i = 0; i < uNumIndices; i++)
-            LDRColorA::InterpolateRGB(a, b, i, uIndexPrec, aPalette[i]);
-        for (size_t i = 0; i < uNumIndices2; i++)
-            LDRColorA::InterpolateA(a, b, i, uIndexPrec2, aPalette[i]);
-    }
-}
-
-_Use_decl_annotations_
-float D3DX_BC7::PerturbOne(const EncodeParams* pEP, const LDRColorA aColors[], size_t np, size_t uIndexMode, size_t ch,
-    const LDREndPntPair &oldEndPts, LDREndPntPair &newEndPts, float fOldErr, uint8_t do_b) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const int prec = ms_aInfo[pEP->uMode].RGBAPrecWithP[ch];
-    LDREndPntPair tmp_endPts = newEndPts = oldEndPts;
-    float fMinErr = fOldErr;
-    uint8_t* pnew_c = (do_b ? &newEndPts.B[ch] : &newEndPts.A[ch]);
-    uint8_t* ptmp_c = (do_b ? &tmp_endPts.B[ch] : &tmp_endPts.A[ch]);
-
-    // do a logarithmic search for the best error for this endpoint (which)
-    for (int step = 1 << (prec - 1); step; step >>= 1)
-    {
-        bool bImproved = false;
-        int beststep = 0;
-        for (int sign = -1; sign <= 1; sign += 2)
-        {
-            int tmp = int(*pnew_c) + sign * step;
-            if (tmp < 0 || tmp >= (1 << prec))
-                continue;
-            else
-                *ptmp_c = static_cast<uint8_t>(tmp);
-
-            const float fTotalErr = MapColors(pEP, aColors, np, uIndexMode, tmp_endPts, fMinErr);
-            if (fTotalErr < fMinErr)
-            {
-                bImproved = true;
-                fMinErr = fTotalErr;
-                beststep = sign * step;
-            }
-        }
-
-        // if this was an improvement, move the endpoint and continue search from there
-        if (bImproved)
-            *pnew_c = uint8_t(int(*pnew_c) + beststep);
-    }
-    return fMinErr;
-}
-
-// perturb the endpoints at least -3 to 3.
-// always ensure endpoint ordering is preserved (no need to overlap the scan)
-_Use_decl_annotations_
-void D3DX_BC7::Exhaustive(const EncodeParams* pEP, const LDRColorA aColors[], size_t np, size_t uIndexMode, size_t ch,
-    float& fOrgErr, LDREndPntPair& optEndPt) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uPrec = ms_aInfo[pEP->uMode].RGBAPrecWithP[ch];
-    LDREndPntPair tmpEndPt;
-    if (fOrgErr == 0)
-        return;
-
-    constexpr int delta = 5;
-
-    // ok figure out the range of A and B
-    tmpEndPt = optEndPt;
-    const int alow = std::max<int>(0, int(optEndPt.A[ch]) - delta);
-    const int ahigh = std::min<int>((1 << uPrec) - 1, int(optEndPt.A[ch]) + delta);
-    const int blow = std::max<int>(0, int(optEndPt.B[ch]) - delta);
-    const int bhigh = std::min<int>((1 << uPrec) - 1, int(optEndPt.B[ch]) + delta);
-    int amin = 0;
-    int bmin = 0;
-
-    float fBestErr = fOrgErr;
-    if (optEndPt.A[ch] <= optEndPt.B[ch])
-    {
-        // keep a <= b
-        for (int a = alow; a <= ahigh; ++a)
-        {
-            for (int b = std::max<int>(a, blow); b < bhigh; ++b)
-            {
-                tmpEndPt.A[ch] = static_cast<uint8_t>(a);
-                tmpEndPt.B[ch] = static_cast<uint8_t>(b);
-
-                const float fErr = MapColors(pEP, aColors, np, uIndexMode, tmpEndPt, fBestErr);
-                if (fErr < fBestErr)
-                {
-                    amin = a;
-                    bmin = b;
-                    fBestErr = fErr;
-                }
-            }
-        }
-    }
-    else
-    {
-        // keep b <= a
-        for (int b = blow; b < bhigh; ++b)
-        {
-            for (int a = std::max<int>(b, alow); a <= ahigh; ++a)
-            {
-                tmpEndPt.A[ch] = static_cast<uint8_t>(a);
-                tmpEndPt.B[ch] = static_cast<uint8_t>(b);
-
-                const float fErr = MapColors(pEP, aColors, np, uIndexMode, tmpEndPt, fBestErr);
-                if (fErr < fBestErr)
-                {
-                    amin = a;
-                    bmin = b;
-                    fBestErr = fErr;
-                }
-            }
-        }
-    }
-
-    if (fBestErr < fOrgErr)
-    {
-        optEndPt.A[ch] = static_cast<uint8_t>(amin);
-        optEndPt.B[ch] = static_cast<uint8_t>(bmin);
-        fOrgErr = fBestErr;
-    }
-}
-
-_Use_decl_annotations_
-void D3DX_BC7::OptimizeOne(const EncodeParams* pEP, const LDRColorA aColors[], size_t np, size_t uIndexMode,
-    float fOrgErr, const LDREndPntPair& org, LDREndPntPair& opt) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    float fOptErr = fOrgErr;
-    opt = org;
-
-    LDREndPntPair new_a, new_b;
-    LDREndPntPair newEndPts;
-    uint8_t do_b;
-
-    // now optimize each channel separately
-    for (size_t ch = 0; ch < BC7_NUM_CHANNELS; ++ch)
-    {
-        if (ms_aInfo[pEP->uMode].RGBAPrecWithP[ch] == 0)
-            continue;
-
-        // figure out which endpoint when perturbed gives the most improvement and start there
-        // if we just alternate, we can easily end up in a local minima
-        const float fErr0 = PerturbOne(pEP, aColors, np, uIndexMode, ch, opt, new_a, fOptErr, 0);	// perturb endpt A
-        const float fErr1 = PerturbOne(pEP, aColors, np, uIndexMode, ch, opt, new_b, fOptErr, 1);	// perturb endpt B
-
-        uint8_t& copt_a = opt.A[ch];
-        uint8_t& copt_b = opt.B[ch];
-        uint8_t& cnew_a = new_a.A[ch];
-        uint8_t& cnew_b = new_a.B[ch];
-
-        if (fErr0 < fErr1)
-        {
-            if (fErr0 >= fOptErr)
-                continue;
-            copt_a = cnew_a;
-            fOptErr = fErr0;
-            do_b = 1;		// do B next
-        }
-        else
-        {
-            if (fErr1 >= fOptErr)
-                continue;
-            copt_b = cnew_b;
-            fOptErr = fErr1;
-            do_b = 0;		// do A next
-        }
-
-        // now alternate endpoints and keep trying until there is no improvement
-        for (; ; )
-        {
-            const float fErr = PerturbOne(pEP, aColors, np, uIndexMode, ch, opt, newEndPts, fOptErr, do_b);
-            if (fErr >= fOptErr)
-                break;
-            if (do_b == 0)
-                copt_a = cnew_a;
-            else
-                copt_b = cnew_b;
-            fOptErr = fErr;
-            do_b = 1u - do_b;	// now move the other endpoint
-        }
-    }
-
-    // finally, do a small exhaustive search around what we think is the global minima to be sure
-    for (size_t ch = 0; ch < BC7_NUM_CHANNELS; ch++)
-        Exhaustive(pEP, aColors, np, uIndexMode, ch, fOptErr, opt);
-}
-
-_Use_decl_annotations_
-void D3DX_BC7::OptimizeEndPoints(const EncodeParams* pEP, size_t uShape, size_t uIndexMode, const float afOrgErr[],
-    const LDREndPntPair aOrgEndPts[], LDREndPntPair aOptEndPts[]) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC7_MAX_REGIONS && uShape < BC7_MAX_SHAPES);
-    _Analysis_assume_(uPartitions < BC7_MAX_REGIONS && uShape < BC7_MAX_SHAPES);
-
-    LDRColorA aPixels[NUM_PIXELS_PER_BLOCK];
-
-    for (size_t p = 0; p <= uPartitions; ++p)
-    {
-        // collect the pixels in the region
-        size_t np = 0;
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-            if (g_aPartitionTable[uPartitions][uShape][i] == p)
-                aPixels[np++] = pEP->aLDRPixels[i];
-
-        OptimizeOne(pEP, aPixels, np, uIndexMode, afOrgErr[p], aOrgEndPts[p], aOptEndPts[p]);
-    }
-}
-
-_Use_decl_annotations_
-void D3DX_BC7::AssignIndices(const EncodeParams* pEP, size_t uShape, size_t uIndexMode, LDREndPntPair endPts[], size_t aIndices[], size_t aIndices2[],
-    float afTotErr[]) const noexcept
-{
-    assert(pEP);
-    assert(uShape < BC7_MAX_SHAPES);
-    _Analysis_assume_(uShape < BC7_MAX_SHAPES);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC7_MAX_REGIONS);
-    _Analysis_assume_(uPartitions < BC7_MAX_REGIONS);
-
-    const uint8_t uIndexPrec = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec2 : ms_aInfo[pEP->uMode].uIndexPrec;
-    const uint8_t uIndexPrec2 = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec : ms_aInfo[pEP->uMode].uIndexPrec2;
-    auto const uNumIndices = static_cast<const uint8_t>(1u << uIndexPrec);
-    auto const uNumIndices2 = static_cast<const uint8_t>(1u << uIndexPrec2);
-
-    assert((uNumIndices <= BC7_MAX_INDICES) && (uNumIndices2 <= BC7_MAX_INDICES));
-    _Analysis_assume_((uNumIndices <= BC7_MAX_INDICES) && (uNumIndices2 <= BC7_MAX_INDICES));
-
-    const uint8_t uHighestIndexBit = uint8_t(uNumIndices >> 1);
-    const uint8_t uHighestIndexBit2 = uint8_t(uNumIndices2 >> 1);
-    LDRColorA aPalette[BC7_MAX_REGIONS][BC7_MAX_INDICES];
-
-    // build list of possibles
-    for (size_t p = 0; p <= uPartitions; p++)
-    {
-        GeneratePaletteQuantized(pEP, uIndexMode, endPts[p], aPalette[p]);
-        afTotErr[p] = 0;
-    }
-
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-    {
-        uint8_t uRegion = g_aPartitionTable[uPartitions][uShape][i];
-        assert(uRegion < BC7_MAX_REGIONS);
-        _Analysis_assume_(uRegion < BC7_MAX_REGIONS);
-        afTotErr[uRegion] += ComputeError(pEP->aLDRPixels[i], aPalette[uRegion], uIndexPrec, uIndexPrec2, &(aIndices[i]), &(aIndices2[i]));
-    }
-
-    // swap endpoints as needed to ensure that the indices at index_positions have a 0 high-order bit
-    if (uIndexPrec2 == 0)
-    {
-        for (size_t p = 0; p <= uPartitions; p++)
-        {
-            if (aIndices[g_aFixUp[uPartitions][uShape][p]] & uHighestIndexBit)
-            {
-                std::swap(endPts[p].A, endPts[p].B);
-                for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-                    if (g_aPartitionTable[uPartitions][uShape][i] == p)
-                        aIndices[i] = uNumIndices - 1 - aIndices[i];
-            }
-            assert((aIndices[g_aFixUp[uPartitions][uShape][p]] & uHighestIndexBit) == 0);
-        }
-    }
-    else
-    {
-        for (size_t p = 0; p <= uPartitions; p++)
-        {
-            if (aIndices[g_aFixUp[uPartitions][uShape][p]] & uHighestIndexBit)
-            {
-                std::swap(endPts[p].A.r, endPts[p].B.r);
-                std::swap(endPts[p].A.g, endPts[p].B.g);
-                std::swap(endPts[p].A.b, endPts[p].B.b);
-                for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-                    if (g_aPartitionTable[uPartitions][uShape][i] == p)
-                        aIndices[i] = uNumIndices - 1 - aIndices[i];
-            }
-            assert((aIndices[g_aFixUp[uPartitions][uShape][p]] & uHighestIndexBit) == 0);
-
-            if (aIndices2[0] & uHighestIndexBit2)
-            {
-                std::swap(endPts[p].A.a, endPts[p].B.a);
-                for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-                    aIndices2[i] = uNumIndices2 - 1 - aIndices2[i];
-            }
-            assert((aIndices2[0] & uHighestIndexBit2) == 0);
-        }
-    }
-}
-
-_Use_decl_annotations_
-void D3DX_BC7::EmitBlock(const EncodeParams* pEP, size_t uShape, size_t uRotation, size_t uIndexMode, const LDREndPntPair aEndPts[], const size_t aIndex[], const size_t aIndex2[]) noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC7_MAX_REGIONS);
-    _Analysis_assume_(uPartitions < BC7_MAX_REGIONS);
-
-    const size_t uPBits = ms_aInfo[pEP->uMode].uPBits;
-    const size_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
-    const size_t uIndexPrec2 = ms_aInfo[pEP->uMode].uIndexPrec2;
-    const LDRColorA RGBAPrec = ms_aInfo[pEP->uMode].RGBAPrec;
-    const LDRColorA RGBAPrecWithP = ms_aInfo[pEP->uMode].RGBAPrecWithP;
-    size_t i;
-    size_t uStartBit = 0;
-    SetBits(uStartBit, pEP->uMode, 0);
-    SetBits(uStartBit, 1, 1);
-    SetBits(uStartBit, ms_aInfo[pEP->uMode].uRotationBits, static_cast<uint8_t>(uRotation));
-    SetBits(uStartBit, ms_aInfo[pEP->uMode].uIndexModeBits, static_cast<uint8_t>(uIndexMode));
-    SetBits(uStartBit, ms_aInfo[pEP->uMode].uPartitionBits, static_cast<uint8_t>(uShape));
-
-    if (uPBits)
-    {
-        const size_t uNumEP = (size_t(uPartitions) + 1) << 1;
-        uint8_t aPVote[BC7_MAX_REGIONS << 1] = { 0,0,0,0,0,0 };
-        uint8_t aCount[BC7_MAX_REGIONS << 1] = { 0,0,0,0,0,0 };
-        for (uint8_t ch = 0; ch < BC7_NUM_CHANNELS; ch++)
-        {
-            uint8_t ep = 0;
-            for (i = 0; i <= uPartitions; i++)
-            {
-                if (RGBAPrec[ch] == RGBAPrecWithP[ch])
-                {
-                    SetBits(uStartBit, RGBAPrec[ch], aEndPts[i].A[ch]);
-                    SetBits(uStartBit, RGBAPrec[ch], aEndPts[i].B[ch]);
-                }
-                else
-                {
-                    SetBits(uStartBit, RGBAPrec[ch], uint8_t(aEndPts[i].A[ch] >> 1));
-                    SetBits(uStartBit, RGBAPrec[ch], uint8_t(aEndPts[i].B[ch] >> 1));
-                    size_t idx = ep++ * uPBits / uNumEP;
-                    assert(idx < (BC7_MAX_REGIONS << 1));
-                    _Analysis_assume_(idx < (BC7_MAX_REGIONS << 1));
-                    aPVote[idx] += aEndPts[i].A[ch] & 0x01;
-                    aCount[idx]++;
-                    idx = ep++ * uPBits / uNumEP;
-                    assert(idx < (BC7_MAX_REGIONS << 1));
-                    _Analysis_assume_(idx < (BC7_MAX_REGIONS << 1));
-                    aPVote[idx] += aEndPts[i].B[ch] & 0x01;
-                    aCount[idx]++;
-                }
-            }
-        }
-
-        for (i = 0; i < uPBits; i++)
-        {
-            SetBits(uStartBit, 1, (aPVote[i] >(aCount[i] >> 1)) ? 1u : 0u);
-        }
-    }
-    else
-    {
-        for (size_t ch = 0; ch < BC7_NUM_CHANNELS; ch++)
-        {
-            for (i = 0; i <= uPartitions; i++)
-            {
-                SetBits(uStartBit, RGBAPrec[ch], aEndPts[i].A[ch]);
-                SetBits(uStartBit, RGBAPrec[ch], aEndPts[i].B[ch]);
-            }
-        }
-    }
-
-    const size_t* aI1 = uIndexMode ? aIndex2 : aIndex;
-    const size_t* aI2 = uIndexMode ? aIndex : aIndex2;
-    for (i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-    {
-        if (IsFixUpOffset(ms_aInfo[pEP->uMode].uPartitions, uShape, i))
-            SetBits(uStartBit, uIndexPrec - 1, static_cast<uint8_t>(aI1[i]));
-        else
-            SetBits(uStartBit, uIndexPrec, static_cast<uint8_t>(aI1[i]));
-    }
-    if (uIndexPrec2)
-        for (i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-            SetBits(uStartBit, i ? uIndexPrec2 : uIndexPrec2 - 1, static_cast<uint8_t>(aI2[i]));
-
-    assert(uStartBit == 128);
-}
-
-_Use_decl_annotations_
-void D3DX_BC7::FixEndpointPBits(const EncodeParams* pEP, const LDREndPntPair *pOrigEndpoints, LDREndPntPair *pFixedEndpoints) noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const size_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC7_MAX_REGIONS);
-    _Analysis_assume_(uPartitions < BC7_MAX_REGIONS);
-
-    pFixedEndpoints[0] = pOrigEndpoints[0];
-    pFixedEndpoints[1] = pOrigEndpoints[1];
-    pFixedEndpoints[2] = pOrigEndpoints[2];
-
-    const size_t uPBits = ms_aInfo[pEP->uMode].uPBits;
-
-    if (uPBits)
-    {
-        const size_t uNumEP = size_t(1 + uPartitions) << 1;
-        uint8_t aPVote[BC7_MAX_REGIONS << 1] = { 0,0,0,0,0,0 };
-        uint8_t aCount[BC7_MAX_REGIONS << 1] = { 0,0,0,0,0,0 };
-
-        const LDRColorA RGBAPrec = ms_aInfo[pEP->uMode].RGBAPrec;
-        const LDRColorA RGBAPrecWithP = ms_aInfo[pEP->uMode].RGBAPrecWithP;
-
-        for (uint8_t ch = 0; ch < BC7_NUM_CHANNELS; ch++)
-        {
-            uint8_t ep = 0;
-            for (size_t i = 0; i <= uPartitions; i++)
-            {
-                if (RGBAPrec[ch] == RGBAPrecWithP[ch])
-                {
-                    pFixedEndpoints[i].A[ch] = pOrigEndpoints[i].A[ch];
-                    pFixedEndpoints[i].B[ch] = pOrigEndpoints[i].B[ch];
-                }
-                else
-                {
-                    pFixedEndpoints[i].A[ch] = uint8_t(pOrigEndpoints[i].A[ch] >> 1);
-                    pFixedEndpoints[i].B[ch] = uint8_t(pOrigEndpoints[i].B[ch] >> 1);
-
-                    size_t idx = ep++ * uPBits / uNumEP;
-                    assert(idx < (BC7_MAX_REGIONS << 1));
-                    _Analysis_assume_(idx < (BC7_MAX_REGIONS << 1));
-                    aPVote[idx] += pOrigEndpoints[i].A[ch] & 0x01;
-                    aCount[idx]++;
-                    idx = ep++ * uPBits / uNumEP;
-                    assert(idx < (BC7_MAX_REGIONS << 1));
-                    _Analysis_assume_(idx < (BC7_MAX_REGIONS << 1));
-                    aPVote[idx] += pOrigEndpoints[i].B[ch] & 0x01;
-                    aCount[idx]++;
-                }
-            }
-        }
-
-        // Compute the actual pbits we'll use when we encode block. Note this is not
-        // rounding the component indices correctly in cases the pbits != a component's LSB.
-        int pbits[BC7_MAX_REGIONS << 1];
-        for (size_t i = 0; i < uPBits; i++)
-            pbits[i] = aPVote[i] >(aCount[i] >> 1) ? 1 : 0;
-
-        // Now calculate the actual endpoints with proper pbits, so error calculations are accurate.
-        if (pEP->uMode == 1)
-        {
-            // shared pbits
-            for (uint8_t ch = 0; ch < BC7_NUM_CHANNELS; ch++)
-            {
-                for (size_t i = 0; i <= uPartitions; i++)
-                {
-                    pFixedEndpoints[i].A[ch] = static_cast<uint8_t>((pFixedEndpoints[i].A[ch] << 1) | pbits[i]);
-                    pFixedEndpoints[i].B[ch] = static_cast<uint8_t>((pFixedEndpoints[i].B[ch] << 1) | pbits[i]);
-                }
-            }
-        }
-        else
-        {
-            for (uint8_t ch = 0; ch < BC7_NUM_CHANNELS; ch++)
-            {
-                for (size_t i = 0; i <= uPartitions; i++)
-                {
-                    pFixedEndpoints[i].A[ch] = static_cast<uint8_t>((pFixedEndpoints[i].A[ch] << 1) | pbits[i * 2 + 0]);
-                    pFixedEndpoints[i].B[ch] = static_cast<uint8_t>((pFixedEndpoints[i].B[ch] << 1) | pbits[i * 2 + 1]);
-                }
-            }
-        }
-    }
-}
-
-_Use_decl_annotations_
-float D3DX_BC7::Refine(const EncodeParams* pEP, size_t uShape, size_t uRotation, size_t uIndexMode) noexcept
-{
-    assert(pEP);
-    assert(uShape < BC7_MAX_SHAPES);
-    _Analysis_assume_(uShape < BC7_MAX_SHAPES);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const size_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC7_MAX_REGIONS);
-    _Analysis_assume_(uPartitions < BC7_MAX_REGIONS);
-
-    LDREndPntPair aOrgEndPts[BC7_MAX_REGIONS];
-    LDREndPntPair aOptEndPts[BC7_MAX_REGIONS];
-    size_t aOrgIdx[NUM_PIXELS_PER_BLOCK];
-    size_t aOrgIdx2[NUM_PIXELS_PER_BLOCK];
-    size_t aOptIdx[NUM_PIXELS_PER_BLOCK];
-    size_t aOptIdx2[NUM_PIXELS_PER_BLOCK];
-    float aOrgErr[BC7_MAX_REGIONS];
-    float aOptErr[BC7_MAX_REGIONS];
-
-    const LDREndPntPair* aEndPts = &pEP->aEndPts[uShape][0];
-
-    for (size_t p = 0; p <= uPartitions; p++)
-    {
-        aOrgEndPts[p].A = Quantize(aEndPts[p].A, ms_aInfo[pEP->uMode].RGBAPrecWithP);
-        aOrgEndPts[p].B = Quantize(aEndPts[p].B, ms_aInfo[pEP->uMode].RGBAPrecWithP);
-    }
-
-    LDREndPntPair newEndPts1[BC7_MAX_REGIONS];
-    FixEndpointPBits(pEP, aOrgEndPts, newEndPts1);
-
-    AssignIndices(pEP, uShape, uIndexMode, newEndPts1, aOrgIdx, aOrgIdx2, aOrgErr);
-
-    OptimizeEndPoints(pEP, uShape, uIndexMode, aOrgErr, newEndPts1, aOptEndPts);
-
-    LDREndPntPair newEndPts2[BC7_MAX_REGIONS];
-    FixEndpointPBits(pEP, aOptEndPts, newEndPts2);
-
-    AssignIndices(pEP, uShape, uIndexMode, newEndPts2, aOptIdx, aOptIdx2, aOptErr);
-
-    float fOrgTotErr = 0, fOptTotErr = 0;
-    for (size_t p = 0; p <= uPartitions; p++)
-    {
-        fOrgTotErr += aOrgErr[p];
-        fOptTotErr += aOptErr[p];
-    }
-    if (fOptTotErr < fOrgTotErr)
-    {
-        EmitBlock(pEP, uShape, uRotation, uIndexMode, newEndPts2, aOptIdx, aOptIdx2);
-        return fOptTotErr;
-    }
-    else
-    {
-        EmitBlock(pEP, uShape, uRotation, uIndexMode, newEndPts1, aOrgIdx, aOrgIdx2);
-        return fOrgTotErr;
-    }
-}
-
-_Use_decl_annotations_
-float D3DX_BC7::MapColors(const EncodeParams* pEP, const LDRColorA aColors[], size_t np, size_t uIndexMode, const LDREndPntPair& endPts, float fMinErr) const noexcept
-{
-    assert(pEP);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    const uint8_t uIndexPrec = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec2 : ms_aInfo[pEP->uMode].uIndexPrec;
-    const uint8_t uIndexPrec2 = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec : ms_aInfo[pEP->uMode].uIndexPrec2;
-    LDRColorA aPalette[BC7_MAX_INDICES];
-    float fTotalErr = 0;
-
-    GeneratePaletteQuantized(pEP, uIndexMode, endPts, aPalette);
-    for (size_t i = 0; i < np; ++i)
-    {
-        fTotalErr += ComputeError(aColors[i], aPalette, uIndexPrec, uIndexPrec2);
-        if (fTotalErr > fMinErr)   // check for early exit
-        {
-            fTotalErr = FLT_MAX;
-            break;
-        }
-    }
-
-    return fTotalErr;
-}
-
-_Use_decl_annotations_
-float D3DX_BC7::RoughMSE(EncodeParams* pEP, size_t uShape, size_t uIndexMode) noexcept
-{
-    assert(pEP);
-    assert(uShape < BC7_MAX_SHAPES);
-    _Analysis_assume_(uShape < BC7_MAX_SHAPES);
-    assert(pEP->uMode < c_NumModes);
-    _Analysis_assume_(pEP->uMode < c_NumModes);
-
-    LDREndPntPair* aEndPts = pEP->aEndPts[uShape];
-
-    const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
-    assert(uPartitions < BC7_MAX_REGIONS);
-    _Analysis_assume_(uPartitions < BC7_MAX_REGIONS);
-
-    const uint8_t uIndexPrec = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec2 : ms_aInfo[pEP->uMode].uIndexPrec;
-    const uint8_t uIndexPrec2 = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec : ms_aInfo[pEP->uMode].uIndexPrec2;
-    auto const uNumIndices = static_cast<const uint8_t>(1u << uIndexPrec);
-    auto const uNumIndices2 = static_cast<const uint8_t>(1u << uIndexPrec2);
-    size_t auPixIdx[NUM_PIXELS_PER_BLOCK];
-    LDRColorA aPalette[BC7_MAX_REGIONS][BC7_MAX_INDICES];
-
-    for (size_t p = 0; p <= uPartitions; p++)
-    {
-        size_t np = 0;
-        for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-        {
-            if (g_aPartitionTable[uPartitions][uShape][i] == p)
-            {
-                auPixIdx[np++] = i;
-            }
-        }
-
-        // handle simple cases
-        assert(np > 0);
-        if (np == 1)
-        {
-            aEndPts[p].A = pEP->aLDRPixels[auPixIdx[0]];
-            aEndPts[p].B = pEP->aLDRPixels[auPixIdx[0]];
-            continue;
-        }
-        else if (np == 2)
-        {
-            aEndPts[p].A = pEP->aLDRPixels[auPixIdx[0]];
-            aEndPts[p].B = pEP->aLDRPixels[auPixIdx[1]];
-            continue;
-        }
-
-        if (uIndexPrec2 == 0)
-        {
-            HDRColorA epA, epB;
-            OptimizeRGBA(pEP->aHDRPixels, &epA, &epB, 4, np, auPixIdx);
-            epA.Clamp(0.0f, 1.0f);
-            epB.Clamp(0.0f, 1.0f);
-            epA *= 255.0f;
-            epB *= 255.0f;
-            aEndPts[p].A = epA.ToLDRColorA();
-            aEndPts[p].B = epB.ToLDRColorA();
-        }
-        else
-        {
-            uint8_t uMinAlpha = 255, uMaxAlpha = 0;
-            for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
-            {
-                uMinAlpha = std::min<uint8_t>(uMinAlpha, pEP->aLDRPixels[auPixIdx[i]].a);
-                uMaxAlpha = std::max<uint8_t>(uMaxAlpha, pEP->aLDRPixels[auPixIdx[i]].a);
-            }
-
-            HDRColorA epA, epB;
-            OptimizeRGB(pEP->aHDRPixels, &epA, &epB, 4, np, auPixIdx);
-            epA.Clamp(0.0f, 1.0f);
-            epB.Clamp(0.0f, 1.0f);
-            epA *= 255.0f;
-            epB *= 255.0f;
-            aEndPts[p].A = epA.ToLDRColorA();
-            aEndPts[p].B = epB.ToLDRColorA();
-            aEndPts[p].A.a = uMinAlpha;
-            aEndPts[p].B.a = uMaxAlpha;
-        }
-    }
-
-    if (uIndexPrec2 == 0)
-    {
-        for (size_t p = 0; p <= uPartitions; p++)
-            for (size_t i = 0; i < uNumIndices; i++)
-                LDRColorA::Interpolate(aEndPts[p].A, aEndPts[p].B, i, i, uIndexPrec, uIndexPrec, aPalette[p][i]);
-    }
-    else
-    {
-        for (size_t p = 0; p <= uPartitions; p++)
-        {
-            for (size_t i = 0; i < uNumIndices; i++)
-                LDRColorA::InterpolateRGB(aEndPts[p].A, aEndPts[p].B, i, uIndexPrec, aPalette[p][i]);
-            for (size_t i = 0; i < uNumIndices2; i++)
-                LDRColorA::InterpolateA(aEndPts[p].A, aEndPts[p].B, i, uIndexPrec2, aPalette[p][i]);
-        }
-    }
-
-    float fTotalErr = 0;
-    for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; i++)
-    {
-        const uint8_t uRegion = g_aPartitionTable[uPartitions][uShape][i];
-        fTotalErr += ComputeError(pEP->aLDRPixels[i], aPalette[uRegion], uIndexPrec, uIndexPrec2);
-    }
-
-    return fTotalErr;
-}
-
-
-//=====================================================================================
-// Entry points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// BC6H Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC6HU(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    assert(pColor && pBC);
-    static_assert(sizeof(D3DX_BC6H) == 16, "D3DX_BC6H should be 16 bytes");
-    reinterpret_cast<const D3DX_BC6H*>(pBC)->Decode(false, reinterpret_cast<HDRColorA*>(pColor));
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC6HS(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    assert(pColor && pBC);
-    static_assert(sizeof(D3DX_BC6H) == 16, "D3DX_BC6H should be 16 bytes");
-    reinterpret_cast<const D3DX_BC6H*>(pBC)->Decode(true, reinterpret_cast<HDRColorA*>(pColor));
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC6HU(uint8_t *pBC, const XMVECTOR *pColor, uint32_t flags) noexcept
-{
-    UNREFERENCED_PARAMETER(flags);
-    assert(pBC && pColor);
-    static_assert(sizeof(D3DX_BC6H) == 16, "D3DX_BC6H should be 16 bytes");
-    reinterpret_cast<D3DX_BC6H*>(pBC)->Encode(false, reinterpret_cast<const HDRColorA*>(pColor));
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC6HS(uint8_t *pBC, const XMVECTOR *pColor, uint32_t flags) noexcept
-{
-    UNREFERENCED_PARAMETER(flags);
-    assert(pBC && pColor);
-    static_assert(sizeof(D3DX_BC6H) == 16, "D3DX_BC6H should be 16 bytes");
-    reinterpret_cast<D3DX_BC6H*>(pBC)->Encode(true, reinterpret_cast<const HDRColorA*>(pColor));
-}
-
-
-//-------------------------------------------------------------------------------------
-// BC7 Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void DirectX::D3DXDecodeBC7(XMVECTOR *pColor, const uint8_t *pBC) noexcept
-{
-    assert(pColor && pBC);
-    static_assert(sizeof(D3DX_BC7) == 16, "D3DX_BC7 should be 16 bytes");
-    reinterpret_cast<const D3DX_BC7*>(pBC)->Decode(reinterpret_cast<HDRColorA*>(pColor));
-}
-
-_Use_decl_annotations_
-void DirectX::D3DXEncodeBC7(uint8_t *pBC, const XMVECTOR *pColor, uint32_t flags) noexcept
-{
-    assert(pBC && pColor);
-    static_assert(sizeof(D3DX_BC7) == 16, "D3DX_BC7 should be 16 bytes");
-    reinterpret_cast<D3DX_BC7*>(pBC)->Encode(flags, reinterpret_cast<const HDRColorA*>(pColor));
-}
diff --git a/thirdparty/directxtex/BCDirectCompute.cpp b/thirdparty/directxtex/BCDirectCompute.cpp
deleted file mode 100644
index a98ef8b..0000000
--- a/thirdparty/directxtex/BCDirectCompute.cpp
+++ /dev/null
@@ -1,616 +0,0 @@
-//-------------------------------------------------------------------------------------
-// BCDirectCompute.cpp
-//
-// Direct3D 11 Compute Shader BC Compressor
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#include "BCDirectCompute.h"
-
-#if defined(_DEBUG) || defined(PROFILE)
-#pragma comment(lib,"dxguid.lib")
-#endif
-
-using namespace DirectX;
-using Microsoft::WRL::ComPtr;
-
-namespace
-{
-#include "BC7Encode_EncodeBlockCS.inc"
-#include "BC7Encode_TryMode02CS.inc"
-#include "BC7Encode_TryMode137CS.inc"
-#include "BC7Encode_TryMode456CS.inc"
-#include "BC6HEncode_EncodeBlockCS.inc"
-#include "BC6HEncode_TryModeG10CS.inc"
-#include "BC6HEncode_TryModeLE10CS.inc"
-
-    struct BufferBC6HBC7
-    {
-        UINT color[4];
-    };
-
-    struct ConstantsBC6HBC7
-    {
-        UINT    tex_width;
-        UINT    num_block_x;
-        UINT    format;
-        UINT    mode_id;
-        UINT    start_block_id;
-        UINT    num_total_blocks;
-        float   alpha_weight;
-        UINT    reserved;
-    };
-
-    static_assert(sizeof(ConstantsBC6HBC7) == sizeof(UINT) * 8, "Constant buffer size mismatch");
-
-    inline void RunComputeShader(ID3D11DeviceContext* pContext,
-        ID3D11ComputeShader* shader,
-        ID3D11ShaderResourceView** pSRVs,
-        UINT srvCount,
-        ID3D11Buffer* pCB,
-        ID3D11UnorderedAccessView* pUAV,
-        UINT X)
-    {
-        // Force UAV to nullptr before setting SRV since we are swapping buffers
-        ID3D11UnorderedAccessView* nullUAV = nullptr;
-        pContext->CSSetUnorderedAccessViews(0, 1, &nullUAV, nullptr);
-
-        pContext->CSSetShader(shader, nullptr, 0);
-        pContext->CSSetShaderResources(0, srvCount, pSRVs);
-        pContext->CSSetUnorderedAccessViews(0, 1, &pUAV, nullptr);
-        pContext->CSSetConstantBuffers(0, 1, &pCB);
-        pContext->Dispatch(X, 1, 1);
-    }
-
-    inline void ResetContext(ID3D11DeviceContext* pContext)
-    {
-        ID3D11UnorderedAccessView* nullUAV = nullptr;
-        pContext->CSSetUnorderedAccessViews(0, 1, &nullUAV, nullptr);
-
-        ID3D11ShaderResourceView* nullSRV[3] = { nullptr, nullptr, nullptr };
-        pContext->CSSetShaderResources(0, 3, nullSRV);
-
-        ID3D11Buffer* nullBuffer[1] = { nullptr };
-        pContext->CSSetConstantBuffers(0, 1, nullBuffer);
-    }
-};
-
-GPUCompressBC::GPUCompressBC() noexcept :
-    m_bcformat(DXGI_FORMAT_UNKNOWN),
-    m_srcformat(DXGI_FORMAT_UNKNOWN),
-    m_alphaWeight(1.f),
-    m_bc7_mode02(false),
-    m_bc7_mode137(false),
-    m_width(0),
-    m_height(0)
-{
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT GPUCompressBC::Initialize(ID3D11Device* pDevice)
-{
-    if (!pDevice)
-        return E_INVALIDARG;
-
-    // Check for DirectCompute support
-    const D3D_FEATURE_LEVEL fl = pDevice->GetFeatureLevel();
-
-    if (fl < D3D_FEATURE_LEVEL_10_0)
-    {
-        // DirectCompute not supported on Feature Level 9.x hardware
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    if (fl < D3D_FEATURE_LEVEL_11_0)
-    {
-        // DirectCompute support on Feature Level 10.x hardware is optional, and this function needs it
-        D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS hwopts;
-        HRESULT hr = pDevice->CheckFeatureSupport(D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS, &hwopts, sizeof(hwopts));
-        if (FAILED(hr))
-        {
-            memset(&hwopts, 0, sizeof(hwopts));
-        }
-
-        if (!hwopts.ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x)
-        {
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-    }
-
-    // Save a device reference and obtain immediate context
-    m_device = pDevice;
-
-    pDevice->GetImmediateContext(m_context.ReleaseAndGetAddressOf());
-    assert(m_context);
-
-    //--- Create compute shader library: BC6H -----------------------------------------
-
-    // Modes 11-14
-    HRESULT hr = pDevice->CreateComputeShader(BC6HEncode_TryModeG10CS, sizeof(BC6HEncode_TryModeG10CS), nullptr, m_BC6H_tryModeG10CS.ReleaseAndGetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    // Modes 1-10
-    hr = pDevice->CreateComputeShader(BC6HEncode_TryModeLE10CS, sizeof(BC6HEncode_TryModeLE10CS), nullptr, m_BC6H_tryModeLE10CS.ReleaseAndGetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    // Encode
-    hr = pDevice->CreateComputeShader(BC6HEncode_EncodeBlockCS, sizeof(BC6HEncode_EncodeBlockCS), nullptr, m_BC6H_encodeBlockCS.ReleaseAndGetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    //--- Create compute shader library: BC7 ------------------------------------------
-
-    // Modes 4, 5, 6
-    hr = pDevice->CreateComputeShader(BC7Encode_TryMode456CS, sizeof(BC7Encode_TryMode456CS), nullptr, m_BC7_tryMode456CS.ReleaseAndGetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    // Modes 1, 3, 7
-    hr = pDevice->CreateComputeShader(BC7Encode_TryMode137CS, sizeof(BC7Encode_TryMode137CS), nullptr, m_BC7_tryMode137CS.ReleaseAndGetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    // Modes 0, 2
-    hr = pDevice->CreateComputeShader(BC7Encode_TryMode02CS, sizeof(BC7Encode_TryMode02CS), nullptr, m_BC7_tryMode02CS.ReleaseAndGetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    // Encode
-    hr = pDevice->CreateComputeShader(BC7Encode_EncodeBlockCS, sizeof(BC7Encode_EncodeBlockCS), nullptr, m_BC7_encodeBlockCS.ReleaseAndGetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-HRESULT GPUCompressBC::Prepare(size_t width, size_t height, uint32_t flags, DXGI_FORMAT format, float alphaWeight)
-{
-    if (!width || !height || alphaWeight < 0.f)
-        return E_INVALIDARG;
-
-    if ((width > UINT32_MAX) || (height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    m_width = width;
-    m_height = height;
-
-    m_alphaWeight = alphaWeight;
-
-    if (flags & TEX_COMPRESS_BC7_QUICK)
-    {
-        m_bc7_mode02 = false;
-        m_bc7_mode137 = false;
-    }
-    else
-    {
-        m_bc7_mode02 = (flags & TEX_COMPRESS_BC7_USE_3SUBSETS) != 0;
-        m_bc7_mode137 = true;
-    }
-
-    const size_t xblocks = std::max<size_t>(1, (width + 3) >> 2);
-    const size_t yblocks = std::max<size_t>(1, (height + 3) >> 2);
-    const size_t num_blocks = xblocks * yblocks;
-
-    switch (format)
-    {
-        // BC6H GPU compressor takes RGBAF32 as input
-    case DXGI_FORMAT_BC6H_TYPELESS:
-    case DXGI_FORMAT_BC6H_UF16:
-    case DXGI_FORMAT_BC6H_SF16:
-        m_srcformat = DXGI_FORMAT_R32G32B32A32_FLOAT;
-        break;
-
-        // BC7 GPU compressor takes RGBA32 as input
-    case DXGI_FORMAT_BC7_TYPELESS:
-    case DXGI_FORMAT_BC7_UNORM:
-        m_srcformat = DXGI_FORMAT_R8G8B8A8_UNORM;
-        break;
-
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        m_srcformat = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
-        break;
-
-    default:
-        m_bcformat = m_srcformat = DXGI_FORMAT_UNKNOWN;
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    m_bcformat = format;
-
-    auto pDevice = m_device.Get();
-    if (!pDevice)
-        return E_POINTER;
-
-    // Create structured buffers
-    const uint64_t sizeInBytes = uint64_t(num_blocks) * sizeof(BufferBC6HBC7);
-    if (sizeInBytes >= UINT32_MAX)
-        return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-    auto const bufferSize = static_cast<size_t>(sizeInBytes);
-
-    {
-        D3D11_BUFFER_DESC desc = {};
-        desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
-        desc.Usage = D3D11_USAGE_DEFAULT;
-        desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
-        desc.StructureByteStride = sizeof(BufferBC6HBC7);
-        desc.ByteWidth = static_cast<UINT>(bufferSize);
-
-        HRESULT hr = pDevice->CreateBuffer(&desc, nullptr, m_output.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-
-        hr = pDevice->CreateBuffer(&desc, nullptr, m_err1.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-
-        hr = pDevice->CreateBuffer(&desc, nullptr, m_err2.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-    }
-
-    // Create staging output buffer
-    {
-        D3D11_BUFFER_DESC desc = {};
-        desc.Usage = D3D11_USAGE_STAGING;
-        desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-        desc.ByteWidth = static_cast<UINT>(bufferSize);
-
-        HRESULT hr = pDevice->CreateBuffer(&desc, nullptr, m_outputCPU.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-    }
-
-    // Create constant buffer
-    {
-        D3D11_BUFFER_DESC desc = {};
-        desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
-        desc.Usage = D3D11_USAGE_DYNAMIC;
-        desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
-        desc.ByteWidth = sizeof(ConstantsBC6HBC7);
-
-        HRESULT hr = pDevice->CreateBuffer(&desc, nullptr, m_constBuffer.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-    }
-
-    // Create shader resource views
-    {
-        D3D11_SHADER_RESOURCE_VIEW_DESC desc = {};
-        desc.Buffer.NumElements = static_cast<UINT>(num_blocks);
-        desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
-
-        HRESULT hr = pDevice->CreateShaderResourceView(m_err1.Get(), &desc, m_err1SRV.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-
-        hr = pDevice->CreateShaderResourceView(m_err2.Get(), &desc, m_err2SRV.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-    }
-
-    // Create unordered access views
-    {
-        D3D11_UNORDERED_ACCESS_VIEW_DESC desc = {};
-        desc.Buffer.NumElements = static_cast<UINT>(num_blocks);
-        desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
-
-        HRESULT hr = pDevice->CreateUnorderedAccessView(m_output.Get(), &desc, m_outputUAV.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-
-        hr = pDevice->CreateUnorderedAccessView(m_err1.Get(), &desc, m_err1UAV.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-
-        hr = pDevice->CreateUnorderedAccessView(m_err2.Get(), &desc, m_err2UAV.ReleaseAndGetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-HRESULT GPUCompressBC::Compress(const Image& srcImage, const Image& destImage)
-{
-    if (!srcImage.pixels || !destImage.pixels)
-        return E_INVALIDARG;
-
-    if (srcImage.width != destImage.width
-        || srcImage.height != destImage.height
-        || srcImage.width != m_width
-        || srcImage.height != m_height
-        || srcImage.format != m_srcformat
-        || destImage.format != m_bcformat)
-    {
-        return E_UNEXPECTED;
-    }
-
-    //--- Create input texture --------------------------------------------------------
-    auto pDevice = m_device.Get();
-    if (!pDevice)
-        return E_POINTER;
-
-    // We need to avoid the hardware doing additional colorspace conversion
-    const DXGI_FORMAT inputFormat = (m_srcformat == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) ? DXGI_FORMAT_R8G8B8A8_UNORM : m_srcformat;
-
-    ComPtr<ID3D11Texture2D> sourceTex;
-    {
-        D3D11_TEXTURE2D_DESC desc = {};
-        desc.Width = static_cast<UINT>(srcImage.width);
-        desc.Height = static_cast<UINT>(srcImage.height);
-        desc.MipLevels = 1;
-        desc.ArraySize = 1;
-        desc.Format = inputFormat;
-        desc.SampleDesc.Count = 1;
-        desc.Usage = D3D11_USAGE_DEFAULT;
-        desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
-
-        D3D11_SUBRESOURCE_DATA initData;
-        initData.pSysMem = srcImage.pixels;
-        initData.SysMemPitch = static_cast<DWORD>(srcImage.rowPitch);
-        initData.SysMemSlicePitch = static_cast<DWORD>(srcImage.slicePitch);
-
-        HRESULT hr = pDevice->CreateTexture2D(&desc, &initData, sourceTex.GetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-    }
-
-    ComPtr<ID3D11ShaderResourceView> sourceSRV;
-    {
-        D3D11_SHADER_RESOURCE_VIEW_DESC desc = {};
-        desc.Texture2D.MipLevels = 1;
-        desc.Format = inputFormat;
-        desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
-
-        HRESULT hr = pDevice->CreateShaderResourceView(sourceTex.Get(), &desc, sourceSRV.GetAddressOf());
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-    }
-
-    //--- Compress using DirectCompute ------------------------------------------------
-    bool isbc7 = false;
-    switch (m_bcformat)
-    {
-    case DXGI_FORMAT_BC6H_TYPELESS:
-    case DXGI_FORMAT_BC6H_UF16:
-    case DXGI_FORMAT_BC6H_SF16:
-        break;
-
-    case DXGI_FORMAT_BC7_TYPELESS:
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        isbc7 = true;
-        break;
-
-    default:
-        return E_UNEXPECTED;
-    }
-
-    constexpr UINT MAX_BLOCK_BATCH = 64u;
-
-    auto pContext = m_context.Get();
-    if (!pContext)
-        return E_UNEXPECTED;
-
-    const size_t xblocks = std::max<size_t>(1, (m_width + 3) >> 2);
-    const size_t yblocks = std::max<size_t>(1, (m_height + 3) >> 2);
-
-    auto const num_total_blocks = static_cast<UINT>(xblocks * yblocks);
-    UINT num_blocks = num_total_blocks;
-    UINT start_block_id = 0;
-    while (num_blocks > 0)
-    {
-        const UINT n = std::min<UINT>(num_blocks, MAX_BLOCK_BATCH);
-        const UINT uThreadGroupCount = n;
-
-        {
-            D3D11_MAPPED_SUBRESOURCE mapped;
-            HRESULT hr = pContext->Map(m_constBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
-            if (FAILED(hr))
-                return hr;
-
-            ConstantsBC6HBC7 param;
-            param.tex_width = static_cast<UINT>(srcImage.width);
-            param.num_block_x = static_cast<UINT>(xblocks);
-            param.format = static_cast<UINT>(m_bcformat);
-            param.mode_id = 0;
-            param.start_block_id = start_block_id;
-            param.num_total_blocks = num_total_blocks;
-            param.alpha_weight = m_alphaWeight;
-            memcpy(mapped.pData, &param, sizeof(param));
-
-            pContext->Unmap(m_constBuffer.Get(), 0);
-        }
-
-        if (isbc7)
-        {
-            //--- BC7 -----------------------------------------------------------------
-            ID3D11ShaderResourceView* pSRVs[] = { sourceSRV.Get(), nullptr };
-            RunComputeShader(pContext, m_BC7_tryMode456CS.Get(), pSRVs, 2, m_constBuffer.Get(),
-                m_err1UAV.Get(), std::max<UINT>((uThreadGroupCount + 3) / 4, 1));
-
-            if (m_bc7_mode137)
-            {
-                for (UINT i = 0; i < 3; ++i)
-                {
-                    static const UINT modes[] = { 1, 3, 7 };
-
-                    // Mode 1: err1 -> err2
-                    // Mode 3: err2 -> err1
-                    // Mode 7: err1 -> err2
-                    {
-                        D3D11_MAPPED_SUBRESOURCE mapped;
-                        HRESULT hr = pContext->Map(m_constBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
-                        if (FAILED(hr))
-                        {
-                            ResetContext(pContext);
-                            return hr;
-                        }
-
-                        ConstantsBC6HBC7 param;
-                        param.tex_width = static_cast<UINT>(srcImage.width);
-                        param.num_block_x = static_cast<UINT>(xblocks);
-                        param.format = static_cast<UINT>(m_bcformat);
-                        param.mode_id = modes[i];
-                        param.start_block_id = start_block_id;
-                        param.num_total_blocks = num_total_blocks;
-                        param.alpha_weight = m_alphaWeight;
-                        memcpy(mapped.pData, &param, sizeof(param));
-                        pContext->Unmap(m_constBuffer.Get(), 0);
-                    }
-
-                    pSRVs[1] = (i & 1) ? m_err2SRV.Get() : m_err1SRV.Get();
-                    RunComputeShader(pContext, m_BC7_tryMode137CS.Get(), pSRVs, 2, m_constBuffer.Get(),
-                        (i & 1) ? m_err1UAV.Get() : m_err2UAV.Get(), uThreadGroupCount);
-                }
-            }
-
-            if (m_bc7_mode02)
-            {
-                // 3 subset modes tend to be used rarely and add significant compression time
-                for (UINT i = 0; i < 2; ++i)
-                {
-                    static const UINT modes[] = { 0, 2 };
-                    // Mode 0: err2 -> err1
-                    // Mode 2: err1 -> err2
-                    {
-                        D3D11_MAPPED_SUBRESOURCE mapped;
-                        HRESULT hr = pContext->Map(m_constBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
-                        if (FAILED(hr))
-                        {
-                            ResetContext(pContext);
-                            return hr;
-                        }
-
-                        ConstantsBC6HBC7 param;
-                        param.tex_width = static_cast<UINT>(srcImage.width);
-                        param.num_block_x = static_cast<UINT>(xblocks);
-                        param.format = static_cast<UINT>(m_bcformat);
-                        param.mode_id = modes[i];
-                        param.start_block_id = start_block_id;
-                        param.num_total_blocks = num_total_blocks;
-                        param.alpha_weight = m_alphaWeight;
-                        memcpy(mapped.pData, &param, sizeof(param));
-                        pContext->Unmap(m_constBuffer.Get(), 0);
-                    }
-
-                    pSRVs[1] = (i & 1) ? m_err1SRV.Get() : m_err2SRV.Get();
-                    RunComputeShader(pContext, m_BC7_tryMode02CS.Get(), pSRVs, 2, m_constBuffer.Get(),
-                        (i & 1) ? m_err2UAV.Get() : m_err1UAV.Get(), uThreadGroupCount);
-                }
-            }
-
-            pSRVs[1] = (m_bc7_mode02 || m_bc7_mode137) ? m_err2SRV.Get() : m_err1SRV.Get();
-            RunComputeShader(pContext, m_BC7_encodeBlockCS.Get(), pSRVs, 2, m_constBuffer.Get(),
-                m_outputUAV.Get(), std::max<UINT>((uThreadGroupCount + 3) / 4, 1));
-        }
-        else
-        {
-            //--- BC6H ----------------------------------------------------------------
-            ID3D11ShaderResourceView* pSRVs[] = { sourceSRV.Get(), nullptr };
-            RunComputeShader(pContext, m_BC6H_tryModeG10CS.Get(), pSRVs, 2, m_constBuffer.Get(),
-                m_err1UAV.Get(), std::max<UINT>((uThreadGroupCount + 3) / 4, 1));
-
-            for (UINT i = 0; i < 10; ++i)
-            {
-                {
-                    D3D11_MAPPED_SUBRESOURCE mapped;
-                    HRESULT hr = pContext->Map(m_constBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
-                    if (FAILED(hr))
-                    {
-                        ResetContext(pContext);
-                        return hr;
-                    }
-
-                    ConstantsBC6HBC7 param;
-                    param.tex_width = static_cast<UINT>(srcImage.width);
-                    param.num_block_x = static_cast<UINT>(xblocks);
-                    param.format = static_cast<UINT>(m_bcformat);
-                    param.mode_id = i;
-                    param.start_block_id = start_block_id;
-                    param.num_total_blocks = num_total_blocks;
-                    memcpy(mapped.pData, &param, sizeof(param));
-                    pContext->Unmap(m_constBuffer.Get(), 0);
-                }
-
-                pSRVs[1] = (i & 1) ? m_err2SRV.Get() : m_err1SRV.Get();
-                RunComputeShader(pContext, m_BC6H_tryModeLE10CS.Get(), pSRVs, 2, m_constBuffer.Get(),
-                    (i & 1) ? m_err1UAV.Get() : m_err2UAV.Get(), std::max<UINT>((uThreadGroupCount + 1) / 2, 1));
-            }
-
-            pSRVs[1] = m_err1SRV.Get();
-            RunComputeShader(pContext, m_BC6H_encodeBlockCS.Get(), pSRVs, 2, m_constBuffer.Get(),
-                m_outputUAV.Get(), std::max<UINT>((uThreadGroupCount + 1) / 2, 1));
-        }
-
-        start_block_id += n;
-        num_blocks -= n;
-    }
-
-    ResetContext(pContext);
-
-    //--- Copy output texture back to CPU ---------------------------------------------
-
-    pContext->CopyResource(m_outputCPU.Get(), m_output.Get());
-
-    D3D11_MAPPED_SUBRESOURCE mapped;
-    HRESULT hr = pContext->Map(m_outputCPU.Get(), 0, D3D11_MAP_READ, 0, &mapped);
-    if (SUCCEEDED(hr))
-    {
-        auto pSrc = static_cast<const uint8_t *>(mapped.pData);
-        uint8_t *pDest = destImage.pixels;
-
-        const size_t pitch = xblocks * sizeof(BufferBC6HBC7);
-
-        const size_t rows = std::max<size_t>(1, (destImage.height + 3) >> 2);
-
-        for (size_t h = 0; h < rows; ++h)
-        {
-            memcpy(pDest, pSrc, destImage.rowPitch);
-
-            pSrc += pitch;
-            pDest += destImage.rowPitch;
-        }
-
-        pContext->Unmap(m_outputCPU.Get(), 0);
-    }
-
-    return hr;
-}
diff --git a/thirdparty/directxtex/BCDirectCompute.h b/thirdparty/directxtex/BCDirectCompute.h
deleted file mode 100644
index 23f013c..0000000
--- a/thirdparty/directxtex/BCDirectCompute.h
+++ /dev/null
@@ -1,64 +0,0 @@
-//-------------------------------------------------------------------------------------
-// BCDirectCompute.h
-//
-// Direct3D 11 Compute Shader BC Compressor
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-namespace DirectX
-{
-
-    class GPUCompressBC
-    {
-    public:
-        GPUCompressBC() noexcept;
-
-        HRESULT Initialize(_In_ ID3D11Device* pDevice);
-
-        HRESULT Prepare(size_t width, size_t height, uint32_t flags, DXGI_FORMAT format, float alphaWeight);
-
-        HRESULT Compress(const Image& srcImage, const Image& destImage);
-
-        DXGI_FORMAT GetSourceFormat() const noexcept { return m_srcformat; }
-
-    private:
-        DXGI_FORMAT                                         m_bcformat;
-        DXGI_FORMAT                                         m_srcformat;
-        float                                               m_alphaWeight;
-        bool                                                m_bc7_mode02;
-        bool                                                m_bc7_mode137;
-        size_t                                              m_width;
-        size_t                                              m_height;
-
-        Microsoft::WRL::ComPtr<ID3D11Device>                m_device;
-        Microsoft::WRL::ComPtr<ID3D11DeviceContext>         m_context;
-
-        Microsoft::WRL::ComPtr<ID3D11Buffer>                m_err1;
-        Microsoft::WRL::ComPtr<ID3D11UnorderedAccessView>   m_err1UAV;
-        Microsoft::WRL::ComPtr<ID3D11ShaderResourceView>    m_err1SRV;
-
-        Microsoft::WRL::ComPtr<ID3D11Buffer>                m_err2;
-        Microsoft::WRL::ComPtr<ID3D11UnorderedAccessView>   m_err2UAV;
-        Microsoft::WRL::ComPtr<ID3D11ShaderResourceView>    m_err2SRV;
-
-        Microsoft::WRL::ComPtr<ID3D11Buffer>                m_output;
-        Microsoft::WRL::ComPtr<ID3D11Buffer>                m_outputCPU;
-        Microsoft::WRL::ComPtr<ID3D11UnorderedAccessView>   m_outputUAV;
-        Microsoft::WRL::ComPtr<ID3D11Buffer>                m_constBuffer;
-
-        // Compute shader library
-        Microsoft::WRL::ComPtr<ID3D11ComputeShader>         m_BC6H_tryModeG10CS;
-        Microsoft::WRL::ComPtr<ID3D11ComputeShader>         m_BC6H_tryModeLE10CS;
-        Microsoft::WRL::ComPtr<ID3D11ComputeShader>         m_BC6H_encodeBlockCS;
-
-        Microsoft::WRL::ComPtr<ID3D11ComputeShader>         m_BC7_tryMode456CS;
-        Microsoft::WRL::ComPtr<ID3D11ComputeShader>         m_BC7_tryMode137CS;
-        Microsoft::WRL::ComPtr<ID3D11ComputeShader>         m_BC7_tryMode02CS;
-        Microsoft::WRL::ComPtr<ID3D11ComputeShader>         m_BC7_encodeBlockCS;
-    };
-
-} // namespace
diff --git a/thirdparty/directxtex/CMakeLists.txt b/thirdparty/directxtex/CMakeLists.txt
deleted file mode 100644
index ca24694..0000000
--- a/thirdparty/directxtex/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-cmake_minimum_required(VERSION 3.22)
-project(DirectXTex)
-
-set(CMAKE_CXX_STANDARD 17)
-
-file(GLOB DXTEX_SOURCE_FILES
-        "${CMAKE_CURRENT_LIST_DIR}/*.cpp"
-)
-file(GLOB DXTEX_HEADERS
-        "${CMAKE_CURRENT_LIST_DIR}/*.h"
-)
-file(GLOB DXTEX_PRECOMPILED_SHADERS
-        "${CMAKE_CURRENT_LIST_DIR}/Shaders/Compiled/*.inc"
-)
-
-add_library(DirectXTex ${DXTEX_SOURCE_FILES} ${DXTEX_HEADERS} ${DXTEX_PRECOMPILED_SHADERS})
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/Shaders/Compiled)
diff --git a/thirdparty/directxtex/DDS.h b/thirdparty/directxtex/DDS.h
deleted file mode 100644
index a88f14a..0000000
--- a/thirdparty/directxtex/DDS.h
+++ /dev/null
@@ -1,290 +0,0 @@
-//--------------------------------------------------------------------------------------
-// DDS.h
-//
-// This header defines constants and structures that are useful when parsing
-// DDS files.  DDS files were originally designed to use several structures
-// and constants that are native to DirectDraw and are defined in ddraw.h,
-// such as DDSURFACEDESC2 and DDSCAPS2.  This file defines similar
-// (compatible) constants and structures so that one can use DDS files
-// without needing to include ddraw.h.
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-// http://go.microsoft.com/fwlink/?LinkId=248929
-// http://go.microsoft.com/fwlink/?LinkID=615561
-//--------------------------------------------------------------------------------------
-
-#pragma once
-
-#include <cstdint>
-
-namespace DirectX
-{
-
-#pragma pack(push,1)
-
-    constexpr uint32_t DDS_MAGIC = 0x20534444; // "DDS "
-
-    struct DDS_PIXELFORMAT
-    {
-        uint32_t    size;
-        uint32_t    flags;
-        uint32_t    fourCC;
-        uint32_t    RGBBitCount;
-        uint32_t    RBitMask;
-        uint32_t    GBitMask;
-        uint32_t    BBitMask;
-        uint32_t    ABitMask;
-    };
-
-#define DDS_FOURCC      0x00000004  // DDPF_FOURCC
-#define DDS_RGB         0x00000040  // DDPF_RGB
-#define DDS_RGBA        0x00000041  // DDPF_RGB | DDPF_ALPHAPIXELS
-#define DDS_LUMINANCE   0x00020000  // DDPF_LUMINANCE
-#define DDS_LUMINANCEA  0x00020001  // DDPF_LUMINANCE | DDPF_ALPHAPIXELS
-#define DDS_ALPHAPIXELS 0x00000001  // DDPF_ALPHAPIXELS
-#define DDS_ALPHA       0x00000002  // DDPF_ALPHA
-#define DDS_PAL8        0x00000020  // DDPF_PALETTEINDEXED8
-#define DDS_PAL8A       0x00000021  // DDPF_PALETTEINDEXED8 | DDPF_ALPHAPIXELS
-#define DDS_BUMPDUDV    0x00080000  // DDPF_BUMPDUDV
-// DDS_BUMPLUMINANCE 0x00040000
-
-#ifndef MAKEFOURCC
-#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
-                (static_cast<uint32_t>(static_cast<uint8_t>(ch0)) \
-                | (static_cast<uint32_t>(static_cast<uint8_t>(ch1)) << 8) \
-                | (static_cast<uint32_t>(static_cast<uint8_t>(ch2)) << 16) \
-                | (static_cast<uint32_t>(static_cast<uint8_t>(ch3)) << 24))
-#endif /* MAKEFOURCC */
-
-#ifndef DDSGLOBALCONST
-#if defined(__GNUC__) && !defined(__MINGW32__)
-#define DDSGLOBALCONST extern const __attribute__((weak))
-#else
-#define DDSGLOBALCONST extern const __declspec(selectany)
-#endif
-#endif /* DDSGLOBALCONST */
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT1 =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT2 =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','2'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT3 =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','3'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT4 =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','4'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT5 =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','5'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_UNORM =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','U'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_SNORM =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','S'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_UNORM =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','U'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_SNORM =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','S'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8_B8G8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('R','G','B','G'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G8R8_G8B8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('G','R','G','B'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_YUY2 =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('Y','U','Y','2'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_UYVY =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('U','Y','V','Y'), 0, 0, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R8G8B8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8R8G8B8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB,  0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8B8G8R8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8B8G8R8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB,  0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G16R16 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB,  0, 32, 0x0000ffff, 0xffff0000, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R5G6B5 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xf800, 0x07e0, 0x001f, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A1R5G5B5 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x7c00, 0x03e0, 0x001f, 0x8000 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X1R5G5B5 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x7c00, 0x03e0, 0x001f, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4R4G4B4 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x0f00, 0x00f0, 0x000f, 0xf000 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X4R4G4B4 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x0f00, 0x00f0, 0x000f, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8B8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R3G3B2 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00e0, 0x001c, 0x0003, 0xff00 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R3G3B2 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xe0, 0x1c, 0x03, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4L4 =
-    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x0f, 0, 0, 0xf0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 8, 0xff, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16 =
-    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 16, 0xffff, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 16, 0x00ff, 0, 0, 0xff00 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_ALT =
-    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x00ff, 0, 0, 0xff00 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8_NVTT1 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xff, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16_NVTT1 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xffff, 0, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_NVTT1 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00ff, 0, 0, 0xff00 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_ALPHA, 0, 8, 0, 0, 0, 0xff };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V8U8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 16, 0x00ff, 0xff00, 0, 0 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_Q8W8V8U8 =
-    { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
-
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V16U16 =
-    { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x0000ffff, 0xffff0000, 0, 0 };
-
-// D3DFMT_A2R10G10B10/D3DFMT_A2B10G10R10 should be written using DX10 extension to avoid D3DX 10:10:10:2 reversal issue
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2R10G10B10 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000 };
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2B10G10R10 =
-    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000 };
-
-// We do not support the following legacy Direct3D 9 formats:
-// DDSPF_A2W10V10U10 = { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000 };
-// DDSPF_L6V5U5 = { sizeof(DDS_PIXELFORMAT), DDS_BUMPLUMINANCE, 0, 16, 0x001f, 0x03e0, 0xfc00, 0 };
-// DDSPF_X8L8V8U8 = { sizeof(DDS_PIXELFORMAT), DDS_BUMPLUMINANCE, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 };
-
-// This indicates the DDS_HEADER_DXT10 extension is present (the format is in dxgiFormat)
-    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DX10 =
-    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','1','0'), 0, 0, 0, 0, 0 };
-
-#define DDS_HEADER_FLAGS_TEXTURE        0x00001007  // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
-#define DDS_HEADER_FLAGS_MIPMAP         0x00020000  // DDSD_MIPMAPCOUNT
-#define DDS_HEADER_FLAGS_VOLUME         0x00800000  // DDSD_DEPTH
-#define DDS_HEADER_FLAGS_PITCH          0x00000008  // DDSD_PITCH
-#define DDS_HEADER_FLAGS_LINEARSIZE     0x00080000  // DDSD_LINEARSIZE
-
-#define DDS_HEIGHT 0x00000002 // DDSD_HEIGHT
-#define DDS_WIDTH  0x00000004 // DDSD_WIDTH
-
-#define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 // DDSCAPS_TEXTURE
-#define DDS_SURFACE_FLAGS_MIPMAP  0x00400008 // DDSCAPS_COMPLEX | DDSCAPS_MIPMAP
-#define DDS_SURFACE_FLAGS_CUBEMAP 0x00000008 // DDSCAPS_COMPLEX
-
-#define DDS_CUBEMAP_POSITIVEX 0x00000600 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEX
-#define DDS_CUBEMAP_NEGATIVEX 0x00000a00 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX
-#define DDS_CUBEMAP_POSITIVEY 0x00001200 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY
-#define DDS_CUBEMAP_NEGATIVEY 0x00002200 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY
-#define DDS_CUBEMAP_POSITIVEZ 0x00004200 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ
-#define DDS_CUBEMAP_NEGATIVEZ 0x00008200 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ
-
-#define DDS_CUBEMAP_ALLFACES ( DDS_CUBEMAP_POSITIVEX | DDS_CUBEMAP_NEGATIVEX |\
-                               DDS_CUBEMAP_POSITIVEY | DDS_CUBEMAP_NEGATIVEY |\
-                               DDS_CUBEMAP_POSITIVEZ | DDS_CUBEMAP_NEGATIVEZ )
-
-#define DDS_CUBEMAP 0x00000200 // DDSCAPS2_CUBEMAP
-
-#define DDS_FLAGS_VOLUME 0x00200000 // DDSCAPS2_VOLUME
-
-// Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION
-    enum DDS_RESOURCE_DIMENSION : uint32_t
-    {
-        DDS_DIMENSION_TEXTURE1D = 2,
-        DDS_DIMENSION_TEXTURE2D = 3,
-        DDS_DIMENSION_TEXTURE3D = 4,
-    };
-
-    // Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
-    enum DDS_RESOURCE_MISC_FLAG : uint32_t
-    {
-        DDS_RESOURCE_MISC_TEXTURECUBE = 0x4L,
-    };
-
-    enum DDS_MISC_FLAGS2 : uint32_t
-    {
-        DDS_MISC_FLAGS2_ALPHA_MODE_MASK = 0x7L,
-    };
-
-#ifndef DDS_ALPHA_MODE_DEFINED
-#define DDS_ALPHA_MODE_DEFINED
-    enum DDS_ALPHA_MODE : uint32_t
-    {
-        DDS_ALPHA_MODE_UNKNOWN = 0,
-        DDS_ALPHA_MODE_STRAIGHT = 1,
-        DDS_ALPHA_MODE_PREMULTIPLIED = 2,
-        DDS_ALPHA_MODE_OPAQUE = 3,
-        DDS_ALPHA_MODE_CUSTOM = 4,
-    };
-#endif
-
-    struct DDS_HEADER
-    {
-        uint32_t        size;
-        uint32_t        flags;
-        uint32_t        height;
-        uint32_t        width;
-        uint32_t        pitchOrLinearSize;
-        uint32_t        depth; // only if DDS_HEADER_FLAGS_VOLUME is set in flags
-        uint32_t        mipMapCount;
-        uint32_t        reserved1[11];
-        DDS_PIXELFORMAT ddspf;
-        uint32_t        caps;
-        uint32_t        caps2;
-        uint32_t        caps3;
-        uint32_t        caps4;
-        uint32_t        reserved2;
-    };
-
-    struct DDS_HEADER_DXT10
-    {
-        DXGI_FORMAT     dxgiFormat;
-        uint32_t        resourceDimension;
-        uint32_t        miscFlag; // see D3D11_RESOURCE_MISC_FLAG
-        uint32_t        arraySize;
-        uint32_t        miscFlags2; // see DDS_MISC_FLAGS2
-    };
-
-#pragma pack(pop)
-
-    static_assert(sizeof(DDS_HEADER) == 124, "DDS Header size mismatch");
-    static_assert(sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch");
-
-} // namespace
diff --git a/thirdparty/directxtex/DirectXTex.h b/thirdparty/directxtex/DirectXTex.h
deleted file mode 100644
index 6ab0a45..0000000
--- a/thirdparty/directxtex/DirectXTex.h
+++ /dev/null
@@ -1,937 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTex.h
-//
-// DirectX Texture Library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <utility>
-#include <vector>
-
-#ifdef _WIN32
-#if !defined(__d3d11_h__) && !defined(__d3d11_x_h__) && !defined(__d3d12_h__) && !defined(__d3d12_x_h__) && !defined(__XBOX_D3D12_X__)
-#ifdef _GAMING_XBOX_SCARLETT
-#include <d3d12_xs.h>
-#elif defined(_GAMING_XBOX)
-#include <d3d12_x.h>
-#elif defined(_XBOX_ONE) && defined(_TITLE)
-#include <d3d11_x.h>
-#else
-#include <d3d11_1.h>
-#endif
-#endif
-#else // !WIN32
-#include <directx/dxgiformat.h>
-#include <wsl/winadapter.h>
-#endif
-
-#include <DirectXMath.h>
-
-#ifdef _WIN32
-#if defined(NTDDI_WIN10_FE) || defined(__MINGW32__)
-#include <ocidl.h>
-#else
-#include <OCIdl.h>
-#endif
-
-struct IWICImagingFactory;
-struct IWICMetadataQueryReader;
-#endif
-
-#define DIRECTX_TEX_VERSION 196
-
-
-namespace DirectX
-{
-
-    //---------------------------------------------------------------------------------
-    // DXGI Format Utilities
-    constexpr bool __cdecl IsValid(_In_ DXGI_FORMAT fmt) noexcept;
-    bool __cdecl IsCompressed(_In_ DXGI_FORMAT fmt) noexcept;
-    bool __cdecl IsPacked(_In_ DXGI_FORMAT fmt) noexcept;
-    bool __cdecl IsVideo(_In_ DXGI_FORMAT fmt) noexcept;
-    bool __cdecl IsPlanar(_In_ DXGI_FORMAT fmt) noexcept;
-    bool __cdecl IsPalettized(_In_ DXGI_FORMAT fmt) noexcept;
-    bool __cdecl IsDepthStencil(_In_ DXGI_FORMAT fmt) noexcept;
-    bool __cdecl IsSRGB(_In_ DXGI_FORMAT fmt) noexcept;
-    bool __cdecl IsBGR(_In_ DXGI_FORMAT fmt) noexcept;
-    bool __cdecl IsTypeless(_In_ DXGI_FORMAT fmt, _In_ bool partialTypeless = true) noexcept;
-
-    bool __cdecl HasAlpha(_In_ DXGI_FORMAT fmt) noexcept;
-
-    size_t __cdecl BitsPerPixel(_In_ DXGI_FORMAT fmt) noexcept;
-
-    size_t __cdecl BitsPerColor(_In_ DXGI_FORMAT fmt) noexcept;
-
-    enum FORMAT_TYPE
-    {
-        FORMAT_TYPE_TYPELESS,
-        FORMAT_TYPE_FLOAT,
-        FORMAT_TYPE_UNORM,
-        FORMAT_TYPE_SNORM,
-        FORMAT_TYPE_UINT,
-        FORMAT_TYPE_SINT,
-    };
-
-    FORMAT_TYPE __cdecl FormatDataType(_In_ DXGI_FORMAT fmt) noexcept;
-
-    enum CP_FLAGS : unsigned long
-    {
-        CP_FLAGS_NONE = 0x0,
-        // Normal operation
-
-        CP_FLAGS_LEGACY_DWORD = 0x1,
-        // Assume pitch is DWORD aligned instead of BYTE aligned
-
-        CP_FLAGS_PARAGRAPH = 0x2,
-        // Assume pitch is 16-byte aligned instead of BYTE aligned
-
-        CP_FLAGS_YMM = 0x4,
-        // Assume pitch is 32-byte aligned instead of BYTE aligned
-
-        CP_FLAGS_ZMM = 0x8,
-        // Assume pitch is 64-byte aligned instead of BYTE aligned
-
-        CP_FLAGS_PAGE4K = 0x200,
-        // Assume pitch is 4096-byte aligned instead of BYTE aligned
-
-        CP_FLAGS_BAD_DXTN_TAILS = 0x1000,
-        // BC formats with malformed mipchain blocks smaller than 4x4
-
-        CP_FLAGS_24BPP = 0x10000,
-        // Override with a legacy 24 bits-per-pixel format size
-
-        CP_FLAGS_16BPP = 0x20000,
-        // Override with a legacy 16 bits-per-pixel format size
-
-        CP_FLAGS_8BPP = 0x40000,
-        // Override with a legacy 8 bits-per-pixel format size
-    };
-
-    HRESULT __cdecl ComputePitch(
-        _In_ DXGI_FORMAT fmt, _In_ size_t width, _In_ size_t height,
-        _Out_ size_t& rowPitch, _Out_ size_t& slicePitch, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-
-    size_t __cdecl ComputeScanlines(_In_ DXGI_FORMAT fmt, _In_ size_t height) noexcept;
-
-    DXGI_FORMAT __cdecl MakeSRGB(_In_ DXGI_FORMAT fmt) noexcept;
-    DXGI_FORMAT __cdecl MakeLinear(_In_ DXGI_FORMAT fmt) noexcept;
-    DXGI_FORMAT __cdecl MakeTypeless(_In_ DXGI_FORMAT fmt) noexcept;
-    DXGI_FORMAT __cdecl MakeTypelessUNORM(_In_ DXGI_FORMAT fmt) noexcept;
-    DXGI_FORMAT __cdecl MakeTypelessFLOAT(_In_ DXGI_FORMAT fmt) noexcept;
-
-    //---------------------------------------------------------------------------------
-    // Texture metadata
-    enum TEX_DIMENSION
-        // Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION
-    {
-        TEX_DIMENSION_TEXTURE1D = 2,
-        TEX_DIMENSION_TEXTURE2D = 3,
-        TEX_DIMENSION_TEXTURE3D = 4,
-    };
-
-    enum TEX_MISC_FLAG : unsigned long
-        // Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
-    {
-        TEX_MISC_TEXTURECUBE = 0x4L,
-    };
-
-    enum TEX_MISC_FLAG2 : unsigned long
-    {
-        TEX_MISC2_ALPHA_MODE_MASK = 0x7L,
-    };
-
-    enum TEX_ALPHA_MODE
-        // Matches DDS_ALPHA_MODE, encoded in MISC_FLAGS2
-    {
-        TEX_ALPHA_MODE_UNKNOWN = 0,
-        TEX_ALPHA_MODE_STRAIGHT = 1,
-        TEX_ALPHA_MODE_PREMULTIPLIED = 2,
-        TEX_ALPHA_MODE_OPAQUE = 3,
-        TEX_ALPHA_MODE_CUSTOM = 4,
-    };
-
-    struct TexMetadata
-    {
-        size_t          width;
-        size_t          height;     // Should be 1 for 1D textures
-        size_t          depth;      // Should be 1 for 1D or 2D textures
-        size_t          arraySize;  // For cubemap, this is a multiple of 6
-        size_t          mipLevels;
-        uint32_t        miscFlags;
-        uint32_t        miscFlags2;
-        DXGI_FORMAT     format;
-        TEX_DIMENSION   dimension;
-
-        size_t __cdecl ComputeIndex(_In_ size_t mip, _In_ size_t item, _In_ size_t slice) const noexcept;
-            // Returns size_t(-1) to indicate an out-of-range error
-
-        bool __cdecl IsCubemap() const noexcept { return (miscFlags & TEX_MISC_TEXTURECUBE) != 0; }
-            // Helper for miscFlags
-
-        bool __cdecl IsPMAlpha() const noexcept { return ((miscFlags2 & TEX_MISC2_ALPHA_MODE_MASK) == TEX_ALPHA_MODE_PREMULTIPLIED) != 0; }
-        void __cdecl SetAlphaMode(TEX_ALPHA_MODE mode) noexcept { miscFlags2 = (miscFlags2 & ~static_cast<uint32_t>(TEX_MISC2_ALPHA_MODE_MASK)) | static_cast<uint32_t>(mode); }
-        TEX_ALPHA_MODE __cdecl GetAlphaMode() const noexcept { return static_cast<TEX_ALPHA_MODE>(miscFlags2 & TEX_MISC2_ALPHA_MODE_MASK); }
-            // Helpers for miscFlags2
-
-        bool __cdecl IsVolumemap() const noexcept { return (dimension == TEX_DIMENSION_TEXTURE3D); }
-            // Helper for dimension
-    };
-
-    enum DDS_FLAGS : unsigned long
-    {
-        DDS_FLAGS_NONE = 0x0,
-
-        DDS_FLAGS_LEGACY_DWORD = 0x1,
-        // Assume pitch is DWORD aligned instead of BYTE aligned (used by some legacy DDS files)
-
-        DDS_FLAGS_NO_LEGACY_EXPANSION = 0x2,
-        // Do not implicitly convert legacy formats that result in larger pixel sizes (24 bpp, 3:3:2, A8L8, A4L4, P8, A8P8)
-
-        DDS_FLAGS_NO_R10B10G10A2_FIXUP = 0x4,
-        // Do not use work-around for long-standing D3DX DDS file format issue which reversed the 10:10:10:2 color order masks
-
-        DDS_FLAGS_FORCE_RGB = 0x8,
-        // Convert DXGI 1.1 BGR formats to DXGI_FORMAT_R8G8B8A8_UNORM to avoid use of optional WDDM 1.1 formats
-
-        DDS_FLAGS_NO_16BPP = 0x10,
-        // Conversions avoid use of 565, 5551, and 4444 formats and instead expand to 8888 to avoid use of optional WDDM 1.2 formats
-
-        DDS_FLAGS_EXPAND_LUMINANCE = 0x20,
-        // When loading legacy luminance formats expand replicating the color channels rather than leaving them packed (L8, L16, A8L8)
-
-        DDS_FLAGS_BAD_DXTN_TAILS = 0x40,
-        // Some older DXTn DDS files incorrectly handle mipchain tails for blocks smaller than 4x4
-
-        DDS_FLAGS_FORCE_DX10_EXT = 0x10000,
-        // Always use the 'DX10' header extension for DDS writer (i.e. don't try to write DX9 compatible DDS files)
-
-        DDS_FLAGS_FORCE_DX10_EXT_MISC2 = 0x20000,
-        // DDS_FLAGS_FORCE_DX10_EXT including miscFlags2 information (result may not be compatible with D3DX10 or D3DX11)
-
-        DDS_FLAGS_FORCE_DX9_LEGACY = 0x40000,
-        // Force use of legacy header for DDS writer (will fail if unable to write as such)
-
-        DDS_FLAGS_ALLOW_LARGE_FILES = 0x1000000,
-        // Enables the loader to read large dimension .dds files (i.e. greater than known hardware requirements)
-    };
-
-    enum TGA_FLAGS : unsigned long
-    {
-        TGA_FLAGS_NONE = 0x0,
-
-        TGA_FLAGS_BGR = 0x1,
-        // 24bpp files are returned as BGRX; 32bpp files are returned as BGRA
-
-        TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA = 0x2,
-        // If the loaded image has an all zero alpha channel, normally we assume it should be opaque. This flag leaves it alone.
-
-        TGA_FLAGS_IGNORE_SRGB = 0x10,
-        // Ignores sRGB TGA 2.0 metadata if present in the file
-
-        TGA_FLAGS_FORCE_SRGB = 0x20,
-        // Writes sRGB metadata into the file reguardless of format (TGA 2.0 only)
-
-        TGA_FLAGS_FORCE_LINEAR = 0x40,
-        // Writes linear gamma metadata into the file reguardless of format (TGA 2.0 only)
-
-        TGA_FLAGS_DEFAULT_SRGB = 0x80,
-        // If no colorspace is specified in TGA 2.0 metadata, assume sRGB
-    };
-
-    enum WIC_FLAGS : unsigned long
-    {
-        WIC_FLAGS_NONE = 0x0,
-
-        WIC_FLAGS_FORCE_RGB = 0x1,
-        // Loads DXGI 1.1 BGR formats as DXGI_FORMAT_R8G8B8A8_UNORM to avoid use of optional WDDM 1.1 formats
-
-        WIC_FLAGS_NO_X2_BIAS = 0x2,
-        // Loads DXGI 1.1 X2 10:10:10:2 format as DXGI_FORMAT_R10G10B10A2_UNORM
-
-        WIC_FLAGS_NO_16BPP = 0x4,
-        // Loads 565, 5551, and 4444 formats as 8888 to avoid use of optional WDDM 1.2 formats
-
-        WIC_FLAGS_ALLOW_MONO = 0x8,
-        // Loads 1-bit monochrome (black & white) as R1_UNORM rather than 8-bit grayscale
-
-        WIC_FLAGS_ALL_FRAMES = 0x10,
-        // Loads all images in a multi-frame file, converting/resizing to match the first frame as needed, defaults to 0th frame otherwise
-
-        WIC_FLAGS_IGNORE_SRGB = 0x20,
-        // Ignores sRGB metadata if present in the file
-
-        WIC_FLAGS_FORCE_SRGB = 0x40,
-        // Writes sRGB metadata into the file reguardless of format
-
-        WIC_FLAGS_FORCE_LINEAR = 0x80,
-        // Writes linear gamma metadata into the file reguardless of format
-
-        WIC_FLAGS_DEFAULT_SRGB = 0x100,
-        // If no colorspace is specified, assume sRGB
-
-        WIC_FLAGS_DITHER = 0x10000,
-        // Use ordered 4x4 dithering for any required conversions
-
-        WIC_FLAGS_DITHER_DIFFUSION = 0x20000,
-        // Use error-diffusion dithering for any required conversions
-
-        WIC_FLAGS_FILTER_POINT = 0x100000,
-        WIC_FLAGS_FILTER_LINEAR = 0x200000,
-        WIC_FLAGS_FILTER_CUBIC = 0x300000,
-        WIC_FLAGS_FILTER_FANT = 0x400000, // Combination of Linear and Box filter
-            // Filtering mode to use for any required image resizing (only needed when loading arrays of differently sized images; defaults to Fant)
-    };
-
-    HRESULT __cdecl GetMetadataFromDDSMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _In_ DDS_FLAGS flags,
-        _Out_ TexMetadata& metadata) noexcept;
-    HRESULT __cdecl GetMetadataFromDDSFile(
-        _In_z_ const wchar_t* szFile,
-        _In_ DDS_FLAGS flags,
-        _Out_ TexMetadata& metadata) noexcept;
-
-    HRESULT __cdecl GetMetadataFromHDRMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _Out_ TexMetadata& metadata) noexcept;
-    HRESULT __cdecl GetMetadataFromHDRFile(
-        _In_z_ const wchar_t* szFile,
-        _Out_ TexMetadata& metadata) noexcept;
-
-    HRESULT __cdecl GetMetadataFromTGAMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _In_ TGA_FLAGS flags,
-        _Out_ TexMetadata& metadata) noexcept;
-    HRESULT __cdecl GetMetadataFromTGAFile(
-        _In_z_ const wchar_t* szFile,
-        _In_ TGA_FLAGS flags,
-        _Out_ TexMetadata& metadata) noexcept;
-
-#ifdef _WIN32
-    HRESULT __cdecl GetMetadataFromWICMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _In_ WIC_FLAGS flags,
-        _Out_ TexMetadata& metadata,
-        _In_opt_ std::function<void __cdecl(IWICMetadataQueryReader*)> getMQR = nullptr);
-
-    HRESULT __cdecl GetMetadataFromWICFile(
-        _In_z_ const wchar_t* szFile,
-        _In_ WIC_FLAGS flags,
-        _Out_ TexMetadata& metadata,
-        _In_opt_ std::function<void __cdecl(IWICMetadataQueryReader*)> getMQR = nullptr);
-#endif
-
-    // Compatability helpers
-    HRESULT __cdecl GetMetadataFromTGAMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _Out_ TexMetadata& metadata) noexcept;
-    HRESULT __cdecl GetMetadataFromTGAFile(
-        _In_z_ const wchar_t* szFile,
-        _Out_ TexMetadata& metadata) noexcept;
-
-    //---------------------------------------------------------------------------------
-    // Bitmap image container
-    struct Image
-    {
-        size_t      width;
-        size_t      height;
-        DXGI_FORMAT format;
-        size_t      rowPitch;
-        size_t      slicePitch;
-        uint8_t*    pixels;
-    };
-
-    class ScratchImage
-    {
-    public:
-        ScratchImage() noexcept
-            : m_nimages(0), m_size(0), m_metadata{}, m_image(nullptr), m_memory(nullptr) {}
-        ScratchImage(ScratchImage&& moveFrom) noexcept
-            : m_nimages(0), m_size(0), m_metadata{}, m_image(nullptr), m_memory(nullptr) { *this = std::move(moveFrom); }
-        ~ScratchImage() { Release(); }
-
-        ScratchImage& __cdecl operator= (ScratchImage&& moveFrom) noexcept;
-
-        ScratchImage(const ScratchImage&) = delete;
-        ScratchImage& operator=(const ScratchImage&) = delete;
-
-        HRESULT __cdecl Initialize(_In_ const TexMetadata& mdata, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-
-        HRESULT __cdecl Initialize1D(_In_ DXGI_FORMAT fmt, _In_ size_t length, _In_ size_t arraySize, _In_ size_t mipLevels, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-        HRESULT __cdecl Initialize2D(_In_ DXGI_FORMAT fmt, _In_ size_t width, _In_ size_t height, _In_ size_t arraySize, _In_ size_t mipLevels, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-        HRESULT __cdecl Initialize3D(_In_ DXGI_FORMAT fmt, _In_ size_t width, _In_ size_t height, _In_ size_t depth, _In_ size_t mipLevels, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-        HRESULT __cdecl InitializeCube(_In_ DXGI_FORMAT fmt, _In_ size_t width, _In_ size_t height, _In_ size_t nCubes, _In_ size_t mipLevels, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-
-        HRESULT __cdecl InitializeFromImage(_In_ const Image& srcImage, _In_ bool allow1D = false, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-        HRESULT __cdecl InitializeArrayFromImages(_In_reads_(nImages) const Image* images, _In_ size_t nImages, _In_ bool allow1D = false, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-        HRESULT __cdecl InitializeCubeFromImages(_In_reads_(nImages) const Image* images, _In_ size_t nImages, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-        HRESULT __cdecl Initialize3DFromImages(_In_reads_(depth) const Image* images, _In_ size_t depth, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
-
-        void __cdecl Release() noexcept;
-
-        bool __cdecl OverrideFormat(_In_ DXGI_FORMAT f) noexcept;
-
-        const TexMetadata& __cdecl GetMetadata() const noexcept { return m_metadata; }
-        const Image* __cdecl GetImage(_In_ size_t mip, _In_ size_t item, _In_ size_t slice) const noexcept;
-
-        const Image* __cdecl GetImages() const noexcept { return m_image; }
-        size_t __cdecl GetImageCount() const noexcept { return m_nimages; }
-
-        uint8_t* __cdecl GetPixels() const noexcept { return m_memory; }
-        size_t __cdecl GetPixelsSize() const noexcept { return m_size; }
-
-        bool __cdecl IsAlphaAllOpaque() const noexcept;
-
-    private:
-        size_t      m_nimages;
-        size_t      m_size;
-        TexMetadata m_metadata;
-        Image*      m_image;
-        uint8_t*    m_memory;
-    };
-
-    //---------------------------------------------------------------------------------
-    // Memory blob (allocated buffer pointer is always 16-byte aligned)
-    class Blob
-    {
-    public:
-        Blob() noexcept : m_buffer(nullptr), m_size(0) {}
-        Blob(Blob&& moveFrom) noexcept : m_buffer(nullptr), m_size(0) { *this = std::move(moveFrom); }
-        ~Blob() { Release(); }
-
-        Blob& __cdecl operator= (Blob&& moveFrom) noexcept;
-
-        Blob(const Blob&) = delete;
-        Blob& operator=(const Blob&) = delete;
-
-        HRESULT __cdecl Initialize(_In_ size_t size) noexcept;
-
-        void __cdecl Release() noexcept;
-
-        void *__cdecl GetBufferPointer() const noexcept { return m_buffer; }
-        size_t __cdecl GetBufferSize() const noexcept { return m_size; }
-
-        HRESULT __cdecl Resize(size_t size) noexcept;
-            // Reallocate for a new size
-
-        HRESULT __cdecl Trim(size_t size) noexcept;
-            // Shorten size without reallocation
-
-    private:
-        void*   m_buffer;
-        size_t  m_size;
-    };
-
-    //---------------------------------------------------------------------------------
-    // Image I/O
-
-    // DDS operations
-    HRESULT __cdecl LoadFromDDSMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _In_ DDS_FLAGS flags,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl LoadFromDDSFile(
-        _In_z_ const wchar_t* szFile,
-        _In_ DDS_FLAGS flags,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
-
-    HRESULT __cdecl SaveToDDSMemory(
-        _In_ const Image& image,
-        _In_ DDS_FLAGS flags,
-        _Out_ Blob& blob) noexcept;
-    HRESULT __cdecl SaveToDDSMemory(
-        _In_reads_(nimages) const Image* images, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ DDS_FLAGS flags,
-        _Out_ Blob& blob) noexcept;
-
-    HRESULT __cdecl SaveToDDSFile(_In_ const Image& image, _In_ DDS_FLAGS flags, _In_z_ const wchar_t* szFile) noexcept;
-    HRESULT __cdecl SaveToDDSFile(
-        _In_reads_(nimages) const Image* images, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ DDS_FLAGS flags, _In_z_ const wchar_t* szFile) noexcept;
-
-    // HDR operations
-    HRESULT __cdecl LoadFromHDRMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl LoadFromHDRFile(
-        _In_z_ const wchar_t* szFile,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
-
-    HRESULT __cdecl SaveToHDRMemory(_In_ const Image& image, _Out_ Blob& blob) noexcept;
-    HRESULT __cdecl SaveToHDRFile(_In_ const Image& image, _In_z_ const wchar_t* szFile) noexcept;
-
-    // TGA operations
-    HRESULT __cdecl LoadFromTGAMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _In_ TGA_FLAGS flags,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl LoadFromTGAFile(
-        _In_z_ const wchar_t* szFile,
-        _In_ TGA_FLAGS flags,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
-
-    HRESULT __cdecl SaveToTGAMemory(_In_ const Image& image,
-        _In_ TGA_FLAGS flags,
-        _Out_ Blob& blob, _In_opt_ const TexMetadata* metadata = nullptr) noexcept;
-    HRESULT __cdecl SaveToTGAFile(_In_ const Image& image,
-        _In_ TGA_FLAGS flags,
-        _In_z_ const wchar_t* szFile, _In_opt_ const TexMetadata* metadata = nullptr) noexcept;
-
-    // WIC operations
-#ifdef _WIN32
-    HRESULT __cdecl LoadFromWICMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _In_ WIC_FLAGS flags,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image,
-        _In_opt_ std::function<void __cdecl(IWICMetadataQueryReader*)> getMQR = nullptr);
-    HRESULT __cdecl LoadFromWICFile(
-        _In_z_ const wchar_t* szFile, _In_ WIC_FLAGS flags,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image,
-        _In_opt_ std::function<void __cdecl(IWICMetadataQueryReader*)> getMQR = nullptr);
-
-    HRESULT __cdecl SaveToWICMemory(
-        _In_ const Image& image, _In_ WIC_FLAGS flags, _In_ REFGUID guidContainerFormat,
-        _Out_ Blob& blob, _In_opt_ const GUID* targetFormat = nullptr,
-        _In_opt_ std::function<void __cdecl(IPropertyBag2*)> setCustomProps = nullptr);
-    HRESULT __cdecl SaveToWICMemory(
-        _In_count_(nimages) const Image* images, _In_ size_t nimages,
-        _In_ WIC_FLAGS flags, _In_ REFGUID guidContainerFormat,
-        _Out_ Blob& blob, _In_opt_ const GUID* targetFormat = nullptr,
-        _In_opt_ std::function<void __cdecl(IPropertyBag2*)> setCustomProps = nullptr);
-
-    HRESULT __cdecl SaveToWICFile(
-        _In_ const Image& image, _In_ WIC_FLAGS flags, _In_ REFGUID guidContainerFormat,
-        _In_z_ const wchar_t* szFile, _In_opt_ const GUID* targetFormat = nullptr,
-        _In_opt_ std::function<void __cdecl(IPropertyBag2*)> setCustomProps = nullptr);
-    HRESULT __cdecl SaveToWICFile(
-        _In_count_(nimages) const Image* images, _In_ size_t nimages,
-        _In_ WIC_FLAGS flags, _In_ REFGUID guidContainerFormat,
-        _In_z_ const wchar_t* szFile, _In_opt_ const GUID* targetFormat = nullptr,
-        _In_opt_ std::function<void __cdecl(IPropertyBag2*)> setCustomProps = nullptr);
-#endif // WIN32
-
-    // Compatability helpers
-    HRESULT __cdecl LoadFromTGAMemory(
-        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl LoadFromTGAFile(
-        _In_z_ const wchar_t* szFile,
-        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
-
-    HRESULT __cdecl SaveToTGAMemory(_In_ const Image& image, _Out_ Blob& blob, _In_opt_ const TexMetadata* metadata = nullptr) noexcept;
-    HRESULT __cdecl SaveToTGAFile(_In_ const Image& image, _In_z_ const wchar_t* szFile, _In_opt_ const TexMetadata* metadata = nullptr) noexcept;
-
-    //---------------------------------------------------------------------------------
-    // Texture conversion, resizing, mipmap generation, and block compression
-
-    enum TEX_FR_FLAGS : unsigned long
-    {
-        TEX_FR_ROTATE0 = 0x0,
-        TEX_FR_ROTATE90 = 0x1,
-        TEX_FR_ROTATE180 = 0x2,
-        TEX_FR_ROTATE270 = 0x3,
-        TEX_FR_FLIP_HORIZONTAL = 0x08,
-        TEX_FR_FLIP_VERTICAL = 0x10,
-    };
-
-#ifdef _WIN32
-    HRESULT __cdecl FlipRotate(_In_ const Image& srcImage, _In_ TEX_FR_FLAGS flags, _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl FlipRotate(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ TEX_FR_FLAGS flags, _Out_ ScratchImage& result) noexcept;
-        // Flip and/or rotate image
-#endif
-
-    enum TEX_FILTER_FLAGS : unsigned long
-    {
-        TEX_FILTER_DEFAULT = 0,
-
-        TEX_FILTER_WRAP_U = 0x1,
-        TEX_FILTER_WRAP_V = 0x2,
-        TEX_FILTER_WRAP_W = 0x4,
-        TEX_FILTER_WRAP = (TEX_FILTER_WRAP_U | TEX_FILTER_WRAP_V | TEX_FILTER_WRAP_W),
-        TEX_FILTER_MIRROR_U = 0x10,
-        TEX_FILTER_MIRROR_V = 0x20,
-        TEX_FILTER_MIRROR_W = 0x40,
-        TEX_FILTER_MIRROR = (TEX_FILTER_MIRROR_U | TEX_FILTER_MIRROR_V | TEX_FILTER_MIRROR_W),
-        // Wrap vs. Mirror vs. Clamp filtering options
-
-        TEX_FILTER_SEPARATE_ALPHA = 0x100,
-        // Resize color and alpha channel independently
-
-        TEX_FILTER_FLOAT_X2BIAS = 0x200,
-        // Enable *2 - 1 conversion cases for unorm<->float and positive-only float formats
-
-        TEX_FILTER_RGB_COPY_RED = 0x1000,
-        TEX_FILTER_RGB_COPY_GREEN = 0x2000,
-        TEX_FILTER_RGB_COPY_BLUE = 0x4000,
-        // When converting RGB to R, defaults to using grayscale. These flags indicate copying a specific channel instead
-        // When converting RGB to RG, defaults to copying RED | GREEN. These flags control which channels are selected instead.
-
-        TEX_FILTER_DITHER = 0x10000,
-        // Use ordered 4x4 dithering for any required conversions
-        TEX_FILTER_DITHER_DIFFUSION = 0x20000,
-        // Use error-diffusion dithering for any required conversions
-
-        TEX_FILTER_POINT = 0x100000,
-        TEX_FILTER_LINEAR = 0x200000,
-        TEX_FILTER_CUBIC = 0x300000,
-        TEX_FILTER_BOX = 0x400000,
-        TEX_FILTER_FANT = 0x400000, // Equiv to Box filtering for mipmap generation
-        TEX_FILTER_TRIANGLE = 0x500000,
-        // Filtering mode to use for any required image resizing
-
-        TEX_FILTER_SRGB_IN = 0x1000000,
-        TEX_FILTER_SRGB_OUT = 0x2000000,
-        TEX_FILTER_SRGB = (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT),
-        // sRGB <-> RGB for use in conversion operations
-        // if the input format type is IsSRGB(), then SRGB_IN is on by default
-        // if the output format type is IsSRGB(), then SRGB_OUT is on by default
-
-        TEX_FILTER_FORCE_NON_WIC = 0x10000000,
-        // Forces use of the non-WIC path when both are an option
-
-        TEX_FILTER_FORCE_WIC = 0x20000000,
-        // Forces use of the WIC path even when logic would have picked a non-WIC path when both are an option
-    };
-
-    constexpr unsigned long TEX_FILTER_DITHER_MASK = 0xF0000;
-    constexpr unsigned long TEX_FILTER_MODE_MASK = 0xF00000;
-    constexpr unsigned long TEX_FILTER_SRGB_MASK = 0xF000000;
-
-    HRESULT __cdecl Resize(
-        _In_ const Image& srcImage, _In_ size_t width, _In_ size_t height,
-        _In_ TEX_FILTER_FLAGS filter,
-        _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl Resize(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ size_t width, _In_ size_t height, _In_ TEX_FILTER_FLAGS filter, _Out_ ScratchImage& result) noexcept;
-        // Resize the image to width x height. Defaults to Fant filtering.
-        // Note for a complex resize, the result will always have mipLevels == 1
-
-    constexpr float TEX_THRESHOLD_DEFAULT = 0.5f;
-        // Default value for alpha threshold used when converting to 1-bit alpha
-
-    HRESULT __cdecl Convert(
-        _In_ const Image& srcImage, _In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS filter, _In_ float threshold,
-        _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl Convert(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS filter, _In_ float threshold, _Out_ ScratchImage& result) noexcept;
-        // Convert the image to a new format
-
-    HRESULT __cdecl ConvertToSinglePlane(_In_ const Image& srcImage, _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl ConvertToSinglePlane(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _Out_ ScratchImage& image) noexcept;
-        // Converts the image from a planar format to an equivalent non-planar format
-
-    HRESULT __cdecl GenerateMipMaps(
-        _In_ const Image& baseImage, _In_ TEX_FILTER_FLAGS filter, _In_ size_t levels,
-        _Inout_ ScratchImage& mipChain, _In_ bool allow1D = false) noexcept;
-    HRESULT __cdecl GenerateMipMaps(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ TEX_FILTER_FLAGS filter, _In_ size_t levels, _Inout_ ScratchImage& mipChain);
-        // levels of '0' indicates a full mipchain, otherwise is generates that number of total levels (including the source base image)
-        // Defaults to Fant filtering which is equivalent to a box filter
-
-    HRESULT __cdecl GenerateMipMaps3D(
-        _In_reads_(depth) const Image* baseImages, _In_ size_t depth, _In_ TEX_FILTER_FLAGS filter, _In_ size_t levels,
-        _Out_ ScratchImage& mipChain) noexcept;
-    HRESULT __cdecl GenerateMipMaps3D(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ TEX_FILTER_FLAGS filter, _In_ size_t levels, _Out_ ScratchImage& mipChain);
-        // levels of '0' indicates a full mipchain, otherwise is generates that number of total levels (including the source base image)
-        // Defaults to Fant filtering which is equivalent to a box filter
-
-    HRESULT __cdecl ScaleMipMapsAlphaForCoverage(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata, _In_ size_t item,
-        _In_ float alphaReference, _Inout_ ScratchImage& mipChain) noexcept;
-
-
-    enum TEX_PMALPHA_FLAGS : unsigned long
-    {
-        TEX_PMALPHA_DEFAULT = 0,
-
-        TEX_PMALPHA_IGNORE_SRGB = 0x1,
-        // ignores sRGB colorspace conversions
-
-        TEX_PMALPHA_REVERSE = 0x2,
-        // converts from premultiplied alpha back to straight alpha
-
-        TEX_PMALPHA_SRGB_IN = 0x1000000,
-        TEX_PMALPHA_SRGB_OUT = 0x2000000,
-        TEX_PMALPHA_SRGB = (TEX_PMALPHA_SRGB_IN | TEX_PMALPHA_SRGB_OUT),
-        // if the input format type is IsSRGB(), then SRGB_IN is on by default
-        // if the output format type is IsSRGB(), then SRGB_OUT is on by default
-    };
-
-    HRESULT __cdecl PremultiplyAlpha(_In_ const Image& srcImage, _In_ TEX_PMALPHA_FLAGS flags, _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl PremultiplyAlpha(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ TEX_PMALPHA_FLAGS flags, _Out_ ScratchImage& result) noexcept;
-        // Converts to/from a premultiplied alpha version of the texture
-
-    enum TEX_COMPRESS_FLAGS : unsigned long
-    {
-        TEX_COMPRESS_DEFAULT = 0,
-
-        TEX_COMPRESS_RGB_DITHER = 0x10000,
-        // Enables dithering RGB colors for BC1-3 compression
-
-        TEX_COMPRESS_A_DITHER = 0x20000,
-        // Enables dithering alpha for BC1-3 compression
-
-        TEX_COMPRESS_DITHER = 0x30000,
-        // Enables both RGB and alpha dithering for BC1-3 compression
-
-        TEX_COMPRESS_UNIFORM = 0x40000,
-        // Uniform color weighting for BC1-3 compression; by default uses perceptual weighting
-
-        TEX_COMPRESS_BC7_USE_3SUBSETS = 0x80000,
-        // Enables exhaustive search for BC7 compress for mode 0 and 2; by default skips trying these modes
-
-        TEX_COMPRESS_BC7_QUICK = 0x100000,
-        // Minimal modes (usually mode 6) for BC7 compression
-
-        TEX_COMPRESS_SRGB_IN = 0x1000000,
-        TEX_COMPRESS_SRGB_OUT = 0x2000000,
-        TEX_COMPRESS_SRGB = (TEX_COMPRESS_SRGB_IN | TEX_COMPRESS_SRGB_OUT),
-        // if the input format type is IsSRGB(), then SRGB_IN is on by default
-        // if the output format type is IsSRGB(), then SRGB_OUT is on by default
-
-        TEX_COMPRESS_PARALLEL = 0x10000000,
-        // Compress is free to use multithreading to improve performance (by default it does not use multithreading)
-    };
-
-    HRESULT __cdecl Compress(
-        _In_ const Image& srcImage, _In_ DXGI_FORMAT format, _In_ TEX_COMPRESS_FLAGS compress, _In_ float threshold,
-        _Out_ ScratchImage& cImage) noexcept;
-    HRESULT __cdecl Compress(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ DXGI_FORMAT format, _In_ TEX_COMPRESS_FLAGS compress, _In_ float threshold, _Out_ ScratchImage& cImages) noexcept;
-        // Note that threshold is only used by BC1. TEX_THRESHOLD_DEFAULT is a typical value to use
-
-#if defined(__d3d11_h__) || defined(__d3d11_x_h__)
-    HRESULT __cdecl Compress(
-        _In_ ID3D11Device* pDevice, _In_ const Image& srcImage, _In_ DXGI_FORMAT format, _In_ TEX_COMPRESS_FLAGS compress,
-        _In_ float alphaWeight, _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl Compress(
-        _In_ ID3D11Device* pDevice, _In_ const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ DXGI_FORMAT format, _In_ TEX_COMPRESS_FLAGS compress, _In_ float alphaWeight, _Out_ ScratchImage& cImages) noexcept;
-        // DirectCompute-based compression (alphaWeight is only used by BC7. 1.0 is the typical value to use)
-#endif
-
-    HRESULT __cdecl Decompress(_In_ const Image& cImage, _In_ DXGI_FORMAT format, _Out_ ScratchImage& image) noexcept;
-    HRESULT __cdecl Decompress(
-        _In_reads_(nimages) const Image* cImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ DXGI_FORMAT format, _Out_ ScratchImage& images) noexcept;
-
-    //---------------------------------------------------------------------------------
-    // Normal map operations
-
-    enum CNMAP_FLAGS : unsigned long
-    {
-        CNMAP_DEFAULT = 0,
-
-        CNMAP_CHANNEL_RED = 0x1,
-        CNMAP_CHANNEL_GREEN = 0x2,
-        CNMAP_CHANNEL_BLUE = 0x3,
-        CNMAP_CHANNEL_ALPHA = 0x4,
-        CNMAP_CHANNEL_LUMINANCE = 0x5,
-        // Channel selection when evaluting color value for height
-        // Luminance is a combination of red, green, and blue
-
-        CNMAP_MIRROR_U = 0x1000,
-        CNMAP_MIRROR_V = 0x2000,
-        CNMAP_MIRROR = 0x3000,
-        // Use mirror semantics for scanline references (defaults to wrap)
-
-        CNMAP_INVERT_SIGN = 0x4000,
-        // Inverts normal sign
-
-        CNMAP_COMPUTE_OCCLUSION = 0x8000,
-        // Computes a crude occlusion term stored in the alpha channel
-    };
-
-    HRESULT __cdecl ComputeNormalMap(
-        _In_ const Image& srcImage, _In_ CNMAP_FLAGS flags, _In_ float amplitude,
-        _In_ DXGI_FORMAT format, _Out_ ScratchImage& normalMap) noexcept;
-    HRESULT __cdecl ComputeNormalMap(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ CNMAP_FLAGS flags, _In_ float amplitude, _In_ DXGI_FORMAT format, _Out_ ScratchImage& normalMaps) noexcept;
-
-    //---------------------------------------------------------------------------------
-    // Misc image operations
-
-    struct Rect
-    {
-        size_t x;
-        size_t y;
-        size_t w;
-        size_t h;
-
-        Rect() = default;
-        Rect(size_t _x, size_t _y, size_t _w, size_t _h) noexcept : x(_x), y(_y), w(_w), h(_h) {}
-    };
-
-    HRESULT __cdecl CopyRectangle(
-        _In_ const Image& srcImage, _In_ const Rect& srcRect, _In_ const Image& dstImage,
-        _In_ TEX_FILTER_FLAGS filter, _In_ size_t xOffset, _In_ size_t yOffset) noexcept;
-
-    enum CMSE_FLAGS : unsigned long
-    {
-        CMSE_DEFAULT = 0,
-
-        CMSE_IMAGE1_SRGB = 0x1,
-        CMSE_IMAGE2_SRGB = 0x2,
-        // Indicates that image needs gamma correction before comparision
-
-        CMSE_IGNORE_RED = 0x10,
-        CMSE_IGNORE_GREEN = 0x20,
-        CMSE_IGNORE_BLUE = 0x40,
-        CMSE_IGNORE_ALPHA = 0x80,
-        // Ignore the channel when computing MSE
-
-        CMSE_IMAGE1_X2_BIAS = 0x100,
-        CMSE_IMAGE2_X2_BIAS = 0x200,
-        // Indicates that image should be scaled and biased before comparison (i.e. UNORM -> SNORM)
-    };
-
-    HRESULT __cdecl ComputeMSE(_In_ const Image& image1, _In_ const Image& image2, _Out_ float& mse, _Out_writes_opt_(4) float* mseV, _In_ CMSE_FLAGS flags = CMSE_DEFAULT) noexcept;
-
-    HRESULT __cdecl EvaluateImage(
-        _In_ const Image& image,
-        _In_ std::function<void __cdecl(_In_reads_(width) const XMVECTOR* pixels, size_t width, size_t y)> pixelFunc);
-    HRESULT __cdecl EvaluateImage(
-        _In_reads_(nimages) const Image* images, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ std::function<void __cdecl(_In_reads_(width) const XMVECTOR* pixels, size_t width, size_t y)> pixelFunc);
-
-    HRESULT __cdecl TransformImage(
-        _In_ const Image& image,
-        _In_ std::function<void __cdecl(_Out_writes_(width) XMVECTOR* outPixels,
-            _In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
-        ScratchImage& result);
-    HRESULT __cdecl TransformImage(
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ std::function<void __cdecl(_Out_writes_(width) XMVECTOR* outPixels,
-            _In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
-        ScratchImage& result);
-
-    //---------------------------------------------------------------------------------
-    // WIC utility code
-#ifdef _WIN32
-    enum WICCodecs
-    {
-        WIC_CODEC_BMP = 1,          // Windows Bitmap (.bmp)
-        WIC_CODEC_JPEG,             // Joint Photographic Experts Group (.jpg, .jpeg)
-        WIC_CODEC_PNG,              // Portable Network Graphics (.png)
-        WIC_CODEC_TIFF,             // Tagged Image File Format  (.tif, .tiff)
-        WIC_CODEC_GIF,              // Graphics Interchange Format  (.gif)
-        WIC_CODEC_WMP,              // Windows Media Photo / HD Photo / JPEG XR (.hdp, .jxr, .wdp)
-        WIC_CODEC_ICO,              // Windows Icon (.ico)
-        WIC_CODEC_HEIF,             // High Efficiency Image File (.heif, .heic)
-    };
-
-    REFGUID __cdecl GetWICCodec(_In_ WICCodecs codec) noexcept;
-
-    IWICImagingFactory* __cdecl GetWICFactory(bool& iswic2) noexcept;
-    void __cdecl SetWICFactory(_In_opt_ IWICImagingFactory* pWIC) noexcept;
-#endif
-
-    //---------------------------------------------------------------------------------
-    // DDS helper functions
-    HRESULT __cdecl EncodeDDSHeader(
-        _In_ const TexMetadata& metadata, DDS_FLAGS flags,
-        _Out_writes_bytes_to_opt_(maxsize, required) void* pDestination, _In_ size_t maxsize,
-        _Out_ size_t& required) noexcept;
-
-    //---------------------------------------------------------------------------------
-    // Direct3D interop
-
-    enum CREATETEX_FLAGS : uint32_t
-    {
-        CREATETEX_DEFAULT = 0,
-        CREATETEX_FORCE_SRGB = 0x1,
-        CREATETEX_IGNORE_SRGB = 0x2,
-    };
-
-    // Direct3D 11 functions
-#if defined(__d3d11_h__) || defined(__d3d11_x_h__)
-    bool __cdecl IsSupportedTexture(_In_ ID3D11Device* pDevice, _In_ const TexMetadata& metadata) noexcept;
-
-    HRESULT __cdecl CreateTexture(
-        _In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _Outptr_ ID3D11Resource** ppResource) noexcept;
-
-    HRESULT __cdecl CreateShaderResourceView(
-        _In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _Outptr_ ID3D11ShaderResourceView** ppSRV) noexcept;
-
-    HRESULT __cdecl CreateTextureEx(
-        _In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ D3D11_USAGE usage, _In_ unsigned int bindFlags, _In_ unsigned int cpuAccessFlags, _In_ unsigned int miscFlags, _In_ CREATETEX_FLAGS flags,
-        _Outptr_ ID3D11Resource** ppResource) noexcept;
-
-    HRESULT __cdecl CreateShaderResourceViewEx(
-        _In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        _In_ D3D11_USAGE usage, _In_ unsigned int bindFlags, _In_ unsigned int cpuAccessFlags, _In_ unsigned int miscFlags, _In_ CREATETEX_FLAGS flags,
-        _Outptr_ ID3D11ShaderResourceView** ppSRV) noexcept;
-
-    HRESULT __cdecl CaptureTexture(_In_ ID3D11Device* pDevice, _In_ ID3D11DeviceContext* pContext, _In_ ID3D11Resource* pSource, _Out_ ScratchImage& result) noexcept;
-#endif
-
-    // Direct3D 12 functions
-#if defined(__d3d12_h__) || defined(__d3d12_x_h__) || defined(__XBOX_D3D12_X__)
-    bool __cdecl IsSupportedTexture(_In_ ID3D12Device* pDevice, _In_ const TexMetadata& metadata) noexcept;
-
-    HRESULT __cdecl CreateTexture(
-        _In_ ID3D12Device* pDevice, _In_ const TexMetadata& metadata,
-        _Outptr_ ID3D12Resource** ppResource) noexcept;
-
-    HRESULT __cdecl CreateTextureEx(
-        _In_ ID3D12Device* pDevice, _In_ const TexMetadata& metadata,
-        _In_ D3D12_RESOURCE_FLAGS resFlags, _In_ CREATETEX_FLAGS flags,
-        _Outptr_ ID3D12Resource** ppResource) noexcept;
-
-    HRESULT __cdecl PrepareUpload(
-        _In_ ID3D12Device* pDevice,
-        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-        std::vector<D3D12_SUBRESOURCE_DATA>& subresources);
-
-    HRESULT __cdecl CaptureTexture(
-        _In_ ID3D12CommandQueue* pCommandQueue, _In_ ID3D12Resource* pSource, _In_ bool isCubeMap,
-        _Out_ ScratchImage& result,
-        _In_ D3D12_RESOURCE_STATES beforeState = D3D12_RESOURCE_STATE_RENDER_TARGET,
-        _In_ D3D12_RESOURCE_STATES afterState = D3D12_RESOURCE_STATE_RENDER_TARGET) noexcept;
-#endif
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wcovered-switch-default"
-#pragma clang diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
-#pragma clang diagnostic ignored "-Wswitch-enum"
-#endif
-
-#pragma warning(push)
-#pragma warning(disable : 4619 4616 4061)
-
-#include "DirectXTex.inl"
-
-#pragma warning(pop)
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-} // namespace
diff --git a/thirdparty/directxtex/DirectXTex.inl b/thirdparty/directxtex/DirectXTex.inl
deleted file mode 100644
index 7fef321..0000000
--- a/thirdparty/directxtex/DirectXTex.inl
+++ /dev/null
@@ -1,213 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTex.inl
-//
-// DirectX Texture Library
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-//=====================================================================================
-// Bitmask flags enumerator operators
-//=====================================================================================
-DEFINE_ENUM_FLAG_OPERATORS(CP_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(DDS_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(TGA_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(WIC_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(TEX_FR_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(TEX_FILTER_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(TEX_PMALPHA_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(TEX_COMPRESS_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(CNMAP_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(CMSE_FLAGS);
-DEFINE_ENUM_FLAG_OPERATORS(CREATETEX_FLAGS);
-
-// WIC_FILTER modes match TEX_FILTER modes
-constexpr WIC_FLAGS operator|(WIC_FLAGS a, TEX_FILTER_FLAGS b) { return static_cast<WIC_FLAGS>(static_cast<unsigned long>(a) | static_cast<unsigned long>(b & TEX_FILTER_MODE_MASK)); }
-constexpr WIC_FLAGS operator|(TEX_FILTER_FLAGS a, WIC_FLAGS b) { return static_cast<WIC_FLAGS>(static_cast<unsigned long>(a & TEX_FILTER_MODE_MASK) | static_cast<unsigned long>(b)); }
-
-// TEX_PMALPHA_SRGB match TEX_FILTER_SRGB
-constexpr TEX_PMALPHA_FLAGS operator|(TEX_PMALPHA_FLAGS a, TEX_FILTER_FLAGS b) { return static_cast<TEX_PMALPHA_FLAGS>(static_cast<unsigned long>(a) | static_cast<unsigned long>(b & TEX_FILTER_SRGB_MASK)); }
-constexpr TEX_PMALPHA_FLAGS operator|(TEX_FILTER_FLAGS a, TEX_PMALPHA_FLAGS b) { return static_cast<TEX_PMALPHA_FLAGS>(static_cast<unsigned long>(a & TEX_FILTER_SRGB_MASK) | static_cast<unsigned long>(b)); }
-
-// TEX_COMPRESS_SRGB match TEX_FILTER_SRGB
-constexpr TEX_COMPRESS_FLAGS operator|(TEX_COMPRESS_FLAGS a, TEX_FILTER_FLAGS b) { return static_cast<TEX_COMPRESS_FLAGS>(static_cast<unsigned long>(a) | static_cast<unsigned long>(b & TEX_FILTER_SRGB_MASK)); }
-constexpr TEX_COMPRESS_FLAGS operator|(TEX_FILTER_FLAGS a, TEX_COMPRESS_FLAGS b) { return static_cast<TEX_COMPRESS_FLAGS>(static_cast<unsigned long>(a & TEX_FILTER_SRGB_MASK) | static_cast<unsigned long>(b)); }
-
-
-//=====================================================================================
-// DXGI Format Utilities
-//=====================================================================================
-
-_Use_decl_annotations_
-constexpr bool __cdecl IsValid(DXGI_FORMAT fmt) noexcept
-{
-    return (static_cast<size_t>(fmt) >= 1 && static_cast<size_t>(fmt) <= 190);
-}
-
-_Use_decl_annotations_
-inline bool __cdecl IsCompressed(DXGI_FORMAT fmt) noexcept
-{
-    switch (fmt)
-    {
-    case DXGI_FORMAT_BC1_TYPELESS:
-    case DXGI_FORMAT_BC1_UNORM:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-    case DXGI_FORMAT_BC2_TYPELESS:
-    case DXGI_FORMAT_BC2_UNORM:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-    case DXGI_FORMAT_BC3_TYPELESS:
-    case DXGI_FORMAT_BC3_UNORM:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-    case DXGI_FORMAT_BC4_TYPELESS:
-    case DXGI_FORMAT_BC4_UNORM:
-    case DXGI_FORMAT_BC4_SNORM:
-    case DXGI_FORMAT_BC5_TYPELESS:
-    case DXGI_FORMAT_BC5_UNORM:
-    case DXGI_FORMAT_BC5_SNORM:
-    case DXGI_FORMAT_BC6H_TYPELESS:
-    case DXGI_FORMAT_BC6H_UF16:
-    case DXGI_FORMAT_BC6H_SF16:
-    case DXGI_FORMAT_BC7_TYPELESS:
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-_Use_decl_annotations_
-inline bool __cdecl IsPalettized(DXGI_FORMAT fmt) noexcept
-{
-    switch (fmt)
-    {
-    case DXGI_FORMAT_AI44:
-    case DXGI_FORMAT_IA44:
-    case DXGI_FORMAT_P8:
-    case DXGI_FORMAT_A8P8:
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-_Use_decl_annotations_
-inline bool __cdecl IsSRGB(DXGI_FORMAT fmt) noexcept
-{
-    switch (fmt)
-    {
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-_Use_decl_annotations_
-inline bool __cdecl IsBGR(DXGI_FORMAT fmt) noexcept
-{
-    switch (fmt)
-    {
-    case DXGI_FORMAT_B5G6R5_UNORM:
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8X8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-
-//=====================================================================================
-// Image I/O
-//=====================================================================================
-_Use_decl_annotations_
-inline HRESULT __cdecl SaveToDDSMemory(const Image& image, DDS_FLAGS flags, Blob& blob) noexcept
-{
-    TexMetadata mdata = {};
-    mdata.width = image.width;
-    mdata.height = image.height;
-    mdata.depth = 1;
-    mdata.arraySize = 1;
-    mdata.mipLevels = 1;
-    mdata.format = image.format;
-    mdata.dimension = TEX_DIMENSION_TEXTURE2D;
-
-    return SaveToDDSMemory(&image, 1, mdata, flags, blob);
-}
-
-_Use_decl_annotations_
-inline HRESULT __cdecl SaveToDDSFile(const Image& image, DDS_FLAGS flags, const wchar_t* szFile) noexcept
-{
-    TexMetadata mdata = {};
-    mdata.width = image.width;
-    mdata.height = image.height;
-    mdata.depth = 1;
-    mdata.arraySize = 1;
-    mdata.mipLevels = 1;
-    mdata.format = image.format;
-    mdata.dimension = TEX_DIMENSION_TEXTURE2D;
-
-    return SaveToDDSFile(&image, 1, mdata, flags, szFile);
-}
-
-
-//=====================================================================================
-// Compatability helpers
-//=====================================================================================
-_Use_decl_annotations_
-inline HRESULT __cdecl GetMetadataFromTGAMemory(const void* pSource, size_t size, TexMetadata& metadata) noexcept
-{
-    return GetMetadataFromTGAMemory(pSource, size, TGA_FLAGS_NONE, metadata);
-}
-
-_Use_decl_annotations_
-inline HRESULT __cdecl GetMetadataFromTGAFile(const wchar_t* szFile, TexMetadata& metadata) noexcept
-{
-    return GetMetadataFromTGAFile(szFile, TGA_FLAGS_NONE, metadata);
-}
-
-_Use_decl_annotations_
-inline HRESULT __cdecl LoadFromTGAMemory(const void* pSource, size_t size, TexMetadata* metadata, ScratchImage& image) noexcept
-{
-    return LoadFromTGAMemory(pSource, size, TGA_FLAGS_NONE, metadata, image);
-}
-
-_Use_decl_annotations_
-inline HRESULT __cdecl LoadFromTGAFile(const wchar_t* szFile, TexMetadata* metadata, ScratchImage& image) noexcept
-{
-    return LoadFromTGAFile(szFile, TGA_FLAGS_NONE, metadata, image);
-}
-
-_Use_decl_annotations_
-inline HRESULT __cdecl SaveToTGAMemory(const Image& image, Blob& blob, const TexMetadata* metadata) noexcept
-{
-    return SaveToTGAMemory(image, TGA_FLAGS_NONE, blob, metadata);
-}
-
-_Use_decl_annotations_
-inline HRESULT __cdecl SaveToTGAFile(const Image& image, const wchar_t* szFile, const TexMetadata* metadata) noexcept
-{
-    return SaveToTGAFile(image, TGA_FLAGS_NONE, szFile, metadata);
-}
diff --git a/thirdparty/directxtex/DirectXTexCompress.cpp b/thirdparty/directxtex/DirectXTexCompress.cpp
deleted file mode 100644
index 99385a9..0000000
--- a/thirdparty/directxtex/DirectXTexCompress.cpp
+++ /dev/null
@@ -1,850 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexCompress.cpp
-//
-// DirectX Texture Library - Texture compression
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#ifdef _OPENMP
-#include <omp.h>
-#pragma warning(disable : 4616 6993)
-#endif
-
-#include "BC.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-
-namespace
-{
-    constexpr uint32_t GetBCFlags(_In_ TEX_COMPRESS_FLAGS compress) noexcept
-    {
-        static_assert(static_cast<int>(TEX_COMPRESS_RGB_DITHER) == static_cast<int>(BC_FLAGS_DITHER_RGB), "TEX_COMPRESS_* flags should match BC_FLAGS_*");
-        static_assert(static_cast<int>(TEX_COMPRESS_A_DITHER) == static_cast<int>(BC_FLAGS_DITHER_A), "TEX_COMPRESS_* flags should match BC_FLAGS_*");
-        static_assert(static_cast<int>(TEX_COMPRESS_DITHER) == static_cast<int>(BC_FLAGS_DITHER_RGB | BC_FLAGS_DITHER_A), "TEX_COMPRESS_* flags should match BC_FLAGS_*");
-        static_assert(static_cast<int>(TEX_COMPRESS_UNIFORM) == static_cast<int>(BC_FLAGS_UNIFORM), "TEX_COMPRESS_* flags should match BC_FLAGS_*");
-        static_assert(static_cast<int>(TEX_COMPRESS_BC7_USE_3SUBSETS) == static_cast<int>(BC_FLAGS_USE_3SUBSETS), "TEX_COMPRESS_* flags should match BC_FLAGS_*");
-        static_assert(static_cast<int>(TEX_COMPRESS_BC7_QUICK) == static_cast<int>(BC_FLAGS_FORCE_BC7_MODE6), "TEX_COMPRESS_* flags should match BC_FLAGS_*");
-        return (compress & (BC_FLAGS_DITHER_RGB | BC_FLAGS_DITHER_A | BC_FLAGS_UNIFORM | BC_FLAGS_USE_3SUBSETS | BC_FLAGS_FORCE_BC7_MODE6));
-    }
-
-    constexpr TEX_FILTER_FLAGS GetSRGBFlags(_In_ TEX_COMPRESS_FLAGS compress) noexcept
-    {
-        static_assert(TEX_FILTER_SRGB_IN == 0x1000000, "TEX_FILTER_SRGB flag values don't match TEX_FILTER_SRGB_MASK");
-        static_assert(static_cast<int>(TEX_COMPRESS_SRGB_IN) == static_cast<int>(TEX_FILTER_SRGB_IN), "TEX_COMPRESS_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_COMPRESS_SRGB_OUT) == static_cast<int>(TEX_FILTER_SRGB_OUT), "TEX_COMPRESS_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_COMPRESS_SRGB) == static_cast<int>(TEX_FILTER_SRGB), "TEX_COMPRESS_SRGB* should match TEX_FILTER_SRGB*");
-        return static_cast<TEX_FILTER_FLAGS>(compress & TEX_FILTER_SRGB_MASK);
-    }
-
-    inline bool DetermineEncoderSettings(_In_ DXGI_FORMAT format, _Out_ BC_ENCODE& pfEncode, _Out_ size_t& blocksize, _Out_ TEX_FILTER_FLAGS& cflags) noexcept
-    {
-        switch (format)
-        {
-        case DXGI_FORMAT_BC1_UNORM:
-        case DXGI_FORMAT_BC1_UNORM_SRGB:    pfEncode = nullptr;         blocksize = 8;   cflags = TEX_FILTER_DEFAULT; break;
-        case DXGI_FORMAT_BC2_UNORM:
-        case DXGI_FORMAT_BC2_UNORM_SRGB:    pfEncode = D3DXEncodeBC2;   blocksize = 16;  cflags = TEX_FILTER_DEFAULT; break;
-        case DXGI_FORMAT_BC3_UNORM:
-        case DXGI_FORMAT_BC3_UNORM_SRGB:    pfEncode = D3DXEncodeBC3;   blocksize = 16;  cflags = TEX_FILTER_DEFAULT; break;
-        case DXGI_FORMAT_BC4_UNORM:         pfEncode = D3DXEncodeBC4U;  blocksize = 8;   cflags = TEX_FILTER_RGB_COPY_RED; break;
-        case DXGI_FORMAT_BC4_SNORM:         pfEncode = D3DXEncodeBC4S;  blocksize = 8;   cflags = TEX_FILTER_RGB_COPY_RED; break;
-        case DXGI_FORMAT_BC5_UNORM:         pfEncode = D3DXEncodeBC5U;  blocksize = 16;  cflags = TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN; break;
-        case DXGI_FORMAT_BC5_SNORM:         pfEncode = D3DXEncodeBC5S;  blocksize = 16;  cflags = TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN; break;
-        case DXGI_FORMAT_BC6H_UF16:         pfEncode = D3DXEncodeBC6HU; blocksize = 16;  cflags = TEX_FILTER_DEFAULT; break;
-        case DXGI_FORMAT_BC6H_SF16:         pfEncode = D3DXEncodeBC6HS; blocksize = 16;  cflags = TEX_FILTER_DEFAULT; break;
-        case DXGI_FORMAT_BC7_UNORM:
-        case DXGI_FORMAT_BC7_UNORM_SRGB:    pfEncode = D3DXEncodeBC7;   blocksize = 16;  cflags = TEX_FILTER_DEFAULT; break;
-        default:                            pfEncode = nullptr;         blocksize = 0;   cflags = TEX_FILTER_DEFAULT; return false;
-        }
-
-        return true;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    HRESULT CompressBC(
-        const Image& image,
-        const Image& result,
-        uint32_t bcflags,
-        TEX_FILTER_FLAGS srgb,
-        float threshold) noexcept
-    {
-        if (!image.pixels || !result.pixels)
-            return E_POINTER;
-
-        assert(image.width == result.width);
-        assert(image.height == result.height);
-
-        const DXGI_FORMAT format = image.format;
-        size_t sbpp = BitsPerPixel(format);
-        if (!sbpp)
-            return E_FAIL;
-
-        if (sbpp < 8)
-        {
-            // We don't support compressing from monochrome (DXGI_FORMAT_R1_UNORM)
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        // Round to bytes
-        sbpp = (sbpp + 7) / 8;
-
-        uint8_t *pDest = result.pixels;
-
-        // Determine BC format encoder
-        BC_ENCODE pfEncode;
-        size_t blocksize;
-        TEX_FILTER_FLAGS cflags;
-        if (!DetermineEncoderSettings(result.format, pfEncode, blocksize, cflags))
-            return HRESULT_E_NOT_SUPPORTED;
-
-        XM_ALIGNED_DATA(16) XMVECTOR temp[16];
-        const uint8_t *pSrc = image.pixels;
-        const uint8_t *pEnd = image.pixels + image.slicePitch;
-        const size_t rowPitch = image.rowPitch;
-        for (size_t h = 0; h < image.height; h += 4)
-        {
-            const uint8_t *sptr = pSrc;
-            uint8_t* dptr = pDest;
-            const size_t ph = std::min<size_t>(4, image.height - h);
-            size_t w = 0;
-            for (size_t count = 0; (count < result.rowPitch) && (w < image.width); count += blocksize, w += 4)
-            {
-                const size_t pw = std::min<size_t>(4, image.width - w);
-                assert(pw > 0 && ph > 0);
-
-                const ptrdiff_t bytesLeft = pEnd - sptr;
-                assert(bytesLeft > 0);
-                size_t bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft));
-                if (!LoadScanline(&temp[0], pw, sptr, bytesToRead, format))
-                    return E_FAIL;
-
-                if (ph > 1)
-                {
-                    bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch);
-                    if (!LoadScanline(&temp[4], pw, sptr + rowPitch, bytesToRead, format))
-                        return E_FAIL;
-
-                    if (ph > 2)
-                    {
-                        bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch * 2);
-                        if (!LoadScanline(&temp[8], pw, sptr + rowPitch * 2, bytesToRead, format))
-                            return E_FAIL;
-
-                        if (ph > 3)
-                        {
-                            bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch * 3);
-                            if (!LoadScanline(&temp[12], pw, sptr + rowPitch * 3, bytesToRead, format))
-                                return E_FAIL;
-                        }
-                    }
-                }
-
-                if (pw != 4 || ph != 4)
-                {
-                    // Replicate pixels for partial block
-                    static const size_t uSrc[] = { 0, 0, 0, 1 };
-
-                    if (pw < 4)
-                    {
-                        for (size_t t = 0; t < ph && t < 4; ++t)
-                        {
-                            for (size_t s = pw; s < 4; ++s)
-                            {
-                            #pragma prefast(suppress: 26000, "PREFAST false positive")
-                                temp[(t << 2) | s] = temp[(t << 2) | uSrc[s]];
-                            }
-                        }
-                    }
-
-                    if (ph < 4)
-                    {
-                        for (size_t t = ph; t < 4; ++t)
-                        {
-                            for (size_t s = 0; s < 4; ++s)
-                            {
-                            #pragma prefast(suppress: 26000, "PREFAST false positive")
-                                temp[(t << 2) | s] = temp[(uSrc[t] << 2) | s];
-                            }
-                        }
-                    }
-                }
-
-                ConvertScanline(temp, 16, result.format, format, cflags | srgb);
-
-                if (pfEncode)
-                    pfEncode(dptr, temp, bcflags);
-                else
-                    D3DXEncodeBC1(dptr, temp, threshold, bcflags);
-
-                sptr += sbpp * 4;
-                dptr += blocksize;
-            }
-
-            pSrc += rowPitch * 4;
-            pDest += result.rowPitch;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-#ifdef _OPENMP
-    HRESULT CompressBC_Parallel(
-        const Image& image,
-        const Image& result,
-        uint32_t bcflags,
-        TEX_FILTER_FLAGS srgb,
-        float threshold) noexcept
-    {
-        if (!image.pixels || !result.pixels)
-            return E_POINTER;
-
-        assert(image.width == result.width);
-        assert(image.height == result.height);
-
-        const DXGI_FORMAT format = image.format;
-        size_t sbpp = BitsPerPixel(format);
-        if (!sbpp)
-            return E_FAIL;
-
-        if (sbpp < 8)
-        {
-            // We don't support compressing from monochrome (DXGI_FORMAT_R1_UNORM)
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        // Round to bytes
-        sbpp = (sbpp + 7) / 8;
-
-        const uint8_t *pEnd = image.pixels + image.slicePitch;
-
-        // Determine BC format encoder
-        BC_ENCODE pfEncode;
-        size_t blocksize;
-        TEX_FILTER_FLAGS cflags;
-        if (!DetermineEncoderSettings(result.format, pfEncode, blocksize, cflags))
-            return HRESULT_E_NOT_SUPPORTED;
-
-        // Refactored version of loop to support parallel independance
-        const size_t nBlocks = std::max<size_t>(1, (image.width + 3) / 4) * std::max<size_t>(1, (image.height + 3) / 4);
-
-        bool fail = false;
-
-    #pragma omp parallel for
-        for (int nb = 0; nb < static_cast<int>(nBlocks); ++nb)
-        {
-            const int nbWidth = std::max<int>(1, int((image.width + 3) / 4));
-
-            int y = nb / nbWidth;
-            const int x = (nb - (y*nbWidth)) * 4;
-            y *= 4;
-
-            assert((x >= 0) && (x < int(image.width)));
-            assert((y >= 0) && (y < int(image.height)));
-
-            const size_t rowPitch = image.rowPitch;
-            const uint8_t *pSrc = image.pixels + (size_t(y)*rowPitch) + (size_t(x)*sbpp);
-
-            uint8_t *pDest = result.pixels + (size_t(nb)*blocksize);
-
-            const size_t ph = std::min<size_t>(4, image.height - size_t(y));
-            const size_t pw = std::min<size_t>(4, image.width - size_t(x));
-            assert(pw > 0 && ph > 0);
-
-            const ptrdiff_t bytesLeft = pEnd - pSrc;
-            assert(bytesLeft > 0);
-            size_t bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft));
-
-            XM_ALIGNED_DATA(16) XMVECTOR temp[16];
-            if (!LoadScanline(&temp[0], pw, pSrc, bytesToRead, format))
-                fail = true;
-
-            if (ph > 1)
-            {
-                bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch);
-                if (!LoadScanline(&temp[4], pw, pSrc + rowPitch, bytesToRead, format))
-                    fail = true;
-
-                if (ph > 2)
-                {
-                    bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch * 2);
-                    if (!LoadScanline(&temp[8], pw, pSrc + rowPitch * 2, bytesToRead, format))
-                        fail = true;
-
-                    if (ph > 3)
-                    {
-                        bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch * 3);
-                        if (!LoadScanline(&temp[12], pw, pSrc + rowPitch * 3, bytesToRead, format))
-                            fail = true;
-                    }
-                }
-            }
-
-            if (pw != 4 || ph != 4)
-            {
-                // Replicate pixels for partial block
-                static const size_t uSrc[] = { 0, 0, 0, 1 };
-
-                if (pw < 4)
-                {
-                    for (size_t t = 0; t < ph && t < 4; ++t)
-                    {
-                        for (size_t s = pw; s < 4; ++s)
-                        {
-                            temp[(t << 2) | s] = temp[(t << 2) | uSrc[s]];
-                        }
-                    }
-                }
-
-                if (ph < 4)
-                {
-                    for (size_t t = ph; t < 4; ++t)
-                    {
-                        for (size_t s = 0; s < 4; ++s)
-                        {
-                            temp[(t << 2) | s] = temp[(uSrc[t] << 2) | s];
-                        }
-                    }
-                }
-            }
-
-            ConvertScanline(temp, 16, result.format, format, cflags | srgb);
-
-            if (pfEncode)
-                pfEncode(pDest, temp, bcflags);
-            else
-                D3DXEncodeBC1(pDest, temp, threshold, bcflags);
-        }
-
-        return (fail) ? E_FAIL : S_OK;
-    }
-#endif // _OPENMP
-
-
-    //-------------------------------------------------------------------------------------
-    DXGI_FORMAT DefaultDecompress(_In_ DXGI_FORMAT format) noexcept
-    {
-        switch (format)
-        {
-        case DXGI_FORMAT_BC1_TYPELESS:
-        case DXGI_FORMAT_BC1_UNORM:
-        case DXGI_FORMAT_BC2_TYPELESS:
-        case DXGI_FORMAT_BC2_UNORM:
-        case DXGI_FORMAT_BC3_TYPELESS:
-        case DXGI_FORMAT_BC3_UNORM:
-        case DXGI_FORMAT_BC7_TYPELESS:
-        case DXGI_FORMAT_BC7_UNORM:
-            return DXGI_FORMAT_R8G8B8A8_UNORM;
-
-        case DXGI_FORMAT_BC1_UNORM_SRGB:
-        case DXGI_FORMAT_BC2_UNORM_SRGB:
-        case DXGI_FORMAT_BC3_UNORM_SRGB:
-        case DXGI_FORMAT_BC7_UNORM_SRGB:
-            return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
-
-        case DXGI_FORMAT_BC4_TYPELESS:
-        case DXGI_FORMAT_BC4_UNORM:
-            return DXGI_FORMAT_R8_UNORM;
-
-        case DXGI_FORMAT_BC4_SNORM:
-            return DXGI_FORMAT_R8_SNORM;
-
-        case DXGI_FORMAT_BC5_TYPELESS:
-        case DXGI_FORMAT_BC5_UNORM:
-            return DXGI_FORMAT_R8G8_UNORM;
-
-        case DXGI_FORMAT_BC5_SNORM:
-            return DXGI_FORMAT_R8G8_SNORM;
-
-        case DXGI_FORMAT_BC6H_TYPELESS:
-        case DXGI_FORMAT_BC6H_UF16:
-        case DXGI_FORMAT_BC6H_SF16:
-            // We could use DXGI_FORMAT_R32G32B32_FLOAT here since BC6H is always Alpha 1.0,
-            // but this format is more supported by viewers
-            return DXGI_FORMAT_R32G32B32A32_FLOAT;
-
-        default:
-            return DXGI_FORMAT_UNKNOWN;
-        }
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    HRESULT DecompressBC(_In_ const Image& cImage, _In_ const Image& result) noexcept
-    {
-        if (!cImage.pixels || !result.pixels)
-            return E_POINTER;
-
-        assert(cImage.width == result.width);
-        assert(cImage.height == result.height);
-
-        const DXGI_FORMAT format = result.format;
-        size_t dbpp = BitsPerPixel(format);
-        if (!dbpp)
-            return E_FAIL;
-
-        if (dbpp < 8)
-        {
-            // We don't support decompressing to monochrome (DXGI_FORMAT_R1_UNORM)
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        // Round to bytes
-        dbpp = (dbpp + 7) / 8;
-
-        uint8_t *pDest = result.pixels;
-        if (!pDest)
-            return E_POINTER;
-
-        // Promote "typeless" BC formats
-        DXGI_FORMAT cformat;
-        switch (cImage.format)
-        {
-        case DXGI_FORMAT_BC1_TYPELESS:  cformat = DXGI_FORMAT_BC1_UNORM; break;
-        case DXGI_FORMAT_BC2_TYPELESS:  cformat = DXGI_FORMAT_BC2_UNORM; break;
-        case DXGI_FORMAT_BC3_TYPELESS:  cformat = DXGI_FORMAT_BC3_UNORM; break;
-        case DXGI_FORMAT_BC4_TYPELESS:  cformat = DXGI_FORMAT_BC4_UNORM; break;
-        case DXGI_FORMAT_BC5_TYPELESS:  cformat = DXGI_FORMAT_BC5_UNORM; break;
-        case DXGI_FORMAT_BC6H_TYPELESS: cformat = DXGI_FORMAT_BC6H_UF16; break;
-        case DXGI_FORMAT_BC7_TYPELESS:  cformat = DXGI_FORMAT_BC7_UNORM; break;
-        default:                        cformat = cImage.format;         break;
-        }
-
-        // Determine BC format decoder
-        BC_DECODE pfDecode;
-        size_t sbpp;
-        switch (cformat)
-        {
-        case DXGI_FORMAT_BC1_UNORM:
-        case DXGI_FORMAT_BC1_UNORM_SRGB:    pfDecode = D3DXDecodeBC1;   sbpp = 8;   break;
-        case DXGI_FORMAT_BC2_UNORM:
-        case DXGI_FORMAT_BC2_UNORM_SRGB:    pfDecode = D3DXDecodeBC2;   sbpp = 16;  break;
-        case DXGI_FORMAT_BC3_UNORM:
-        case DXGI_FORMAT_BC3_UNORM_SRGB:    pfDecode = D3DXDecodeBC3;   sbpp = 16;  break;
-        case DXGI_FORMAT_BC4_UNORM:         pfDecode = D3DXDecodeBC4U;  sbpp = 8;   break;
-        case DXGI_FORMAT_BC4_SNORM:         pfDecode = D3DXDecodeBC4S;  sbpp = 8;   break;
-        case DXGI_FORMAT_BC5_UNORM:         pfDecode = D3DXDecodeBC5U;  sbpp = 16;  break;
-        case DXGI_FORMAT_BC5_SNORM:         pfDecode = D3DXDecodeBC5S;  sbpp = 16;  break;
-        case DXGI_FORMAT_BC6H_UF16:         pfDecode = D3DXDecodeBC6HU; sbpp = 16;  break;
-        case DXGI_FORMAT_BC6H_SF16:         pfDecode = D3DXDecodeBC6HS; sbpp = 16;  break;
-        case DXGI_FORMAT_BC7_UNORM:
-        case DXGI_FORMAT_BC7_UNORM_SRGB:    pfDecode = D3DXDecodeBC7;   sbpp = 16;  break;
-        default:
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        XM_ALIGNED_DATA(16) XMVECTOR temp[16];
-        const uint8_t *pSrc = cImage.pixels;
-        const size_t rowPitch = result.rowPitch;
-        for (size_t h = 0; h < cImage.height; h += 4)
-        {
-            const uint8_t *sptr = pSrc;
-            uint8_t* dptr = pDest;
-            const size_t ph = std::min<size_t>(4, cImage.height - h);
-            size_t w = 0;
-            for (size_t count = 0; (count < cImage.rowPitch) && (w < cImage.width); count += sbpp, w += 4)
-            {
-                pfDecode(temp, sptr);
-                ConvertScanline(temp, 16, format, cformat, TEX_FILTER_DEFAULT);
-
-                const size_t pw = std::min<size_t>(4, cImage.width - w);
-                assert(pw > 0 && ph > 0);
-
-                if (!StoreScanline(dptr, rowPitch, format, &temp[0], pw))
-                    return E_FAIL;
-
-                if (ph > 1)
-                {
-                    if (!StoreScanline(dptr + rowPitch, rowPitch, format, &temp[4], pw))
-                        return E_FAIL;
-
-                    if (ph > 2)
-                    {
-                        if (!StoreScanline(dptr + rowPitch * 2, rowPitch, format, &temp[8], pw))
-                            return E_FAIL;
-
-                        if (ph > 3)
-                        {
-                            if (!StoreScanline(dptr + rowPitch * 3, rowPitch, format, &temp[12], pw))
-                                return E_FAIL;
-                        }
-                    }
-                }
-
-                sptr += sbpp;
-                dptr += dbpp * 4;
-            }
-
-            pSrc += cImage.rowPitch;
-            pDest += rowPitch * 4;
-        }
-
-        return S_OK;
-    }
-}
-
-//-------------------------------------------------------------------------------------
-bool DirectX::Internal::IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept
-{
-    if (!cImage.pixels)
-        return false;
-
-    // Promote "typeless" BC formats
-    DXGI_FORMAT cformat;
-    switch (cImage.format)
-    {
-    case DXGI_FORMAT_BC1_TYPELESS:  cformat = DXGI_FORMAT_BC1_UNORM; break;
-    case DXGI_FORMAT_BC2_TYPELESS:  cformat = DXGI_FORMAT_BC2_UNORM; break;
-    case DXGI_FORMAT_BC3_TYPELESS:  cformat = DXGI_FORMAT_BC3_UNORM; break;
-    case DXGI_FORMAT_BC7_TYPELESS:  cformat = DXGI_FORMAT_BC7_UNORM; break;
-    default:                        cformat = cImage.format;         break;
-    }
-
-    // Determine BC format decoder
-    BC_DECODE pfDecode;
-    size_t sbpp;
-    switch (cformat)
-    {
-    case DXGI_FORMAT_BC1_UNORM:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:    pfDecode = D3DXDecodeBC1;   sbpp = 8;   break;
-    case DXGI_FORMAT_BC2_UNORM:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:    pfDecode = D3DXDecodeBC2;   sbpp = 16;  break;
-    case DXGI_FORMAT_BC3_UNORM:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:    pfDecode = D3DXDecodeBC3;   sbpp = 16;  break;
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:    pfDecode = D3DXDecodeBC7;   sbpp = 16;  break;
-    default:
-        // BC4, BC5, and BC6 don't have alpha channels
-        return false;
-    }
-
-    // Scan blocks for non-opaque alpha
-    static const XMVECTORF32 threshold = { { { 0.99f, 0.99f, 0.99f, 0.99f } } };
-
-    XM_ALIGNED_DATA(16) XMVECTOR temp[16];
-    const uint8_t* pPixels = cImage.pixels;
-    for (size_t h = 0; h < cImage.height; h += 4)
-    {
-        const uint8_t* ptr = pPixels;
-        const size_t ph = std::min<size_t>(4, cImage.height - h);
-        size_t w = 0;
-        for (size_t count = 0; (count < cImage.rowPitch) && (w < cImage.width); count += sbpp, w += 4)
-        {
-            pfDecode(temp, ptr);
-
-            const size_t pw = std::min<size_t>(4, cImage.width - w);
-            assert(pw > 0 && ph > 0);
-
-            if (pw == 4 && ph == 4)
-            {
-                // Full blocks
-                for (size_t j = 0; j < 16; ++j)
-                {
-                    const XMVECTOR alpha = XMVectorSplatW(temp[j]);
-                    if (XMVector4Less(alpha, threshold))
-                        return false;
-                }
-            }
-            else
-            {
-                // Handle partial blocks
-                for (size_t y = 0; y < ph; ++y)
-                {
-                    for (size_t x = 0; x < pw; ++x)
-                    {
-                        const XMVECTOR alpha = XMVectorSplatW(temp[y * 4 + x]);
-                        if (XMVector4Less(alpha, threshold))
-                            return false;
-                    }
-                }
-            }
-
-            ptr += sbpp;
-        }
-
-        pPixels += cImage.rowPitch;
-    }
-
-    return true;
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::Compress(
-    const Image& srcImage,
-    DXGI_FORMAT format,
-    TEX_COMPRESS_FLAGS compress,
-    float threshold,
-    ScratchImage& image) noexcept
-{
-    if (IsCompressed(srcImage.format) || !IsCompressed(format))
-        return E_INVALIDARG;
-
-    if (IsTypeless(format)
-        || IsTypeless(srcImage.format) || IsPlanar(srcImage.format) || IsPalettized(srcImage.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    // Create compressed image
-    HRESULT hr = image.Initialize2D(format, srcImage.width, srcImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *img = image.GetImage(0, 0, 0);
-    if (!img)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    // Compress single image
-    if (compress & TEX_COMPRESS_PARALLEL)
-    {
-    #ifndef _OPENMP
-        return E_NOTIMPL;
-    #else
-        hr = CompressBC_Parallel(srcImage, *img, GetBCFlags(compress), GetSRGBFlags(compress), threshold);
-    #endif // _OPENMP
-    }
-    else
-    {
-        hr = CompressBC(srcImage, *img, GetBCFlags(compress), GetSRGBFlags(compress), threshold);
-    }
-
-    if (FAILED(hr))
-        image.Release();
-
-    return hr;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::Compress(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    DXGI_FORMAT format,
-    TEX_COMPRESS_FLAGS compress,
-    float threshold,
-    ScratchImage& cImages) noexcept
-{
-    if (!srcImages || !nimages)
-        return E_INVALIDARG;
-
-    if (IsCompressed(metadata.format) || !IsCompressed(format))
-        return E_INVALIDARG;
-
-    if (IsTypeless(format)
-        || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    cImages.Release();
-
-    TexMetadata mdata2 = metadata;
-    mdata2.format = format;
-    HRESULT hr = cImages.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != cImages.GetImageCount())
-    {
-        cImages.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = cImages.GetImages();
-    if (!dest)
-    {
-        cImages.Release();
-        return E_POINTER;
-    }
-
-    for (size_t index = 0; index < nimages; ++index)
-    {
-        assert(dest[index].format == format);
-
-        const Image& src = srcImages[index];
-
-        if (src.width != dest[index].width || src.height != dest[index].height)
-        {
-            cImages.Release();
-            return E_FAIL;
-        }
-
-        if ((compress & TEX_COMPRESS_PARALLEL))
-        {
-        #ifndef _OPENMP
-            return E_NOTIMPL;
-        #else
-            if (compress & TEX_COMPRESS_PARALLEL)
-            {
-                hr = CompressBC_Parallel(src, dest[index], GetBCFlags(compress), GetSRGBFlags(compress), threshold);
-                if (FAILED(hr))
-                {
-                    cImages.Release();
-                    return  hr;
-                }
-            }
-        #endif // _OPENMP
-        }
-        else
-        {
-            hr = CompressBC(src, dest[index], GetBCFlags(compress), GetSRGBFlags(compress), threshold);
-            if (FAILED(hr))
-            {
-                cImages.Release();
-                return hr;
-            }
-        }
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Decompression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::Decompress(
-    const Image& cImage,
-    DXGI_FORMAT format,
-    ScratchImage& image) noexcept
-{
-    if (!IsCompressed(cImage.format) || IsCompressed(format))
-        return E_INVALIDARG;
-
-    if (format == DXGI_FORMAT_UNKNOWN)
-    {
-        // Pick a default decompressed format based on BC input format
-        format = DefaultDecompress(cImage.format);
-        if (format == DXGI_FORMAT_UNKNOWN)
-        {
-            // Input is not a compressed format
-            return E_INVALIDARG;
-        }
-    }
-    else
-    {
-        if (!IsValid(format))
-            return E_INVALIDARG;
-
-        if (IsTypeless(format) || IsPlanar(format) || IsPalettized(format))
-            return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    // Create decompressed image
-    HRESULT hr = image.Initialize2D(format, cImage.width, cImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *img = image.GetImage(0, 0, 0);
-    if (!img)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    // Decompress single image
-    hr = DecompressBC(cImage, *img);
-    if (FAILED(hr))
-        image.Release();
-
-    return hr;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::Decompress(
-    const Image* cImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    DXGI_FORMAT format,
-    ScratchImage& images) noexcept
-{
-    if (!cImages || !nimages)
-        return E_INVALIDARG;
-
-    if (!IsCompressed(metadata.format) || IsCompressed(format))
-        return E_INVALIDARG;
-
-    if (format == DXGI_FORMAT_UNKNOWN)
-    {
-        // Pick a default decompressed format based on BC input format
-        format = DefaultDecompress(cImages[0].format);
-        if (format == DXGI_FORMAT_UNKNOWN)
-        {
-            // Input is not a compressed format
-            return E_FAIL;
-        }
-    }
-    else
-    {
-        if (!IsValid(format))
-            return E_INVALIDARG;
-
-        if (IsTypeless(format) || IsPlanar(format) || IsPalettized(format))
-            return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    images.Release();
-
-    TexMetadata mdata2 = metadata;
-    mdata2.format = format;
-    HRESULT hr = images.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != images.GetImageCount())
-    {
-        images.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = images.GetImages();
-    if (!dest)
-    {
-        images.Release();
-        return E_POINTER;
-    }
-
-    for (size_t index = 0; index < nimages; ++index)
-    {
-        assert(dest[index].format == format);
-
-        const Image& src = cImages[index];
-        if (!IsCompressed(src.format))
-        {
-            images.Release();
-            return E_FAIL;
-        }
-
-        if (src.width != dest[index].width || src.height != dest[index].height)
-        {
-            images.Release();
-            return E_FAIL;
-        }
-
-        hr = DecompressBC(src, dest[index]);
-        if (FAILED(hr))
-        {
-            images.Release();
-            return hr;
-        }
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexCompressGPU.cpp b/thirdparty/directxtex/DirectXTexCompressGPU.cpp
deleted file mode 100644
index fb9d84d..0000000
--- a/thirdparty/directxtex/DirectXTexCompressGPU.cpp
+++ /dev/null
@@ -1,422 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexCompressGPU.cpp
-//
-// DirectX Texture Library - DirectCompute-based texture compression
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#include "BCDirectCompute.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-
-namespace
-{
-    constexpr TEX_FILTER_FLAGS GetSRGBFlags(_In_ TEX_COMPRESS_FLAGS compress) noexcept
-    {
-        static_assert(TEX_FILTER_SRGB_IN == 0x1000000, "TEX_FILTER_SRGB flag values don't match TEX_FILTER_SRGB_MASK");
-        static_assert(static_cast<int>(TEX_COMPRESS_SRGB_IN) == static_cast<int>(TEX_FILTER_SRGB_IN), "TEX_COMPRESS_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_COMPRESS_SRGB_OUT) == static_cast<int>(TEX_FILTER_SRGB_OUT), "TEX_COMPRESS_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_COMPRESS_SRGB) == static_cast<int>(TEX_FILTER_SRGB), "TEX_COMPRESS_SRGB* should match TEX_FILTER_SRGB*");
-        return static_cast<TEX_FILTER_FLAGS>(compress & TEX_FILTER_SRGB_MASK);
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Converts to R8G8B8A8_UNORM or R8G8B8A8_UNORM_SRGB doing any conversion logic needed
-    //-------------------------------------------------------------------------------------
-    HRESULT ConvertToRGBA32(
-        const Image& srcImage,
-        ScratchImage& image,
-        bool srgb,
-        TEX_FILTER_FLAGS filter) noexcept
-    {
-        if (!srcImage.pixels)
-            return E_POINTER;
-
-        const DXGI_FORMAT format = srgb ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM;
-
-        HRESULT hr = image.Initialize2D(format, srcImage.width, srcImage.height, 1, 1);
-        if (FAILED(hr))
-            return hr;
-
-        const Image *img = image.GetImage(0, 0, 0);
-        if (!img)
-        {
-            image.Release();
-            return E_POINTER;
-        }
-
-        uint8_t* pDest = img->pixels;
-        if (!pDest)
-        {
-            image.Release();
-            return E_POINTER;
-        }
-
-        auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
-        if (!scanline)
-        {
-            image.Release();
-            return E_OUTOFMEMORY;
-        }
-
-        const uint8_t *pSrc = srcImage.pixels;
-        for (size_t h = 0; h < srcImage.height; ++h)
-        {
-            if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
-            {
-                image.Release();
-                return E_FAIL;
-            }
-
-            ConvertScanline(scanline.get(), srcImage.width, format, srcImage.format, filter);
-
-            if (!StoreScanline(pDest, img->rowPitch, format, scanline.get(), srcImage.width))
-            {
-                image.Release();
-                return E_FAIL;
-            }
-
-            pSrc += srcImage.rowPitch;
-            pDest += img->rowPitch;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Converts to DXGI_FORMAT_R32G32B32A32_FLOAT doing any conversion logic needed
-    //-------------------------------------------------------------------------------------
-    HRESULT ConvertToRGBAF32(
-        const Image& srcImage,
-        ScratchImage& image,
-        TEX_FILTER_FLAGS filter) noexcept
-    {
-        if (!srcImage.pixels)
-            return E_POINTER;
-
-        HRESULT hr = image.Initialize2D(DXGI_FORMAT_R32G32B32A32_FLOAT, srcImage.width, srcImage.height, 1, 1);
-        if (FAILED(hr))
-            return hr;
-
-        const Image *img = image.GetImage(0, 0, 0);
-        if (!img)
-        {
-            image.Release();
-            return E_POINTER;
-        }
-
-        uint8_t* pDest = img->pixels;
-        if (!pDest)
-        {
-            image.Release();
-            return E_POINTER;
-        }
-
-        const uint8_t *pSrc = srcImage.pixels;
-        for (size_t h = 0; h < srcImage.height; ++h)
-        {
-            if (!LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
-            {
-                image.Release();
-                return E_FAIL;
-            }
-
-            ConvertScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, DXGI_FORMAT_R32G32B32A32_FLOAT, srcImage.format, filter);
-
-            pSrc += srcImage.rowPitch;
-            pDest += img->rowPitch;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Compress using GPU, converting to the proper input format for the shader if needed
-    //-------------------------------------------------------------------------------------
-    inline HRESULT GPUCompress(
-        _In_ GPUCompressBC* gpubc,
-        const Image& srcImage,
-        const Image& destImage,
-        TEX_COMPRESS_FLAGS compress)
-    {
-        if (!gpubc)
-            return E_POINTER;
-
-        assert(srcImage.pixels && destImage.pixels);
-
-        const DXGI_FORMAT format = gpubc->GetSourceFormat();
-
-        if (srcImage.format == format)
-        {
-            // Input is already in our required source format
-            return gpubc->Compress(srcImage, destImage);
-        }
-        else
-        {
-            // Convert format and then use as the source image
-            ScratchImage image;
-            HRESULT hr = E_UNEXPECTED;
-
-            auto const srgb = GetSRGBFlags(compress);
-
-            switch (format)
-            {
-            case DXGI_FORMAT_R8G8B8A8_UNORM:
-                hr = ConvertToRGBA32(srcImage, image, false, srgb);
-                break;
-
-            case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-                hr = ConvertToRGBA32(srcImage, image, true, srgb);
-                break;
-
-            case DXGI_FORMAT_R32G32B32A32_FLOAT:
-                hr = ConvertToRGBAF32(srcImage, image, srgb);
-                break;
-
-            default:
-                break;
-            }
-
-            if (FAILED(hr))
-                return hr;
-
-            const Image *img = image.GetImage(0, 0, 0);
-            if (!img)
-                return E_POINTER;
-
-            return gpubc->Compress(*img, destImage);
-        }
-    }
-};
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Compression
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::Compress(
-    ID3D11Device* pDevice,
-    const Image& srcImage,
-    DXGI_FORMAT format,
-    TEX_COMPRESS_FLAGS compress,
-    float alphaWeight,
-    ScratchImage& image) noexcept
-{
-    if (!pDevice || IsCompressed(srcImage.format) || !IsCompressed(format))
-        return E_INVALIDARG;
-
-    if (IsTypeless(format)
-        || IsTypeless(srcImage.format) || IsPlanar(srcImage.format) || IsPalettized(srcImage.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    // Setup GPU compressor
-    std::unique_ptr<GPUCompressBC> gpubc(new (std::nothrow) GPUCompressBC);
-    if (!gpubc)
-        return E_OUTOFMEMORY;
-
-    HRESULT hr = gpubc->Initialize(pDevice);
-    if (FAILED(hr))
-        return hr;
-
-    hr = gpubc->Prepare(srcImage.width, srcImage.height, compress, format, alphaWeight);
-    if (FAILED(hr))
-        return hr;
-
-    // Create workspace for result
-    hr = image.Initialize2D(format, srcImage.width, srcImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *img = image.GetImage(0, 0, 0);
-    if (!img)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    hr = GPUCompress(gpubc.get(), srcImage, *img, compress);
-    if (FAILED(hr))
-        image.Release();
-
-    return hr;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::Compress(
-    ID3D11Device* pDevice,
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    DXGI_FORMAT format,
-    TEX_COMPRESS_FLAGS compress,
-    float alphaWeight,
-    ScratchImage& cImages) noexcept
-{
-    if (!pDevice || !srcImages || !nimages)
-        return E_INVALIDARG;
-
-    if (IsCompressed(metadata.format) || !IsCompressed(format))
-        return E_INVALIDARG;
-
-    if (IsTypeless(format)
-        || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    cImages.Release();
-
-    // Setup GPU compressor
-    std::unique_ptr<GPUCompressBC> gpubc(new (std::nothrow) GPUCompressBC);
-    if (!gpubc)
-        return E_OUTOFMEMORY;
-
-    HRESULT hr = gpubc->Initialize(pDevice);
-    if (FAILED(hr))
-        return hr;
-
-    // Create workspace for result
-    TexMetadata mdata2 = metadata;
-    mdata2.format = format;
-    hr = cImages.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != cImages.GetImageCount())
-    {
-        cImages.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = cImages.GetImages();
-    if (!dest)
-    {
-        cImages.Release();
-        return E_POINTER;
-    }
-
-    // Process images (ordered by size)
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-    case TEX_DIMENSION_TEXTURE2D:
-        {
-            size_t w = metadata.width;
-            size_t h = metadata.height;
-
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                hr = gpubc->Prepare(w, h, compress, format, alphaWeight);
-                if (FAILED(hr))
-                {
-                    cImages.Release();
-                    return hr;
-                }
-
-                for (size_t item = 0; item < metadata.arraySize; ++item)
-                {
-                    const size_t index = metadata.ComputeIndex(level, item, 0);
-                    if (index >= nimages)
-                    {
-                        cImages.Release();
-                        return E_FAIL;
-                    }
-
-                    assert(dest[index].format == format);
-
-                    const Image& src = srcImages[index];
-
-                    if (src.width != dest[index].width || src.height != dest[index].height)
-                    {
-                        cImages.Release();
-                        return E_FAIL;
-                    }
-
-                    hr = GPUCompress(gpubc.get(), src, dest[index], compress);
-                    if (FAILED(hr))
-                    {
-                        cImages.Release();
-                        return hr;
-                    }
-                }
-
-                if (h > 1)
-                    h >>= 1;
-
-                if (w > 1)
-                    w >>= 1;
-            }
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        {
-            size_t w = metadata.width;
-            size_t h = metadata.height;
-            size_t d = metadata.depth;
-
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                hr = gpubc->Prepare(w, h, compress, format, alphaWeight);
-                if (FAILED(hr))
-                {
-                    cImages.Release();
-                    return hr;
-                }
-
-                for (size_t slice = 0; slice < d; ++slice)
-                {
-                    const size_t index = metadata.ComputeIndex(level, 0, slice);
-                    if (index >= nimages)
-                    {
-                        cImages.Release();
-                        return E_FAIL;
-                    }
-
-                    assert(dest[index].format == format);
-
-                    const Image& src = srcImages[index];
-
-                    if (src.width != dest[index].width || src.height != dest[index].height)
-                    {
-                        cImages.Release();
-                        return E_FAIL;
-                    }
-
-                    hr = GPUCompress(gpubc.get(), src, dest[index], compress);
-                    if (FAILED(hr))
-                    {
-                        cImages.Release();
-                        return hr;
-                    }
-                }
-
-                if (h > 1)
-                    h >>= 1;
-
-                if (w > 1)
-                    w >>= 1;
-
-                if (d > 1)
-                    d >>= 1;
-            }
-        }
-        break;
-
-    default:
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexConvert.cpp b/thirdparty/directxtex/DirectXTexConvert.cpp
deleted file mode 100644
index f98fbc7..0000000
--- a/thirdparty/directxtex/DirectXTexConvert.cpp
+++ /dev/null
@@ -1,5216 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexConvert.cpp
-//
-// DirectX Texture Library - Image pixel format conversion
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-using namespace DirectX::PackedVector;
-using Microsoft::WRL::ComPtr;
-
-namespace
-{
-    inline uint32_t FloatTo7e3(float Value) noexcept
-    {
-        uint32_t IValue = reinterpret_cast<uint32_t *>(&Value)[0];
-
-        if (IValue & 0x80000000U)
-        {
-            // Positive only
-            return 0;
-        }
-        else if (IValue > 0x41FF73FFU)
-        {
-            // The number is too large to be represented as a 7e3. Saturate.
-            return 0x3FFU;
-        }
-        else
-        {
-            if (IValue < 0x3E800000U)
-            {
-                // The number is too small to be represented as a normalized 7e3.
-                // Convert it to a denormalized value.
-                const uint32_t Shift = std::min<uint32_t>(125U - (IValue >> 23U), 24U);
-                IValue = (0x800000U | (IValue & 0x7FFFFFU)) >> Shift;
-            }
-            else
-            {
-                // Rebias the exponent to represent the value as a normalized 7e3.
-                IValue += 0xC2000000U;
-            }
-
-            return ((IValue + 0x7FFFU + ((IValue >> 16U) & 1U)) >> 16U) & 0x3FFU;
-        }
-    }
-
-    inline float FloatFrom7e3(uint32_t Value) noexcept
-    {
-        auto Mantissa = static_cast<uint32_t>(Value & 0x7F);
-
-        uint32_t Exponent = (Value & 0x380);
-        if (Exponent != 0)  // The value is normalized
-        {
-            Exponent = static_cast<uint32_t>((Value >> 7) & 0x7);
-        }
-        else if (Mantissa != 0)     // The value is denormalized
-        {
-            // Normalize the value in the resulting float
-            Exponent = 1;
-
-            do
-            {
-                Exponent--;
-                Mantissa <<= 1;
-            }
-            while ((Mantissa & 0x80) == 0);
-
-            Mantissa &= 0x7F;
-        }
-        else                        // The value is zero
-        {
-            Exponent = uint32_t(-124);
-        }
-
-        const uint32_t Result = ((Exponent + 124) << 23) | // Exponent
-            (Mantissa << 16);          // Mantissa
-
-        return reinterpret_cast<const float*>(&Result)[0];
-    }
-
-    inline uint32_t FloatTo6e4(float Value) noexcept
-    {
-        uint32_t IValue = reinterpret_cast<uint32_t *>(&Value)[0];
-
-        if (IValue & 0x80000000U)
-        {
-            // Positive only
-            return 0;
-        }
-        else if (IValue > 0x43FEFFFFU)
-        {
-            // The number is too large to be represented as a 6e4. Saturate.
-            return 0x3FFU;
-        }
-        else
-        {
-            if (IValue < 0x3C800000U)
-            {
-                // The number is too small to be represented as a normalized 6e4.
-                // Convert it to a denormalized value.
-                const uint32_t Shift = std::min<uint32_t>(121U - (IValue >> 23U), 24U);
-                IValue = (0x800000U | (IValue & 0x7FFFFFU)) >> Shift;
-            }
-            else
-            {
-                // Rebias the exponent to represent the value as a normalized 6e4.
-                IValue += 0xC4000000U;
-            }
-
-            return ((IValue + 0xFFFFU + ((IValue >> 17U) & 1U)) >> 17U) & 0x3FFU;
-        }
-    }
-
-    inline float FloatFrom6e4(uint32_t Value) noexcept
-    {
-        uint32_t Mantissa = static_cast<uint32_t>(Value & 0x3F);
-
-        uint32_t Exponent = (Value & 0x3C0);
-        if (Exponent != 0)  // The value is normalized
-        {
-            Exponent = static_cast<uint32_t>((Value >> 6) & 0xF);
-        }
-        else if (Mantissa != 0)     // The value is denormalized
-        {
-            // Normalize the value in the resulting float
-            Exponent = 1;
-
-            do
-            {
-                Exponent--;
-                Mantissa <<= 1;
-            }
-            while ((Mantissa & 0x40) == 0);
-
-            Mantissa &= 0x3F;
-        }
-        else                        // The value is zero
-        {
-            Exponent = uint32_t(-120);
-        }
-
-        const uint32_t Result = ((Exponent + 120) << 23) | // Exponent
-            (Mantissa << 17);          // Mantissa
-
-        return reinterpret_cast<const float*>(&Result)[0];
-    }
-
-#if DIRECTX_MATH_VERSION >= 310
-#define StoreFloat3SE XMStoreFloat3SE
-#else
-    inline void XM_CALLCONV StoreFloat3SE(_Out_ XMFLOAT3SE* pDestination, DirectX::FXMVECTOR V)
-    {
-        assert(pDestination);
-
-        DirectX::XMFLOAT3A tmp;
-        DirectX::XMStoreFloat3A(&tmp, V);
-
-        constexpr float maxf9 = float(0x1FF << 7);
-        constexpr float minf9 = float(1.f / (1 << 16));
-
-        float x = (tmp.x >= 0.f) ? ((tmp.x > maxf9) ? maxf9 : tmp.x) : 0.f;
-        float y = (tmp.y >= 0.f) ? ((tmp.y > maxf9) ? maxf9 : tmp.y) : 0.f;
-        float z = (tmp.z >= 0.f) ? ((tmp.z > maxf9) ? maxf9 : tmp.z) : 0.f;
-
-        const float max_xy = (x > y) ? x : y;
-        const float max_xyz = (max_xy > z) ? max_xy : z;
-
-        const float maxColor = (max_xyz > minf9) ? max_xyz : minf9;
-
-        union { float f; int32_t i; } fi;
-        fi.f = maxColor;
-        fi.i += 0x00004000; // round up leaving 9 bits in fraction (including assumed 1)
-
-        // Fix applied from DirectXMath 3.10
-        uint32_t exp = fi.i >> 23;
-        pDestination->e = exp - 0x6f;
-
-        fi.i = 0x83000000 - (exp << 23);
-        float ScaleR = fi.f;
-
-        pDestination->xm = static_cast<uint32_t>(lroundf(x * ScaleR));
-        pDestination->ym = static_cast<uint32_t>(lroundf(y * ScaleR));
-        pDestination->zm = static_cast<uint32_t>(lroundf(z * ScaleR));
-    }
-#endif
-
-    const XMVECTORF32 g_Grayscale = { { { 0.2125f, 0.7154f, 0.0721f, 0.0f } } };
-    const XMVECTORF32 g_HalfMin = { { { -65504.f, -65504.f, -65504.f, -65504.f } } };
-    const XMVECTORF32 g_HalfMax = { { { 65504.f, 65504.f, 65504.f, 65504.f } } };
-    const XMVECTORF32 g_8BitBias = { { { 0.5f / 255.f, 0.5f / 255.f, 0.5f / 255.f, 0.5f / 255.f } } };
-}
-
-//-------------------------------------------------------------------------------------
-// Copies an image row with optional clearing of alpha value to 1.0
-// (can be used in place as well) otherwise copies the image row unmodified.
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void DirectX::Internal::CopyScanline(
-    void* pDestination,
-    size_t outSize,
-    const void* pSource,
-    size_t inSize,
-    DXGI_FORMAT format,
-    uint32_t tflags) noexcept
-{
-    assert(pDestination && outSize > 0);
-    assert(pSource && inSize > 0);
-    assert(IsValid(format) && !IsPalettized(format));
-
-    if (tflags & TEXP_SCANLINE_SETALPHA)
-    {
-        switch (static_cast<int>(format))
-        {
-            //-----------------------------------------------------------------------------
-        case DXGI_FORMAT_R32G32B32A32_TYPELESS:
-        case DXGI_FORMAT_R32G32B32A32_FLOAT:
-        case DXGI_FORMAT_R32G32B32A32_UINT:
-        case DXGI_FORMAT_R32G32B32A32_SINT:
-            if (inSize >= 16 && outSize >= 16)
-            {
-                uint32_t alpha;
-                if (format == DXGI_FORMAT_R32G32B32A32_FLOAT)
-                    alpha = 0x3f800000;
-                else if (format == DXGI_FORMAT_R32G32B32A32_SINT)
-                    alpha = 0x7fffffff;
-                else
-                    alpha = 0xffffffff;
-
-                if (pDestination == pSource)
-                {
-                    auto dPtr = static_cast<uint32_t*>(pDestination);
-                    for (size_t count = 0; count < (outSize - 15); count += 16)
-                    {
-                        dPtr += 3;
-                        *(dPtr++) = alpha;
-                    }
-                }
-                else
-                {
-                    const uint32_t * __restrict sPtr = static_cast<const uint32_t*>(pSource);
-                    uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-                    const size_t size = std::min<size_t>(outSize, inSize);
-                    for (size_t count = 0; count < (size - 15); count += 16)
-                    {
-                        *(dPtr++) = *(sPtr++);
-                        *(dPtr++) = *(sPtr++);
-                        *(dPtr++) = *(sPtr++);
-                        *(dPtr++) = alpha;
-                        ++sPtr;
-                    }
-                }
-            }
-            return;
-
-            //-----------------------------------------------------------------------------
-        case DXGI_FORMAT_R16G16B16A16_TYPELESS:
-        case DXGI_FORMAT_R16G16B16A16_FLOAT:
-        case DXGI_FORMAT_R16G16B16A16_UNORM:
-        case DXGI_FORMAT_R16G16B16A16_UINT:
-        case DXGI_FORMAT_R16G16B16A16_SNORM:
-        case DXGI_FORMAT_R16G16B16A16_SINT:
-        case DXGI_FORMAT_Y416:
-            if (inSize >= 8 && outSize >= 8)
-            {
-                uint16_t alpha;
-                if (format == DXGI_FORMAT_R16G16B16A16_FLOAT)
-                    alpha = 0x3c00;
-                else if (format == DXGI_FORMAT_R16G16B16A16_SNORM || format == DXGI_FORMAT_R16G16B16A16_SINT)
-                    alpha = 0x7fff;
-                else
-                    alpha = 0xffff;
-
-                if (pDestination == pSource)
-                {
-                    auto dPtr = static_cast<uint16_t*>(pDestination);
-                    for (size_t count = 0; count < (outSize - 7); count += 8)
-                    {
-                        dPtr += 3;
-                        *(dPtr++) = alpha;
-                    }
-                }
-                else
-                {
-                    const uint16_t * __restrict sPtr = static_cast<const uint16_t*>(pSource);
-                    uint16_t * __restrict dPtr = static_cast<uint16_t*>(pDestination);
-                    const size_t size = std::min<size_t>(outSize, inSize);
-                    for (size_t count = 0; count < (size - 7); count += 8)
-                    {
-                        *(dPtr++) = *(sPtr++);
-                        *(dPtr++) = *(sPtr++);
-                        *(dPtr++) = *(sPtr++);
-                        *(dPtr++) = alpha;
-                        ++sPtr;
-                    }
-                }
-            }
-            return;
-
-            //-----------------------------------------------------------------------------
-        case DXGI_FORMAT_R10G10B10A2_TYPELESS:
-        case DXGI_FORMAT_R10G10B10A2_UNORM:
-        case DXGI_FORMAT_R10G10B10A2_UINT:
-        case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-        case DXGI_FORMAT_Y410:
-        case XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT:
-        case XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT:
-        case XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM:
-            if (inSize >= 4 && outSize >= 4)
-            {
-                if (pDestination == pSource)
-                {
-                    auto dPtr = static_cast<uint32_t*>(pDestination);
-                    for (size_t count = 0; count < (outSize - 3); count += 4)
-                    {
-                        *dPtr |= 0xC0000000;
-                        ++dPtr;
-                    }
-                }
-                else
-                {
-                    const uint32_t * __restrict sPtr = static_cast<const uint32_t*>(pSource);
-                    uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-                    const size_t size = std::min<size_t>(outSize, inSize);
-                    for (size_t count = 0; count < (size - 3); count += 4)
-                    {
-                        *(dPtr++) = *(sPtr++) | 0xC0000000;
-                    }
-                }
-            }
-            return;
-
-            //-----------------------------------------------------------------------------
-        case DXGI_FORMAT_R8G8B8A8_TYPELESS:
-        case DXGI_FORMAT_R8G8B8A8_UNORM:
-        case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-        case DXGI_FORMAT_R8G8B8A8_UINT:
-        case DXGI_FORMAT_R8G8B8A8_SNORM:
-        case DXGI_FORMAT_R8G8B8A8_SINT:
-        case DXGI_FORMAT_B8G8R8A8_UNORM:
-        case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-        case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        case DXGI_FORMAT_AYUV:
-            if (inSize >= 4 && outSize >= 4)
-            {
-                const uint32_t alpha = (format == DXGI_FORMAT_R8G8B8A8_SNORM || format == DXGI_FORMAT_R8G8B8A8_SINT) ? 0x7f000000 : 0xff000000;
-
-                if (pDestination == pSource)
-                {
-                    auto dPtr = static_cast<uint32_t*>(pDestination);
-                    for (size_t count = 0; count < (outSize - 3); count += 4)
-                    {
-                        uint32_t t = *dPtr & 0xFFFFFF;
-                        t |= alpha;
-                        *(dPtr++) = t;
-                    }
-                }
-                else
-                {
-                    const uint32_t * __restrict sPtr = static_cast<const uint32_t*>(pSource);
-                    uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-                    const size_t size = std::min<size_t>(outSize, inSize);
-                    for (size_t count = 0; count < (size - 3); count += 4)
-                    {
-                        uint32_t t = *(sPtr++) & 0xFFFFFF;
-                        t |= alpha;
-                        *(dPtr++) = t;
-                    }
-                }
-            }
-            return;
-
-            //-----------------------------------------------------------------------------
-        case DXGI_FORMAT_B5G5R5A1_UNORM:
-            if (inSize >= 2 && outSize >= 2)
-            {
-                if (pDestination == pSource)
-                {
-                    auto dPtr = static_cast<uint16_t*>(pDestination);
-                    for (size_t count = 0; count < (outSize - 1); count += 2)
-                    {
-                        *(dPtr++) |= 0x8000;
-                    }
-                }
-                else
-                {
-                    const uint16_t * __restrict sPtr = static_cast<const uint16_t*>(pSource);
-                    uint16_t * __restrict dPtr = static_cast<uint16_t*>(pDestination);
-                    const size_t size = std::min<size_t>(outSize, inSize);
-                    for (size_t count = 0; count < (size - 1); count += 2)
-                    {
-                        *(dPtr++) = uint16_t(*(sPtr++) | 0x8000);
-                    }
-                }
-            }
-            return;
-
-            //-----------------------------------------------------------------------------
-        case DXGI_FORMAT_A8_UNORM:
-            memset(pDestination, 0xff, outSize);
-            return;
-
-            //-----------------------------------------------------------------------------
-        case DXGI_FORMAT_B4G4R4A4_UNORM:
-            if (inSize >= 2 && outSize >= 2)
-            {
-                if (pDestination == pSource)
-                {
-                    auto dPtr = static_cast<uint16_t*>(pDestination);
-                    for (size_t count = 0; count < (outSize - 1); count += 2)
-                    {
-                        *(dPtr++) |= 0xF000;
-                    }
-                }
-                else
-                {
-                    const uint16_t * __restrict sPtr = static_cast<const uint16_t*>(pSource);
-                    uint16_t * __restrict dPtr = static_cast<uint16_t*>(pDestination);
-                    const size_t size = std::min<size_t>(outSize, inSize);
-                    for (size_t count = 0; count < (size - 1); count += 2)
-                    {
-                        *(dPtr++) = uint16_t(*(sPtr++) | 0xF000);
-                    }
-                }
-            }
-            return;
-        }
-    }
-
-    // Fall-through case is to just use memcpy (assuming this is not an in-place operation)
-    if (pDestination == pSource)
-        return;
-
-    const size_t size = std::min<size_t>(outSize, inSize);
-    memcpy(pDestination, pSource, size);
-}
-
-
-//-------------------------------------------------------------------------------------
-// Swizzles (RGB <-> BGR) an image row with optional clearing of alpha value to 1.0
-// (can be used in place as well) otherwise copies the image row unmodified.
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-void DirectX::Internal::SwizzleScanline(
-    void* pDestination,
-    size_t outSize,
-    const void* pSource,
-    size_t inSize,
-    DXGI_FORMAT format,
-    uint32_t tflags) noexcept
-{
-    assert(pDestination && outSize > 0);
-    assert(pSource && inSize > 0);
-    assert(IsValid(format) && !IsPlanar(format) && !IsPalettized(format));
-
-    switch (static_cast<int>(format))
-    {
-        //---------------------------------------------------------------------------------
-    case DXGI_FORMAT_R10G10B10A2_TYPELESS:
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-    case DXGI_FORMAT_R10G10B10A2_UINT:
-    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-    case XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM:
-        if (inSize >= 4 && outSize >= 4)
-        {
-            if (tflags & TEXP_SCANLINE_LEGACY)
-            {
-                // Swap Red (R) and Blue (B) channel (used for D3DFMT_A2R10G10B10 legacy sources)
-                if (pDestination == pSource)
-                {
-                    auto dPtr = static_cast<uint32_t*>(pDestination);
-                    for (size_t count = 0; count < (outSize - 3); count += 4)
-                    {
-                        const uint32_t t = *dPtr;
-
-                        uint32_t t1 = (t & 0x3ff00000) >> 20;
-                        uint32_t t2 = (t & 0x000003ff) << 20;
-                        uint32_t t3 = (t & 0x000ffc00);
-                        uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xC0000000 : (t & 0xC0000000);
-
-                        *(dPtr++) = t1 | t2 | t3 | ta;
-                    }
-                }
-                else
-                {
-                    const uint32_t * __restrict sPtr = static_cast<const uint32_t*>(pSource);
-                    uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-                    const size_t size = std::min<size_t>(outSize, inSize);
-                    for (size_t count = 0; count < (size - 3); count += 4)
-                    {
-                        const uint32_t t = *(sPtr++);
-
-                        uint32_t t1 = (t & 0x3ff00000) >> 20;
-                        uint32_t t2 = (t & 0x000003ff) << 20;
-                        uint32_t t3 = (t & 0x000ffc00);
-                        uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xC0000000 : (t & 0xC0000000);
-
-                        *(dPtr++) = t1 | t2 | t3 | ta;
-                    }
-                }
-                return;
-            }
-        }
-        break;
-
-        //---------------------------------------------------------------------------------
-    case DXGI_FORMAT_R8G8B8A8_TYPELESS:
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8X8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        if (inSize >= 4 && outSize >= 4)
-        {
-            // Swap Red (R) and Blue (B) channels (used to convert from DXGI 1.1 BGR formats to DXGI 1.0 RGB)
-            if (pDestination == pSource)
-            {
-                auto dPtr = static_cast<uint32_t*>(pDestination);
-                for (size_t count = 0; count < (outSize - 3); count += 4)
-                {
-                    const uint32_t t = *dPtr;
-
-                    uint32_t t1 = (t & 0x00ff0000) >> 16;
-                    uint32_t t2 = (t & 0x000000ff) << 16;
-                    uint32_t t3 = (t & 0x0000ff00);
-                    uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xff000000 : (t & 0xFF000000);
-
-                    *(dPtr++) = t1 | t2 | t3 | ta;
-                }
-            }
-            else
-            {
-                const uint32_t * __restrict sPtr = static_cast<const uint32_t*>(pSource);
-                uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-                const size_t size = std::min<size_t>(outSize, inSize);
-                for (size_t count = 0; count < (size - 3); count += 4)
-                {
-                    const uint32_t t = *(sPtr++);
-
-                    uint32_t t1 = (t & 0x00ff0000) >> 16;
-                    uint32_t t2 = (t & 0x000000ff) << 16;
-                    uint32_t t3 = (t & 0x0000ff00);
-                    uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xff000000 : (t & 0xFF000000);
-
-                    *(dPtr++) = t1 | t2 | t3 | ta;
-                }
-            }
-            return;
-        }
-        break;
-
-        //---------------------------------------------------------------------------------
-    case DXGI_FORMAT_YUY2:
-        if (inSize >= 4 && outSize >= 4)
-        {
-            if (tflags & TEXP_SCANLINE_LEGACY)
-            {
-                // Reorder YUV components (used to convert legacy UYVY -> YUY2)
-                if (pDestination == pSource)
-                {
-                    auto dPtr = static_cast<uint32_t*>(pDestination);
-                    for (size_t count = 0; count < (outSize - 3); count += 4)
-                    {
-                        const uint32_t t = *dPtr;
-
-                        uint32_t t1 = (t & 0x000000ff) << 8;
-                        uint32_t t2 = (t & 0x0000ff00) >> 8;
-                        uint32_t t3 = (t & 0x00ff0000) << 8;
-                        uint32_t t4 = (t & 0xff000000) >> 8;
-
-                        *(dPtr++) = t1 | t2 | t3 | t4;
-                    }
-                }
-                else
-                {
-                    const uint32_t * __restrict sPtr = static_cast<const uint32_t*>(pSource);
-                    uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-                    const size_t size = std::min<size_t>(outSize, inSize);
-                    for (size_t count = 0; count < (size - 3); count += 4)
-                    {
-                        const uint32_t t = *(sPtr++);
-
-                        uint32_t t1 = (t & 0x000000ff) << 8;
-                        uint32_t t2 = (t & 0x0000ff00) >> 8;
-                        uint32_t t3 = (t & 0x00ff0000) << 8;
-                        uint32_t t4 = (t & 0xff000000) >> 8;
-
-                        *(dPtr++) = t1 | t2 | t3 | t4;
-                    }
-                }
-                return;
-            }
-        }
-        break;
-    }
-
-    // Fall-through case is to just use memcpy (assuming this is not an in-place operation)
-    if (pDestination == pSource)
-        return;
-
-    const size_t size = std::min<size_t>(outSize, inSize);
-    memcpy(pDestination, pSource, size);
-}
-
-
-//-------------------------------------------------------------------------------------
-// Converts an image row with optional clearing of alpha value to 1.0
-// Returns true if supported, false if expansion case not supported
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::Internal::ExpandScanline(
-    void* pDestination,
-    size_t outSize,
-    DXGI_FORMAT outFormat,
-    const void* pSource,
-    size_t inSize,
-    DXGI_FORMAT inFormat,
-    uint32_t tflags) noexcept
-{
-    assert(pDestination && outSize > 0);
-    assert(pSource && inSize > 0);
-    assert(IsValid(outFormat) && !IsPlanar(outFormat) && !IsPalettized(outFormat));
-    assert(IsValid(inFormat) && !IsPlanar(inFormat) && !IsPalettized(inFormat));
-
-    switch (inFormat)
-    {
-    case DXGI_FORMAT_B5G6R5_UNORM:
-        if (outFormat != DXGI_FORMAT_R8G8B8A8_UNORM)
-            return false;
-
-        // DXGI_FORMAT_B5G6R5_UNORM -> DXGI_FORMAT_R8G8B8A8_UNORM
-        if (inSize >= 2 && outSize >= 4)
-        {
-            const uint16_t * __restrict sPtr = static_cast<const uint16_t*>(pSource);
-            uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-            for (size_t ocount = 0, icount = 0; ((icount < (inSize - 1)) && (ocount < (outSize - 3))); icount += 2, ocount += 4)
-            {
-                const uint16_t t = *(sPtr++);
-
-                uint32_t t1 = uint32_t(((t & 0xf800) >> 8) | ((t & 0xe000) >> 13));
-                uint32_t t2 = uint32_t(((t & 0x07e0) << 5) | ((t & 0x0600) >> 5));
-                uint32_t t3 = uint32_t(((t & 0x001f) << 19) | ((t & 0x001c) << 14));
-
-                *(dPtr++) = t1 | t2 | t3 | 0xff000000;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-        if (outFormat != DXGI_FORMAT_R8G8B8A8_UNORM)
-            return false;
-
-        // DXGI_FORMAT_B5G5R5A1_UNORM -> DXGI_FORMAT_R8G8B8A8_UNORM
-        if (inSize >= 2 && outSize >= 4)
-        {
-            const uint16_t * __restrict sPtr = static_cast<const uint16_t*>(pSource);
-            uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-            for (size_t ocount = 0, icount = 0; ((icount < (inSize - 1)) && (ocount < (outSize - 3))); icount += 2, ocount += 4)
-            {
-                const uint16_t t = *(sPtr++);
-
-                uint32_t t1 = uint32_t(((t & 0x7c00) >> 7) | ((t & 0x7000) >> 12));
-                uint32_t t2 = uint32_t(((t & 0x03e0) << 6) | ((t & 0x0380) << 1));
-                uint32_t t3 = uint32_t(((t & 0x001f) << 19) | ((t & 0x001c) << 14));
-                uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xff000000 : ((t & 0x8000) ? 0xff000000 : 0);
-
-                *(dPtr++) = t1 | t2 | t3 | ta;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-        if (outFormat != DXGI_FORMAT_R8G8B8A8_UNORM)
-            return false;
-
-        // DXGI_FORMAT_B4G4R4A4_UNORM -> DXGI_FORMAT_R8G8B8A8_UNORM
-        if (inSize >= 2 && outSize >= 4)
-        {
-            const uint16_t * __restrict sPtr = static_cast<const uint16_t*>(pSource);
-            uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-            for (size_t ocount = 0, icount = 0; ((icount < (inSize - 1)) && (ocount < (outSize - 3))); icount += 2, ocount += 4)
-            {
-                const uint16_t t = *(sPtr++);
-
-                uint32_t t1 = uint32_t(((t & 0x0f00) >> 4) | ((t & 0x0f00) >> 8));
-                uint32_t t2 = uint32_t(((t & 0x00f0) << 8) | ((t & 0x00f0) << 4));
-                uint32_t t3 = uint32_t(((t & 0x000f) << 20) | ((t & 0x000f) << 16));
-                uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xff000000 : uint32_t(((t & 0xf000) << 16) | ((t & 0xf000) << 12));
-
-                *(dPtr++) = t1 | t2 | t3 | ta;
-            }
-            return true;
-        }
-        return false;
-
-    default:
-        return false;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Loads an image row into standard RGBA XMVECTOR (aligned) array
-//-------------------------------------------------------------------------------------
-#define LOAD_SCANLINE( type, func )\
-        if (size >= sizeof(type))\
-        {\
-            const type * __restrict sPtr = reinterpret_cast<const type*>(pSource);\
-            for(size_t icount = 0; icount < (size - sizeof(type) + 1); icount += sizeof(type))\
-            {\
-                if (dPtr >= ePtr) break;\
-                *(dPtr++) = func(sPtr++);\
-            }\
-            return true;\
-        }\
-        return false;
-
-#define LOAD_SCANLINE3( type, func, defvec )\
-        if (size >= sizeof(type))\
-        {\
-            const type * __restrict sPtr = reinterpret_cast<const type*>(pSource);\
-            for(size_t icount = 0; icount < (size - sizeof(type) + 1); icount += sizeof(type))\
-            {\
-                const XMVECTOR v = func(sPtr++);\
-                if (dPtr >= ePtr) break;\
-                *(dPtr++) = XMVectorSelect(defvec, v, g_XMSelect1110);\
-            }\
-            return true;\
-        }\
-        return false;
-
-#define LOAD_SCANLINE2( type, func, defvec )\
-        if (size >= sizeof(type))\
-        {\
-            const type * __restrict sPtr = reinterpret_cast<const type*>(pSource);\
-            for(size_t icount = 0; icount < (size - sizeof(type) + 1); icount += sizeof(type))\
-            {\
-                const XMVECTOR v = func(sPtr++);\
-                if (dPtr >= ePtr) break;\
-                *(dPtr++) = XMVectorSelect(defvec, v, g_XMSelect1100);\
-            }\
-            return true;\
-        }\
-        return false;
-
-#pragma warning(suppress: 6101)
-_Use_decl_annotations_ bool DirectX::Internal::LoadScanline(
-    XMVECTOR* pDestination,
-    size_t count,
-    const void* pSource,
-    size_t size,
-    DXGI_FORMAT format) noexcept
-{
-    assert(pDestination && count > 0 && ((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0));
-    assert(pSource && size > 0);
-    assert(IsValid(format) && !IsTypeless(format, false) && !IsCompressed(format) && !IsPlanar(format) && !IsPalettized(format));
-
-    XMVECTOR* __restrict dPtr = pDestination;
-    if (!dPtr)
-        return false;
-
-    const XMVECTOR* ePtr = pDestination + count;
-
-    switch (static_cast<int>(format))
-    {
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-        {
-            const size_t msize = (size > (sizeof(XMVECTOR)*count)) ? (sizeof(XMVECTOR)*count) : size;
-            memcpy(dPtr, pSource, msize);
-        }
-        return true;
-
-    case DXGI_FORMAT_R32G32B32A32_UINT:
-        LOAD_SCANLINE(XMUINT4, XMLoadUInt4)
-
-    case DXGI_FORMAT_R32G32B32A32_SINT:
-        LOAD_SCANLINE(XMINT4, XMLoadSInt4)
-
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-        LOAD_SCANLINE3(XMFLOAT3, XMLoadFloat3, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R32G32B32_UINT:
-        LOAD_SCANLINE3(XMUINT3, XMLoadUInt3, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R32G32B32_SINT:
-        LOAD_SCANLINE3(XMINT3, XMLoadSInt3, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-        LOAD_SCANLINE(XMHALF4, XMLoadHalf4)
-
-    case DXGI_FORMAT_R16G16B16A16_UNORM:
-        LOAD_SCANLINE(XMUSHORTN4, XMLoadUShortN4)
-
-    case DXGI_FORMAT_R16G16B16A16_UINT:
-        LOAD_SCANLINE(XMUSHORT4, XMLoadUShort4)
-
-    case DXGI_FORMAT_R16G16B16A16_SNORM:
-        LOAD_SCANLINE(XMSHORTN4, XMLoadShortN4)
-
-    case DXGI_FORMAT_R16G16B16A16_SINT:
-        LOAD_SCANLINE(XMSHORT4, XMLoadShort4)
-
-    case DXGI_FORMAT_R32G32_FLOAT:
-        LOAD_SCANLINE2(XMFLOAT2, XMLoadFloat2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R32G32_UINT:
-        LOAD_SCANLINE2(XMUINT2, XMLoadUInt2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R32G32_SINT:
-        LOAD_SCANLINE2(XMINT2, XMLoadSInt2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
-            {
-                constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
-                if (size >= psize)
-                {
-                    auto sPtr = static_cast<const float*>(pSource);
-                    for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
-                    {
-                        auto ps8 = reinterpret_cast<const uint8_t*>(&sPtr[1]);
-                        if (dPtr >= ePtr) break;
-                        *(dPtr++) = XMVectorSet(sPtr[0], static_cast<float>(*ps8), 0.f, 1.f);
-                        sPtr += 2;
-                    }
-                    return true;
-                }
-            }
-            return false;
-
-    case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
-        {
-            constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
-            if (size >= psize)
-            {
-                auto sPtr = static_cast<const float*>(pSource);
-                for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
-                {
-                    if (dPtr >= ePtr) break;
-                    *(dPtr++) = XMVectorSet(sPtr[0], 0.f /* typeless component assumed zero */, 0.f, 1.f);
-                    sPtr += 2;
-                }
-                return true;
-            }
-        }
-        return false;
-
-    case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
-        {
-            constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
-            if (size >= psize)
-            {
-                auto sPtr = static_cast<const float*>(pSource);
-                for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
-                {
-                    auto pg8 = reinterpret_cast<const uint8_t*>(&sPtr[1]);
-                    if (dPtr >= ePtr) break;
-                    *(dPtr++) = XMVectorSet(0.f /* typeless component assumed zero */, static_cast<float>(*pg8), 0.f, 1.f);
-                    sPtr += 2;
-                }
-                return true;
-            }
-        }
-        return false;
-
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-        LOAD_SCANLINE(XMUDECN4, XMLoadUDecN4)
-
-    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-        LOAD_SCANLINE(XMUDECN4, XMLoadUDecN4_XR)
-
-    case DXGI_FORMAT_R10G10B10A2_UINT:
-        LOAD_SCANLINE(XMUDEC4, XMLoadUDec4)
-
-    case DXGI_FORMAT_R11G11B10_FLOAT:
-        LOAD_SCANLINE3(XMFLOAT3PK, XMLoadFloat3PK, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-        LOAD_SCANLINE(XMUBYTEN4, XMLoadUByteN4)
-
-    case DXGI_FORMAT_R8G8B8A8_UINT:
-        LOAD_SCANLINE(XMUBYTE4, XMLoadUByte4)
-
-    case DXGI_FORMAT_R8G8B8A8_SNORM:
-        LOAD_SCANLINE(XMBYTEN4, XMLoadByteN4)
-
-    case DXGI_FORMAT_R8G8B8A8_SINT:
-        LOAD_SCANLINE(XMBYTE4, XMLoadByte4)
-
-    case DXGI_FORMAT_R16G16_FLOAT:
-        LOAD_SCANLINE2(XMHALF2, XMLoadHalf2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R16G16_UNORM:
-        LOAD_SCANLINE2(XMUSHORTN2, XMLoadUShortN2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R16G16_UINT:
-        LOAD_SCANLINE2(XMUSHORT2, XMLoadUShort2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R16G16_SNORM:
-        LOAD_SCANLINE2(XMSHORTN2, XMLoadShortN2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R16G16_SINT:
-        LOAD_SCANLINE2(XMSHORT2, XMLoadShort2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_D32_FLOAT:
-    case DXGI_FORMAT_R32_FLOAT:
-        if (size >= sizeof(float))
-        {
-            const float* __restrict sPtr = static_cast<const float*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(float) + 1); icount += sizeof(float))
-            {
-                const XMVECTOR v = XMLoadFloat(sPtr++);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v, g_XMSelect1000);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R32_UINT:
-        if (size >= sizeof(uint32_t))
-        {
-            const uint32_t* __restrict sPtr = static_cast<const uint32_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(uint32_t) + 1); icount += sizeof(uint32_t))
-            {
-                XMVECTOR v = XMLoadInt(sPtr++);
-                v = XMConvertVectorUIntToFloat(v, 0);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v, g_XMSelect1000);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R32_SINT:
-        if (size >= sizeof(int32_t))
-        {
-            const int32_t * __restrict sPtr = static_cast<const int32_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(int32_t) + 1); icount += sizeof(int32_t))
-            {
-                XMVECTOR v = XMLoadInt(reinterpret_cast<const uint32_t*>(sPtr++));
-                v = XMConvertVectorIntToFloat(v, 0);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v, g_XMSelect1000);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_D24_UNORM_S8_UINT:
-        if (size >= sizeof(uint32_t))
-        {
-            auto sPtr = static_cast<const uint32_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(uint32_t) + 1); icount += sizeof(uint32_t))
-            {
-                auto const d = static_cast<float>(*sPtr & 0xFFFFFF) / 16777215.f;
-                auto const s = static_cast<float>((*sPtr & 0xFF000000) >> 24);
-                ++sPtr;
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(d, s, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
-        if (size >= sizeof(uint32_t))
-        {
-            auto sPtr = static_cast<const uint32_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(uint32_t) + 1); icount += sizeof(uint32_t))
-            {
-                auto const r = static_cast<float>(*sPtr & 0xFFFFFF) / 16777215.f;
-                ++sPtr;
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(r, 0.f /* typeless component assumed zero */, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
-        if (size >= sizeof(uint32_t))
-        {
-            auto sPtr = static_cast<const uint32_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(uint32_t) + 1); icount += sizeof(uint32_t))
-            {
-                auto const g = static_cast<float>((*sPtr & 0xFF000000) >> 24);
-                ++sPtr;
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(0.f /* typeless component assumed zero */, g, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8G8_UNORM:
-        LOAD_SCANLINE2(XMUBYTEN2, XMLoadUByteN2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R8G8_UINT:
-        LOAD_SCANLINE2(XMUBYTE2, XMLoadUByte2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R8G8_SNORM:
-        LOAD_SCANLINE2(XMBYTEN2, XMLoadByteN2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R8G8_SINT:
-        LOAD_SCANLINE2(XMBYTE2, XMLoadByte2, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R16_FLOAT:
-        if (size >= sizeof(HALF))
-        {
-            const HALF * __restrict sPtr = static_cast<const HALF*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(HALF) + 1); icount += sizeof(HALF))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(XMConvertHalfToFloat(*sPtr++), 0.f, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_D16_UNORM:
-    case DXGI_FORMAT_R16_UNORM:
-        if (size >= sizeof(uint16_t))
-        {
-            const uint16_t* __restrict sPtr = static_cast<const uint16_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(uint16_t) + 1); icount += sizeof(uint16_t))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(static_cast<float>(*sPtr++) / 65535.f, 0.f, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R16_UINT:
-        if (size >= sizeof(uint16_t))
-        {
-            const uint16_t * __restrict sPtr = static_cast<const uint16_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(uint16_t) + 1); icount += sizeof(uint16_t))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(static_cast<float>(*sPtr++), 0.f, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R16_SNORM:
-        if (size >= sizeof(int16_t))
-        {
-            const int16_t * __restrict sPtr = static_cast<const int16_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(int16_t) + 1); icount += sizeof(int16_t))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(static_cast<float>(*sPtr++) / 32767.f, 0.f, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R16_SINT:
-        if (size >= sizeof(int16_t))
-        {
-            const int16_t * __restrict sPtr = static_cast<const int16_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(int16_t) + 1); icount += sizeof(int16_t))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(static_cast<float>(*sPtr++), 0.f, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8_UNORM:
-        if (size >= sizeof(uint8_t))
-        {
-            const uint8_t * __restrict sPtr = static_cast<const uint8_t*>(pSource);
-            for (size_t icount = 0; icount < size; icount += sizeof(uint8_t))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(static_cast<float>(*sPtr++) / 255.f, 0.f, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8_UINT:
-        if (size >= sizeof(uint8_t))
-        {
-            const uint8_t * __restrict sPtr = static_cast<const uint8_t*>(pSource);
-            for (size_t icount = 0; icount < size; icount += sizeof(uint8_t))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(static_cast<float>(*sPtr++), 0.f, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8_SNORM:
-        if (size >= sizeof(int8_t))
-        {
-            const int8_t * __restrict sPtr = static_cast<const int8_t*>(pSource);
-            for (size_t icount = 0; icount < size; icount += sizeof(int8_t))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(static_cast<float>(*sPtr++) / 127.f, 0.f, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8_SINT:
-        if (size >= sizeof(int8_t))
-        {
-            const int8_t * __restrict sPtr = static_cast<const int8_t*>(pSource);
-            for (size_t icount = 0; icount < size; icount += sizeof(int8_t))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(static_cast<float>(*sPtr++), 0.f, 0.f, 1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_A8_UNORM:
-        if (size >= sizeof(uint8_t))
-        {
-            const uint8_t * __restrict sPtr = static_cast<const uint8_t*>(pSource);
-            for (size_t icount = 0; icount < size; icount += sizeof(uint8_t))
-            {
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(0.f, 0.f, 0.f, static_cast<float>(*sPtr++) / 255.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R1_UNORM:
-        if (size >= sizeof(uint8_t))
-        {
-            const uint8_t * __restrict sPtr = static_cast<const uint8_t*>(pSource);
-            for (size_t icount = 0; icount < size; icount += sizeof(uint8_t))
-            {
-                for (size_t bcount = 8; bcount > 0; --bcount)
-                {
-                    if (dPtr >= ePtr) break;
-                    *(dPtr++) = XMVectorSet((((*sPtr >> (bcount - 1)) & 0x1) ? 1.f : 0.f), 0.f, 0.f, 1.f);
-                }
-
-                ++sPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
-        LOAD_SCANLINE3(XMFLOAT3SE, XMLoadFloat3SE, g_XMIdentityR3)
-
-    case DXGI_FORMAT_R8G8_B8G8_UNORM:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            const XMUBYTEN4 * __restrict sPtr = static_cast<const XMUBYTEN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                const XMVECTOR v = XMLoadUByteN4(sPtr++);
-                const XMVECTOR v1 = XMVectorSwizzle<0, 3, 2, 1>(v);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v, g_XMSelect1110);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v1, g_XMSelect1110);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_G8R8_G8B8_UNORM:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            const XMUBYTEN4 * __restrict sPtr = static_cast<const XMUBYTEN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                const XMVECTOR v = XMLoadUByteN4(sPtr++);
-                const XMVECTOR v0 = XMVectorSwizzle<1, 0, 3, 2>(v);
-                const XMVECTOR v1 = XMVectorSwizzle<1, 2, 3, 0>(v);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v0, g_XMSelect1110);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v1, g_XMSelect1110);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B5G6R5_UNORM:
-        if (size >= sizeof(XMU565))
-        {
-            static const XMVECTORF32 s_Scale = { { { 1.f / 31.f, 1.f / 63.f, 1.f / 31.f, 1.f } } };
-            const XMU565 * __restrict sPtr = static_cast<const XMU565*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMU565) + 1); icount += sizeof(XMU565))
-            {
-                XMVECTOR v = XMLoadU565(sPtr++);
-                v = XMVectorMultiply(v, s_Scale);
-                v = XMVectorSwizzle<2, 1, 0, 3>(v);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v, g_XMSelect1110);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-        if (size >= sizeof(XMU555))
-        {
-            static const XMVECTORF32 s_Scale = { { { 1.f / 31.f, 1.f / 31.f, 1.f / 31.f, 1.f } } };
-            const XMU555 * __restrict sPtr = static_cast<const XMU555*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMU555) + 1); icount += sizeof(XMU555))
-            {
-                XMVECTOR v = XMLoadU555(sPtr++);
-                v = XMVectorMultiply(v, s_Scale);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSwizzle<2, 1, 0, 3>(v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            const XMUBYTEN4 * __restrict sPtr = static_cast<const XMUBYTEN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                const XMVECTOR v = XMLoadUByteN4(sPtr++);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSwizzle<2, 1, 0, 3>(v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            const XMUBYTEN4 * __restrict sPtr = static_cast<const XMUBYTEN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                XMVECTOR v = XMLoadUByteN4(sPtr++);
-                v = XMVectorSwizzle<2, 1, 0, 3>(v);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v, g_XMSelect1110);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_AYUV:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            const XMUBYTEN4 * __restrict sPtr = static_cast<const XMUBYTEN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                const int v = int(sPtr->x) - 128;
-                const int u = int(sPtr->y) - 128;
-                const int y = int(sPtr->z) - 16;
-                const unsigned int a = sPtr->w;
-                ++sPtr;
-
-                // http://msdn.microsoft.com/en-us/library/windows/desktop/dd206750.aspx
-
-                // Y'  = Y - 16
-                // Cb' = Cb - 128
-                // Cr' = Cr - 128
-
-                // R = 1.1644Y' + 1.5960Cr'
-                // G = 1.1644Y' - 0.3917Cb' - 0.8128Cr'
-                // B = 1.1644Y' + 2.0172Cb'
-
-                const int r = (298 * y + 409 * v + 128) >> 8;
-                const int g = (298 * y - 100 * u - 208 * v + 128) >> 8;
-                const int b = (298 * y + 516 * u + 128) >> 8;
-
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(float(std::min<int>(std::max<int>(r, 0), 255)) / 255.f,
-                    float(std::min<int>(std::max<int>(g, 0), 255)) / 255.f,
-                    float(std::min<int>(std::max<int>(b, 0), 255)) / 255.f,
-                    float(a) / 255.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_Y410:
-        if (size >= sizeof(XMUDECN4))
-        {
-            const XMUDECN4 * __restrict sPtr = static_cast<const XMUDECN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUDECN4) + 1); icount += sizeof(XMUDECN4))
-            {
-                const int64_t u = int(sPtr->x) - 512;
-                const int64_t y = int(sPtr->y) - 64;
-                const int64_t v = int(sPtr->z) - 512;
-                const unsigned int a = sPtr->w;
-                ++sPtr;
-
-                // http://msdn.microsoft.com/en-us/library/windows/desktop/bb970578.aspx
-
-                // Y'  = Y - 64
-                // Cb' = Cb - 512
-                // Cr' = Cr - 512
-
-                // R = 1.1678Y' + 1.6007Cr'
-                // G = 1.1678Y' - 0.3929Cb' - 0.8152Cr'
-                // B = 1.1678Y' + 2.0232Cb'
-
-                auto const r = static_cast<int>((76533 * y + 104905 * v + 32768) >> 16);
-                auto const g = static_cast<int>((76533 * y - 25747 * u - 53425 * v + 32768) >> 16);
-                auto const b = static_cast<int>((76533 * y + 132590 * u + 32768) >> 16);
-
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(float(std::min<int>(std::max<int>(r, 0), 1023)) / 1023.f,
-                    float(std::min<int>(std::max<int>(g, 0), 1023)) / 1023.f,
-                    float(std::min<int>(std::max<int>(b, 0), 1023)) / 1023.f,
-                    float(a) / 3.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_Y416:
-        if (size >= sizeof(XMUSHORTN4))
-        {
-            const XMUSHORTN4 * __restrict sPtr = static_cast<const XMUSHORTN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUSHORTN4) + 1); icount += sizeof(XMUSHORTN4))
-            {
-                const int64_t u = int64_t(sPtr->x) - 32768;
-                const int64_t y = int64_t(sPtr->y) - 4096;
-                const int64_t v = int64_t(sPtr->z) - 32768;
-                auto const a = static_cast<int>(sPtr->w);
-                ++sPtr;
-
-                // http://msdn.microsoft.com/en-us/library/windows/desktop/bb970578.aspx
-
-                // Y'  = Y - 4096
-                // Cb' = Cb - 32768
-                // Cr' = Cr - 32768
-
-                // R = 1.1689Y' + 1.6023Cr'
-                // G = 1.1689Y' - 0.3933Cb' - 0.8160Cr'
-                // B = 1.1689Y'+ 2.0251Cb'
-
-                auto const r = static_cast<int>((76607 * y + 105006 * v + 32768) >> 16);
-                auto const g = static_cast<int>((76607 * y - 25772 * u - 53477 * v + 32768) >> 16);
-                auto const b = static_cast<int>((76607 * y + 132718 * u + 32768) >> 16);
-
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(float(std::min<int>(std::max<int>(r, 0), 65535)) / 65535.f,
-                    float(std::min<int>(std::max<int>(g, 0), 65535)) / 65535.f,
-                    float(std::min<int>(std::max<int>(b, 0), 65535)) / 65535.f,
-                    float(std::min<int>(std::max<int>(a, 0), 65535)) / 65535.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_YUY2:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            const XMUBYTEN4 * __restrict sPtr = static_cast<const XMUBYTEN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                const int y0 = int(sPtr->x) - 16;
-                const int u = int(sPtr->y) - 128;
-                const int y1 = int(sPtr->z) - 16;
-                const int v = int(sPtr->w) - 128;
-                ++sPtr;
-
-                // See AYUV
-                int r = (298 * y0 + 409 * v + 128) >> 8;
-                int g = (298 * y0 - 100 * u - 208 * v + 128) >> 8;
-                int b = (298 * y0 + 516 * u + 128) >> 8;
-
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(float(std::min<int>(std::max<int>(r, 0), 255)) / 255.f,
-                    float(std::min<int>(std::max<int>(g, 0), 255)) / 255.f,
-                    float(std::min<int>(std::max<int>(b, 0), 255)) / 255.f,
-                    1.f);
-
-                r = (298 * y1 + 409 * v + 128) >> 8;
-                g = (298 * y1 - 100 * u - 208 * v + 128) >> 8;
-                b = (298 * y1 + 516 * u + 128) >> 8;
-
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(float(std::min<int>(std::max<int>(r, 0), 255)) / 255.f,
-                    float(std::min<int>(std::max<int>(g, 0), 255)) / 255.f,
-                    float(std::min<int>(std::max<int>(b, 0), 255)) / 255.f,
-                    1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_Y210:
-        // Same as Y216 with least significant 6 bits set to zero
-        if (size >= sizeof(XMUSHORTN4))
-        {
-            const XMUSHORTN4 * __restrict sPtr = static_cast<const XMUSHORTN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUSHORTN4) + 1); icount += sizeof(XMUSHORTN4))
-            {
-                const int64_t y0 = int64_t(sPtr->x >> 6) - 64;
-                const int64_t u = int64_t(sPtr->y >> 6) - 512;
-                const int64_t y1 = int64_t(sPtr->z >> 6) - 64;
-                const int64_t v = int64_t(sPtr->w >> 6) - 512;
-                ++sPtr;
-
-                // See Y410
-                auto r = static_cast<int>((76533 * y0 + 104905 * v + 32768) >> 16);
-                auto g = static_cast<int>((76533 * y0 - 25747 * u - 53425 * v + 32768) >> 16);
-                auto b = static_cast<int>((76533 * y0 + 132590 * u + 32768) >> 16);
-
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(float(std::min<int>(std::max<int>(r, 0), 1023)) / 1023.f,
-                    float(std::min<int>(std::max<int>(g, 0), 1023)) / 1023.f,
-                    float(std::min<int>(std::max<int>(b, 0), 1023)) / 1023.f,
-                    1.f);
-
-                r = static_cast<int>((76533 * y1 + 104905 * v + 32768) >> 16);
-                g = static_cast<int>((76533 * y1 - 25747 * u - 53425 * v + 32768) >> 16);
-                b = static_cast<int>((76533 * y1 + 132590 * u + 32768) >> 16);
-
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(float(std::min<int>(std::max<int>(r, 0), 1023)) / 1023.f,
-                    float(std::min<int>(std::max<int>(g, 0), 1023)) / 1023.f,
-                    float(std::min<int>(std::max<int>(b, 0), 1023)) / 1023.f,
-                    1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_Y216:
-        if (size >= sizeof(XMUSHORTN4))
-        {
-            const XMUSHORTN4 * __restrict sPtr = static_cast<const XMUSHORTN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUSHORTN4) + 1); icount += sizeof(XMUSHORTN4))
-            {
-                const int64_t y0 = int64_t(sPtr->x) - 4096;
-                const int64_t u = int64_t(sPtr->y) - 32768;
-                const int64_t y1 = int64_t(sPtr->z) - 4096;
-                const int64_t v = int64_t(sPtr->w) - 32768;
-                ++sPtr;
-
-                // See Y416
-                auto r = static_cast<int>((76607 * y0 + 105006 * v + 32768) >> 16);
-                auto g = static_cast<int>((76607 * y0 - 25772 * u - 53477 * v + 32768) >> 16);
-                auto b = static_cast<int>((76607 * y0 + 132718 * u + 32768) >> 16);
-
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(float(std::min<int>(std::max<int>(r, 0), 65535)) / 65535.f,
-                    float(std::min<int>(std::max<int>(g, 0), 65535)) / 65535.f,
-                    float(std::min<int>(std::max<int>(b, 0), 65535)) / 65535.f,
-                    1.f);
-
-                r = static_cast<int>((76607 * y1 + 105006 * v + 32768) >> 16);
-                g = static_cast<int>((76607 * y1 - 25772 * u - 53477 * v + 32768) >> 16);
-                b = static_cast<int>((76607 * y1 + 132718 * u + 32768) >> 16);
-
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSet(float(std::min<int>(std::max<int>(r, 0), 65535)) / 65535.f,
-                    float(std::min<int>(std::max<int>(g, 0), 65535)) / 65535.f,
-                    float(std::min<int>(std::max<int>(b, 0), 65535)) / 65535.f,
-                    1.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-        if (size >= sizeof(XMUNIBBLE4))
-        {
-            static const XMVECTORF32 s_Scale = { { { 1.f / 15.f, 1.f / 15.f, 1.f / 15.f, 1.f / 15.f } } };
-            const XMUNIBBLE4 * __restrict sPtr = static_cast<const XMUNIBBLE4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUNIBBLE4) + 1); icount += sizeof(XMUNIBBLE4))
-            {
-                XMVECTOR v = XMLoadUNibble4(sPtr++);
-                v = XMVectorMultiply(v, s_Scale);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSwizzle<2, 1, 0, 3>(v);
-            }
-            return true;
-        }
-        return false;
-
-    case XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT:
-        // Xbox One specific 7e3 format
-        if (size >= sizeof(XMUDECN4))
-        {
-            const XMUDECN4 * __restrict sPtr = static_cast<const XMUDECN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUDECN4) + 1); icount += sizeof(XMUDECN4))
-            {
-                if (dPtr >= ePtr) break;
-
-                XMVECTORF32 vResult = { { {
-                    FloatFrom7e3(sPtr->x),
-                    FloatFrom7e3(sPtr->y),
-                    FloatFrom7e3(sPtr->z),
-                    static_cast<float>(sPtr->v >> 30) / 3.0f
-                } } };
-
-                ++sPtr;
-
-                *(dPtr++) = vResult.v;
-            }
-            return true;
-        }
-        return false;
-
-    case XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT:
-        // Xbox One specific 6e4 format
-        if (size >= sizeof(XMUDECN4))
-        {
-            const XMUDECN4 * __restrict sPtr = static_cast<const XMUDECN4*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(XMUDECN4) + 1); icount += sizeof(XMUDECN4))
-            {
-                if (dPtr >= ePtr) break;
-
-                XMVECTORF32 vResult = { { {
-                    FloatFrom6e4(sPtr->x),
-                    FloatFrom6e4(sPtr->y),
-                    FloatFrom6e4(sPtr->z),
-                    static_cast<float>(sPtr->v >> 30) / 3.0f
-                } } };
-
-                ++sPtr;
-
-                *(dPtr++) = vResult.v;
-            }
-            return true;
-        }
-        return false;
-
-    case XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM:
-        // Xbox One specific format
-        LOAD_SCANLINE(XMXDECN4, XMLoadXDecN4)
-
-    case XBOX_DXGI_FORMAT_R4G4_UNORM:
-        // Xbox One specific format
-        if (size >= sizeof(uint8_t))
-        {
-            static const XMVECTORF32 s_Scale = { { { 1.f / 15.f, 1.f / 15.f, 0.f, 0.f } } };
-            const uint8_t * __restrict sPtr = static_cast<const uint8_t*>(pSource);
-            for (size_t icount = 0; icount < (size - sizeof(uint8_t) + 1); icount += sizeof(uint8_t))
-            {
-                XMUNIBBLE4 nibble;
-                nibble.v = static_cast<uint16_t>(*sPtr++);
-                XMVECTOR v = XMLoadUNibble4(&nibble);
-                v = XMVectorMultiply(v, s_Scale);
-                if (dPtr >= ePtr) break;
-                *(dPtr++) = XMVectorSelect(g_XMIdentityR3, v, g_XMSelect1100);
-            }
-            return true;
-        }
-        return false;
-
-        // We don't support the planar or palettized formats
-
-    default:
-        return false;
-    }
-}
-
-#undef LOAD_SCANLINE
-#undef LOAD_SCANLINE3
-#undef LOAD_SCANLINE2
-
-
-//-------------------------------------------------------------------------------------
-// Stores an image row from standard RGBA XMVECTOR (aligned) array
-//-------------------------------------------------------------------------------------
-#define STORE_SCANLINE( type, func )\
-        if (size >= sizeof(type))\
-        {\
-            type * __restrict dPtr = reinterpret_cast<type*>(pDestination);\
-            for(size_t icount = 0; icount < (size - sizeof(type) + 1); icount += sizeof(type))\
-            {\
-                if (sPtr >= ePtr) break;\
-                func(dPtr++, *sPtr++);\
-            }\
-            return true; \
-        }\
-        return false;
-
-_Use_decl_annotations_
-bool DirectX::Internal::StoreScanline(
-    void* pDestination,
-    size_t size,
-    DXGI_FORMAT format,
-    const XMVECTOR* pSource,
-    size_t count,
-    float threshold) noexcept
-{
-    assert(pDestination != nullptr);
-    assert(IsValid(format) && !IsTypeless(format) && !IsCompressed(format) && !IsPlanar(format) && !IsPalettized(format));
-
-    if (!size || !count)
-        return false;
-
-    const XMVECTOR* __restrict sPtr = pSource;
-    if (!sPtr)
-        return false;
-
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-
-    const XMVECTOR* ePtr = sPtr + count;
-
-#ifdef _PREFAST_
-    *reinterpret_cast<uint8_t*>(pDestination) = 0;
-#endif
-
-    switch (static_cast<int>(format))
-    {
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-        STORE_SCANLINE(XMFLOAT4, XMStoreFloat4)
-
-    case DXGI_FORMAT_R32G32B32A32_UINT:
-        STORE_SCANLINE(XMUINT4, XMStoreUInt4)
-
-    case DXGI_FORMAT_R32G32B32A32_SINT:
-        STORE_SCANLINE(XMINT4, XMStoreSInt4)
-
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-        STORE_SCANLINE(XMFLOAT3, XMStoreFloat3)
-
-    case DXGI_FORMAT_R32G32B32_UINT:
-        STORE_SCANLINE(XMUINT3, XMStoreUInt3)
-
-    case DXGI_FORMAT_R32G32B32_SINT:
-        STORE_SCANLINE(XMINT3, XMStoreSInt3)
-
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-        if (size >= sizeof(XMHALF4))
-        {
-            XMHALF4* __restrict dPtr = static_cast<XMHALF4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMHALF4) + 1); icount += sizeof(XMHALF4))
-            {
-                if (sPtr >= ePtr) break;
-                XMVECTOR v = *sPtr++;
-                v = XMVectorClamp(v, g_HalfMin, g_HalfMax);
-                XMStoreHalf4(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R16G16B16A16_UNORM:
-        STORE_SCANLINE(XMUSHORTN4, XMStoreUShortN4)
-
-    case DXGI_FORMAT_R16G16B16A16_UINT:
-        STORE_SCANLINE(XMUSHORT4, XMStoreUShort4)
-
-    case DXGI_FORMAT_R16G16B16A16_SNORM:
-        STORE_SCANLINE(XMSHORTN4, XMStoreShortN4)
-
-    case DXGI_FORMAT_R16G16B16A16_SINT:
-        STORE_SCANLINE(XMSHORT4, XMStoreShort4)
-
-    case DXGI_FORMAT_R32G32_FLOAT:
-        STORE_SCANLINE(XMFLOAT2, XMStoreFloat2)
-
-    case DXGI_FORMAT_R32G32_UINT:
-        STORE_SCANLINE(XMUINT2, XMStoreUInt2)
-
-    case DXGI_FORMAT_R32G32_SINT:
-        STORE_SCANLINE(XMINT2, XMStoreSInt2)
-
-    case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
-            {
-                constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
-                if (size >= psize)
-                {
-                    auto dPtr = static_cast<float*>(pDestination);
-                    for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
-                    {
-                        if (sPtr >= ePtr) break;
-                        XMFLOAT4 f;
-                        XMStoreFloat4(&f, *sPtr++);
-                        dPtr[0] = f.x;
-                        auto ps8 = reinterpret_cast<uint8_t*>(&dPtr[1]);
-                        ps8[0] = static_cast<uint8_t>(std::min<float>(255.f, std::max<float>(0.f, f.y)));
-                        ps8[1] = ps8[2] = ps8[3] = 0;
-                        dPtr += 2;
-                    }
-                    return true;
-                }
-            }
-            return false;
-
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-        STORE_SCANLINE(XMUDECN4, XMStoreUDecN4)
-
-    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-        STORE_SCANLINE(XMUDECN4, XMStoreUDecN4_XR)
-
-    case DXGI_FORMAT_R10G10B10A2_UINT:
-        STORE_SCANLINE(XMUDEC4, XMStoreUDec4)
-
-    case DXGI_FORMAT_R11G11B10_FLOAT:
-        STORE_SCANLINE(XMFLOAT3PK, XMStoreFloat3PK)
-
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            XMUBYTEN4 * __restrict dPtr = static_cast<XMUBYTEN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                if (sPtr >= ePtr) break;
-                const XMVECTOR v = XMVectorAdd(*sPtr++, g_8BitBias);
-                XMStoreUByteN4(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8G8B8A8_UINT:
-        STORE_SCANLINE(XMUBYTE4, XMStoreUByte4)
-
-    case DXGI_FORMAT_R8G8B8A8_SNORM:
-        STORE_SCANLINE(XMBYTEN4, XMStoreByteN4)
-
-    case DXGI_FORMAT_R8G8B8A8_SINT:
-        STORE_SCANLINE(XMBYTE4, XMStoreByte4)
-
-    case DXGI_FORMAT_R16G16_FLOAT:
-        if (size >= sizeof(XMHALF2))
-        {
-            XMHALF2* __restrict dPtr = static_cast<XMHALF2*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMHALF2) + 1); icount += sizeof(XMHALF2))
-            {
-                if (sPtr >= ePtr) break;
-                XMVECTOR v = *sPtr++;
-                v = XMVectorClamp(v, g_HalfMin, g_HalfMax);
-                XMStoreHalf2(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R16G16_UNORM:
-        STORE_SCANLINE(XMUSHORTN2, XMStoreUShortN2)
-
-    case DXGI_FORMAT_R16G16_UINT:
-        STORE_SCANLINE(XMUSHORT2, XMStoreUShort2)
-
-    case DXGI_FORMAT_R16G16_SNORM:
-        STORE_SCANLINE(XMSHORTN2, XMStoreShortN2)
-
-    case DXGI_FORMAT_R16G16_SINT:
-        STORE_SCANLINE(XMSHORT2, XMStoreShort2)
-
-    case DXGI_FORMAT_D32_FLOAT:
-    case DXGI_FORMAT_R32_FLOAT:
-        if (size >= sizeof(float))
-        {
-            float * __restrict dPtr = static_cast<float*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(float) + 1); icount += sizeof(float))
-            {
-                if (sPtr >= ePtr) break;
-                XMStoreFloat(dPtr++, *(sPtr++));
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R32_UINT:
-        if (size >= sizeof(uint32_t))
-        {
-            uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(uint32_t) + 1); icount += sizeof(uint32_t))
-            {
-                if (sPtr >= ePtr) break;
-                const XMVECTOR v = XMConvertVectorFloatToUInt(*(sPtr++), 0);
-                XMStoreInt(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R32_SINT:
-        if (size >= sizeof(int32_t))
-        {
-            uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(int32_t) + 1); icount += sizeof(int32_t))
-            {
-                if (sPtr >= ePtr) break;
-                const XMVECTOR v = XMConvertVectorFloatToInt(*(sPtr++), 0);
-                XMStoreInt(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_D24_UNORM_S8_UINT:
-        if (size >= sizeof(uint32_t))
-        {
-            static const XMVECTORF32 clamp = { { { 1.f, 255.f, 0.f, 0.f } } };
-            const XMVECTOR zero = XMVectorZero();
-            auto dPtr = static_cast<uint32_t*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(uint32_t) + 1); icount += sizeof(uint32_t))
-            {
-                if (sPtr >= ePtr) break;
-                XMFLOAT4 f;
-                XMStoreFloat4(&f, XMVectorClamp(*sPtr++, zero, clamp));
-                *dPtr++ = (static_cast<uint32_t>(f.x * 16777215.f) & 0xFFFFFF)
-                    | ((static_cast<uint32_t>(f.y) & 0xFF) << 24);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8G8_UNORM:
-        STORE_SCANLINE(XMUBYTEN2, XMStoreUByteN2)
-
-    case DXGI_FORMAT_R8G8_UINT:
-        STORE_SCANLINE(XMUBYTE2, XMStoreUByte2)
-
-    case DXGI_FORMAT_R8G8_SNORM:
-        STORE_SCANLINE(XMBYTEN2, XMStoreByteN2)
-
-    case DXGI_FORMAT_R8G8_SINT:
-        STORE_SCANLINE(XMBYTE2, XMStoreByte2)
-
-    case DXGI_FORMAT_R16_FLOAT:
-        if (size >= sizeof(HALF))
-        {
-            HALF * __restrict dPtr = static_cast<HALF*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(HALF) + 1); icount += sizeof(HALF))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetX(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 65504.f), -65504.f);
-                *(dPtr++) = XMConvertFloatToHalf(v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_D16_UNORM:
-    case DXGI_FORMAT_R16_UNORM:
-        if (size >= sizeof(uint16_t))
-        {
-            uint16_t * __restrict dPtr = static_cast<uint16_t*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(uint16_t) + 1); icount += sizeof(uint16_t))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetX(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 1.f), 0.f);
-                *(dPtr++) = static_cast<uint16_t>(v*65535.f + 0.5f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R16_UINT:
-        if (size >= sizeof(uint16_t))
-        {
-            uint16_t * __restrict dPtr = static_cast<uint16_t*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(uint16_t) + 1); icount += sizeof(uint16_t))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetX(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 65535.f), 0.f);
-                *(dPtr++) = static_cast<uint16_t>(v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R16_SNORM:
-        if (size >= sizeof(int16_t))
-        {
-            int16_t * __restrict dPtr = static_cast<int16_t*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(int16_t) + 1); icount += sizeof(int16_t))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetX(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 1.f), -1.f);
-                *(dPtr++) = static_cast<int16_t>(lroundf(v * 32767.f));
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R16_SINT:
-        if (size >= sizeof(int16_t))
-        {
-            int16_t * __restrict dPtr = static_cast<int16_t*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(int16_t) + 1); icount += sizeof(int16_t))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetX(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 32767.f), -32767.f);
-                *(dPtr++) = static_cast<int16_t>(v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8_UNORM:
-        if (size >= sizeof(uint8_t))
-        {
-            uint8_t * __restrict dPtr = static_cast<uint8_t*>(pDestination);
-            for (size_t icount = 0; icount < size; icount += sizeof(uint8_t))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetX(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 1.f), 0.f);
-                *(dPtr++) = static_cast<uint8_t>(v * 255.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8_UINT:
-        if (size >= sizeof(uint8_t))
-        {
-            uint8_t * __restrict dPtr = static_cast<uint8_t*>(pDestination);
-            for (size_t icount = 0; icount < size; icount += sizeof(uint8_t))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetX(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 255.f), 0.f);
-                *(dPtr++) = static_cast<uint8_t>(v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8_SNORM:
-        if (size >= sizeof(int8_t))
-        {
-            int8_t * __restrict dPtr = static_cast<int8_t*>(pDestination);
-            for (size_t icount = 0; icount < size; icount += sizeof(int8_t))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetX(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 1.f), -1.f);
-                *(dPtr++) = static_cast<int8_t>(lroundf(v * 127.f));
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8_SINT:
-        if (size >= sizeof(int8_t))
-        {
-            int8_t * __restrict dPtr = static_cast<int8_t*>(pDestination);
-            for (size_t icount = 0; icount < size; icount += sizeof(int8_t))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetX(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 127.f), -127.f);
-                *(dPtr++) = static_cast<int8_t>(v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_A8_UNORM:
-        if (size >= sizeof(uint8_t))
-        {
-            uint8_t * __restrict dPtr = static_cast<uint8_t*>(pDestination);
-            for (size_t icount = 0; icount < size; icount += sizeof(uint8_t))
-            {
-                if (sPtr >= ePtr) break;
-                float v = XMVectorGetW(*sPtr++);
-                v = std::max<float>(std::min<float>(v, 1.f), 0.f);
-                *(dPtr++) = static_cast<uint8_t>(v * 255.f);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R1_UNORM:
-        if (size >= sizeof(uint8_t))
-        {
-            uint8_t * __restrict dPtr = static_cast<uint8_t*>(pDestination);
-            for (size_t icount = 0; icount < size; icount += sizeof(uint8_t))
-            {
-                uint8_t pixels = 0;
-                for (size_t bcount = 8; bcount > 0; --bcount)
-                {
-                    if (sPtr >= ePtr) break;
-                    const float v = XMVectorGetX(*sPtr++);
-
-                    // Absolute thresholding generally doesn't give good results for all images
-                    // Picking the 'right' threshold automatically requires whole-image analysis
-
-                    if (v > 0.25f)
-                        pixels |= 1 << (bcount - 1);
-                }
-                *(dPtr++) = pixels;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
-        STORE_SCANLINE(XMFLOAT3SE, StoreFloat3SE)
-
-    case DXGI_FORMAT_R8G8_B8G8_UNORM:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            XMUBYTEN4 * __restrict dPtr = static_cast<XMUBYTEN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                if (sPtr >= ePtr) break;
-                const XMVECTOR v0 = *sPtr++;
-                const XMVECTOR v1 = (sPtr < ePtr) ? XMVectorSplatY(*sPtr++) : XMVectorZero();
-                XMVECTOR v = XMVectorSelect(v1, v0, g_XMSelect1110);
-                v = XMVectorAdd(v, g_8BitBias);
-                XMStoreUByteN4(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_G8R8_G8B8_UNORM:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            static XMVECTORU32 select1101 = { { { XM_SELECT_1, XM_SELECT_1, XM_SELECT_0, XM_SELECT_1 } } };
-
-            XMUBYTEN4 * __restrict dPtr = static_cast<XMUBYTEN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                if (sPtr >= ePtr) break;
-                const XMVECTOR v0 = XMVectorSwizzle<1, 0, 3, 2>(*sPtr++);
-                const XMVECTOR v1 = (sPtr < ePtr) ? XMVectorSplatY(*sPtr++) : XMVectorZero();
-                XMVECTOR v = XMVectorSelect(v1, v0, select1101);
-                v = XMVectorAdd(v, g_8BitBias);
-                XMStoreUByteN4(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B5G6R5_UNORM:
-        if (size >= sizeof(XMU565))
-        {
-            static const XMVECTORF32 s_Scale = { { { 31.f, 63.f, 31.f, 1.f } } };
-            XMU565 * __restrict dPtr = static_cast<XMU565*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMU565) + 1); icount += sizeof(XMU565))
-            {
-                if (sPtr >= ePtr) break;
-                XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(*sPtr++);
-                v = XMVectorMultiply(v, s_Scale);
-                XMStoreU565(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-        if (size >= sizeof(XMU555))
-        {
-            static const XMVECTORF32 s_Scale = { { { 31.f, 31.f, 31.f, 1.f } } };
-            XMU555 * __restrict dPtr = static_cast<XMU555*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMU555) + 1); icount += sizeof(XMU555))
-            {
-                if (sPtr >= ePtr) break;
-                XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(*sPtr++);
-                v = XMVectorMultiply(v, s_Scale);
-                XMStoreU555(dPtr, v);
-                dPtr->w = (XMVectorGetW(v) > threshold) ? 1u : 0u;
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            XMUBYTEN4 * __restrict dPtr = static_cast<XMUBYTEN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                if (sPtr >= ePtr) break;
-                XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(*sPtr++);
-                v = XMVectorAdd(v, g_8BitBias);
-                XMStoreUByteN4(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            XMUBYTEN4 * __restrict dPtr = static_cast<XMUBYTEN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                if (sPtr >= ePtr) break;
-                XMVECTOR v = XMVectorPermute<2, 1, 0, 7>(*sPtr++, g_XMIdentityR3);
-                v = XMVectorAdd(v, g_8BitBias);
-                XMStoreUByteN4(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_AYUV:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            XMUBYTEN4 * __restrict dPtr = static_cast<XMUBYTEN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                if (sPtr >= ePtr) break;
-
-                XMUBYTEN4 rgba;
-                XMStoreUByteN4(&rgba, *sPtr++);
-
-                // http://msdn.microsoft.com/en-us/library/windows/desktop/dd206750.aspx
-
-                // Y  =  0.2568R + 0.5041G + 0.1001B + 16
-                // Cb = -0.1482R - 0.2910G + 0.4392B + 128
-                // Cr =  0.4392R - 0.3678G - 0.0714B + 128
-
-                const int y = ((66 * rgba.x + 129 * rgba.y + 25 * rgba.z + 128) >> 8) + 16;
-                const int u = ((-38 * rgba.x - 74 * rgba.y + 112 * rgba.z + 128) >> 8) + 128;
-                const int v = ((112 * rgba.x - 94 * rgba.y - 18 * rgba.z + 128) >> 8) + 128;
-
-                dPtr->x = static_cast<uint8_t>(std::min<int>(std::max<int>(v, 0), 255));
-                dPtr->y = static_cast<uint8_t>(std::min<int>(std::max<int>(u, 0), 255));
-                dPtr->z = static_cast<uint8_t>(std::min<int>(std::max<int>(y, 0), 255));
-                dPtr->w = rgba.w;
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_Y410:
-        if (size >= sizeof(XMUDECN4))
-        {
-            XMUDECN4 * __restrict dPtr = static_cast<XMUDECN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUDECN4) + 1); icount += sizeof(XMUDECN4))
-            {
-                if (sPtr >= ePtr) break;
-
-                XMUDECN4 rgba;
-                XMStoreUDecN4(&rgba, *sPtr++);
-
-                // http://msdn.microsoft.com/en-us/library/windows/desktop/bb970578.aspx
-
-                // Y  =  0.2560R + 0.5027G + 0.0998B + 64
-                // Cb = -0.1478R - 0.2902G + 0.4379B + 512
-                // Cr =  0.4379R - 0.3667G - 0.0712B + 512
-
-                const int64_t r = rgba.x;
-                const int64_t g = rgba.y;
-                const int64_t b = rgba.z;
-
-                const int y = static_cast<int>((16780 * r + 32942 * g + 6544 * b + 32768) >> 16) + 64;
-                const int u = static_cast<int>((-9683 * r - 19017 * g + 28700 * b + 32768) >> 16) + 512;
-                const int v = static_cast<int>((28700 * r - 24033 * g - 4667 * b + 32768) >> 16) + 512;
-
-                dPtr->x = static_cast<uint32_t>(std::min<int>(std::max<int>(u, 0), 1023));
-                dPtr->y = static_cast<uint32_t>(std::min<int>(std::max<int>(y, 0), 1023));
-                dPtr->z = static_cast<uint32_t>(std::min<int>(std::max<int>(v, 0), 1023));
-                dPtr->w = rgba.w;
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_Y416:
-        if (size >= sizeof(XMUSHORTN4))
-        {
-            XMUSHORTN4 * __restrict dPtr = static_cast<XMUSHORTN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUSHORTN4) + 1); icount += sizeof(XMUSHORTN4))
-            {
-                if (sPtr >= ePtr) break;
-
-                XMUSHORTN4 rgba;
-                XMStoreUShortN4(&rgba, *sPtr++);
-
-                // http://msdn.microsoft.com/en-us/library/windows/desktop/bb970578.aspx
-
-                // Y  =  0.2558R + 0.5022G + 0.0998B + 4096
-                // Cb = -0.1476R - 0.2899G + 0.4375B + 32768
-                // Cr =  0.4375R - 0.3664G - 0.0711B + 32768
-
-                const int64_t r = int64_t(rgba.x);
-                const int64_t g = int64_t(rgba.y);
-                const int64_t b = int64_t(rgba.z);
-
-                const int y = static_cast<int>((16763 * r + 32910 * g + 6537 * b + 32768) >> 16) + 4096;
-                const int u = static_cast<int>((-9674 * r - 18998 * g + 28672 * b + 32768) >> 16) + 32768;
-                const int v = static_cast<int>((28672 * r - 24010 * g - 4662 * b + 32768) >> 16) + 32768;
-
-                dPtr->x = static_cast<uint16_t>(std::min<int>(std::max<int>(u, 0), 65535));
-                dPtr->y = static_cast<uint16_t>(std::min<int>(std::max<int>(y, 0), 65535));
-                dPtr->z = static_cast<uint16_t>(std::min<int>(std::max<int>(v, 0), 65535));
-                dPtr->w = rgba.w;
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_YUY2:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            XMUBYTEN4 * __restrict dPtr = static_cast<XMUBYTEN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUBYTEN4) + 1); icount += sizeof(XMUBYTEN4))
-            {
-                if (sPtr >= ePtr) break;
-
-                XMUBYTEN4 rgb1;
-                XMStoreUByteN4(&rgb1, *sPtr++);
-
-                // See AYUV
-                const int y0 = ((66 * rgb1.x + 129 * rgb1.y + 25 * rgb1.z + 128) >> 8) + 16;
-                const int u0 = ((-38 * rgb1.x - 74 * rgb1.y + 112 * rgb1.z + 128) >> 8) + 128;
-                const int v0 = ((112 * rgb1.x - 94 * rgb1.y - 18 * rgb1.z + 128) >> 8) + 128;
-
-                XMUBYTEN4 rgb2 = {};
-                if (sPtr < ePtr)
-                {
-                    XMStoreUByteN4(&rgb2, *sPtr++);
-                }
-
-                const int y1 = ((66 * rgb2.x + 129 * rgb2.y + 25 * rgb2.z + 128) >> 8) + 16;
-                const int u1 = ((-38 * rgb2.x - 74 * rgb2.y + 112 * rgb2.z + 128) >> 8) + 128;
-                const int v1 = ((112 * rgb2.x - 94 * rgb2.y - 18 * rgb2.z + 128) >> 8) + 128;
-
-                dPtr->x = static_cast<uint8_t>(std::min<int>(std::max<int>(y0, 0), 255));
-                dPtr->y = static_cast<uint8_t>(std::min<int>(std::max<int>((u0 + u1) >> 1, 0), 255));
-                dPtr->z = static_cast<uint8_t>(std::min<int>(std::max<int>(y1, 0), 255));
-                dPtr->w = static_cast<uint8_t>(std::min<int>(std::max<int>((v0 + v1) >> 1, 0), 255));
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_Y210:
-        // Same as Y216 with least significant 6 bits set to zero
-        if (size >= sizeof(XMUSHORTN4))
-        {
-            XMUSHORTN4 * __restrict dPtr = static_cast<XMUSHORTN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUSHORTN4) + 1); icount += sizeof(XMUSHORTN4))
-            {
-                if (sPtr >= ePtr) break;
-
-                XMUDECN4 rgb1;
-                XMStoreUDecN4(&rgb1, *sPtr++);
-
-                // See Y410
-                int64_t r = rgb1.x;
-                int64_t g = rgb1.y;
-                int64_t b = rgb1.z;
-
-                const int y0 = static_cast<int>((16780 * r + 32942 * g + 6544 * b + 32768) >> 16) + 64;
-                const int u0 = static_cast<int>((-9683 * r - 19017 * g + 28700 * b + 32768) >> 16) + 512;
-                const int v0 = static_cast<int>((28700 * r - 24033 * g - 4667 * b + 32768) >> 16) + 512;
-
-                XMUDECN4 rgb2 = {};
-                if (sPtr < ePtr)
-                {
-                    XMStoreUDecN4(&rgb2, *sPtr++);
-                }
-
-                r = rgb2.x;
-                g = rgb2.y;
-                b = rgb2.z;
-
-                const int y1 = static_cast<int>((16780 * r + 32942 * g + 6544 * b + 32768) >> 16) + 64;
-                const int u1 = static_cast<int>((-9683 * r - 19017 * g + 28700 * b + 32768) >> 16) + 512;
-                const int v1 = static_cast<int>((28700 * r - 24033 * g - 4667 * b + 32768) >> 16) + 512;
-
-                dPtr->x = static_cast<uint16_t>(std::min<int>(std::max<int>(y0, 0), 1023) << 6);
-                dPtr->y = static_cast<uint16_t>(std::min<int>(std::max<int>((u0 + u1) >> 1, 0), 1023) << 6);
-                dPtr->z = static_cast<uint16_t>(std::min<int>(std::max<int>(y1, 0), 1023) << 6);
-                dPtr->w = static_cast<uint16_t>(std::min<int>(std::max<int>((v0 + v1) >> 1, 0), 1023) << 6);
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_Y216:
-        if (size >= sizeof(XMUSHORTN4))
-        {
-            XMUSHORTN4 * __restrict dPtr = static_cast<XMUSHORTN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUSHORTN4) + 1); icount += sizeof(XMUSHORTN4))
-            {
-                if (sPtr >= ePtr) break;
-
-                XMUSHORTN4 rgb1;
-                XMStoreUShortN4(&rgb1, *sPtr++);
-
-                // See Y416
-                int64_t r = int64_t(rgb1.x);
-                int64_t g = int64_t(rgb1.y);
-                int64_t b = int64_t(rgb1.z);
-
-                const int y0 = static_cast<int>((16763 * r + 32910 * g + 6537 * b + 32768) >> 16) + 4096;
-                const int u0 = static_cast<int>((-9674 * r - 18998 * g + 28672 * b + 32768) >> 16) + 32768;
-                const int v0 = static_cast<int>((28672 * r - 24010 * g - 4662 * b + 32768) >> 16) + 32768;
-
-                XMUSHORTN4 rgb2 = {};
-                if (sPtr < ePtr)
-                {
-                    XMStoreUShortN4(&rgb2, *sPtr++);
-                }
-
-                r = int64_t(rgb2.x);
-                g = int64_t(rgb2.y);
-                b = int64_t(rgb2.z);
-
-                const int y1 = static_cast<int>((16763 * r + 32910 * g + 6537 * b + 32768) >> 16) + 4096;
-                const int u1 = static_cast<int>((-9674 * r - 18998 * g + 28672 * b + 32768) >> 16) + 32768;
-                const int v1 = static_cast<int>((28672 * r - 24010 * g - 4662 * b + 32768) >> 16) + 32768;
-
-                dPtr->x = static_cast<uint16_t>(std::min<int>(std::max<int>(y0, 0), 65535));
-                dPtr->y = static_cast<uint16_t>(std::min<int>(std::max<int>((u0 + u1) >> 1, 0), 65535));
-                dPtr->z = static_cast<uint16_t>(std::min<int>(std::max<int>(y1, 0), 65535));
-                dPtr->w = static_cast<uint16_t>(std::min<int>(std::max<int>((v0 + v1) >> 1, 0), 65535));
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-        if (size >= sizeof(XMUNIBBLE4))
-        {
-            static const XMVECTORF32 s_Scale = { { { 15.f, 15.f, 15.f, 15.f } } };
-            XMUNIBBLE4 * __restrict dPtr = static_cast<XMUNIBBLE4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUNIBBLE4) + 1); icount += sizeof(XMUNIBBLE4))
-            {
-                if (sPtr >= ePtr) break;
-                XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(*sPtr++);
-                v = XMVectorMultiply(v, s_Scale);
-                XMStoreUNibble4(dPtr++, v);
-            }
-            return true;
-        }
-        return false;
-
-    case XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT:
-        // Xbox One specific 7e3 format with alpha
-        if (size >= sizeof(XMUDECN4))
-        {
-            static const XMVECTORF32  Scale = { { { 1.0f, 1.0f, 1.0f, 3.0f } } };
-            static const XMVECTORF32  C = { { { 31.875f, 31.875f, 31.875f, 3.f } } };
-
-            XMUDECN4 * __restrict dPtr = static_cast<XMUDECN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUDECN4) + 1); icount += sizeof(XMUDECN4))
-            {
-                if (sPtr >= ePtr) break;
-
-                XMVECTOR V = XMVectorMultiply(*sPtr++, Scale);
-                V = XMVectorClamp(V, g_XMZero, C);
-
-                XMFLOAT4A tmp;
-                XMStoreFloat4A(&tmp, V);
-
-                dPtr->x = FloatTo7e3(tmp.x);
-                dPtr->y = FloatTo7e3(tmp.y);
-                dPtr->z = FloatTo7e3(tmp.z);
-                dPtr->w = static_cast<uint32_t>(tmp.w);
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT:
-        // Xbox One specific 6e4 format with alpha
-        if (size >= sizeof(XMUDECN4))
-        {
-            static const XMVECTORF32  Scale = { { { 1.0f, 1.0f, 1.0f, 3.0f } } };
-            static const XMVECTORF32  C = { { { 508.f, 508.f, 508.f, 3.f } } };
-
-            XMUDECN4 * __restrict dPtr = static_cast<XMUDECN4*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(XMUDECN4) + 1); icount += sizeof(XMUDECN4))
-            {
-                if (sPtr >= ePtr) break;
-
-                XMVECTOR V = XMVectorMultiply(*sPtr++, Scale);
-                V = XMVectorClamp(V, g_XMZero, C);
-
-                XMFLOAT4A tmp;
-                XMStoreFloat4A(&tmp, V);
-
-                dPtr->x = FloatTo6e4(tmp.x);
-                dPtr->y = FloatTo6e4(tmp.y);
-                dPtr->z = FloatTo6e4(tmp.z);
-                dPtr->w = static_cast<uint32_t>(tmp.w);
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-    case XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM:
-        // Xbox One specific format
-        STORE_SCANLINE(XMXDECN4, XMStoreXDecN4)
-
-    case XBOX_DXGI_FORMAT_R4G4_UNORM:
-        // Xbox One specific format
-        if (size >= sizeof(uint8_t))
-        {
-            static const XMVECTORF32 s_Scale = { { { 15.f, 15.f, 0.f, 0.f } } };
-            uint8_t * __restrict dPtr = static_cast<uint8_t*>(pDestination);
-            for (size_t icount = 0; icount < (size - sizeof(uint8_t) + 1); icount += sizeof(uint8_t))
-            {
-                if (sPtr >= ePtr) break;
-                const XMVECTOR v = XMVectorMultiply(*sPtr++, s_Scale);
-
-                XMUNIBBLE4 nibble;
-                XMStoreUNibble4(&nibble, v);
-                *dPtr = static_cast<uint8_t>(nibble.v);
-                ++dPtr;
-            }
-            return true;
-        }
-        return false;
-
-        // We don't support the planar or palettized formats
-
-    default:
-        return false;
-    }
-}
-
-#undef STORE_SCANLINE
-
-
-//-------------------------------------------------------------------------------------
-// Convert DXGI image to/from GUID_WICPixelFormat128bppRGBAFloat (no range conversions)
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::Internal::ConvertToR32G32B32A32(const Image& srcImage, ScratchImage& image) noexcept
-{
-    if (!srcImage.pixels)
-        return E_POINTER;
-
-    HRESULT hr = image.Initialize2D(DXGI_FORMAT_R32G32B32A32_FLOAT, srcImage.width, srcImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *img = image.GetImage(0, 0, 0);
-    if (!img)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    uint8_t* pDest = img->pixels;
-    if (!pDest)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    const uint8_t *pSrc = srcImage.pixels;
-    for (size_t h = 0; h < srcImage.height; ++h)
-    {
-        if (!LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
-        {
-            image.Release();
-            return E_FAIL;
-        }
-
-        pSrc += srcImage.rowPitch;
-        pDest += img->rowPitch;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::Internal::ConvertFromR32G32B32A32(const Image& srcImage, const Image& destImage) noexcept
-{
-    assert(srcImage.format == DXGI_FORMAT_R32G32B32A32_FLOAT);
-
-    if (!srcImage.pixels || !destImage.pixels)
-        return E_POINTER;
-
-    if (srcImage.width != destImage.width || srcImage.height != destImage.height)
-        return E_FAIL;
-
-    const uint8_t *pSrc = srcImage.pixels;
-    uint8_t* pDest = destImage.pixels;
-
-    for (size_t h = 0; h < srcImage.height; ++h)
-    {
-        if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, reinterpret_cast<const XMVECTOR*>(pSrc), srcImage.width))
-            return E_FAIL;
-
-        pSrc += srcImage.rowPitch;
-        pDest += destImage.rowPitch;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::Internal::ConvertFromR32G32B32A32(
-    const Image& srcImage,
-    DXGI_FORMAT format,
-    ScratchImage& image) noexcept
-{
-    if (!srcImage.pixels)
-        return E_POINTER;
-
-    HRESULT hr = image.Initialize2D(format, srcImage.width, srcImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *img = image.GetImage(0, 0, 0);
-    if (!img)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    hr = ConvertFromR32G32B32A32(srcImage, *img);
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::Internal::ConvertFromR32G32B32A32(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    DXGI_FORMAT format,
-    ScratchImage& result) noexcept
-{
-    if (!srcImages)
-        return E_POINTER;
-
-    result.Release();
-
-    assert(metadata.format == DXGI_FORMAT_R32G32B32A32_FLOAT);
-
-    TexMetadata mdata2 = metadata;
-    mdata2.format = format;
-    HRESULT hr = result.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != result.GetImageCount())
-    {
-        result.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = result.GetImages();
-    if (!dest)
-    {
-        result.Release();
-        return E_POINTER;
-    }
-
-    for (size_t index = 0; index < nimages; ++index)
-    {
-        const Image& src = srcImages[index];
-        const Image& dst = dest[index];
-
-        assert(src.format == DXGI_FORMAT_R32G32B32A32_FLOAT);
-        assert(dst.format == format);
-
-        if (src.width != dst.width || src.height != dst.height)
-        {
-            result.Release();
-            return E_FAIL;
-        }
-
-        const uint8_t* pSrc = src.pixels;
-        uint8_t* pDest = dst.pixels;
-        if (!pSrc || !pDest)
-        {
-            result.Release();
-            return E_POINTER;
-        }
-
-        for (size_t h = 0; h < src.height; ++h)
-        {
-            if (!StoreScanline(pDest, dst.rowPitch, format, reinterpret_cast<const XMVECTOR*>(pSrc), src.width))
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            pSrc += src.rowPitch;
-            pDest += dst.rowPitch;
-        }
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Convert DXGI image to/from GUID_WICPixelFormat64bppRGBAHalf (no range conversions)
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::Internal::ConvertToR16G16B16A16(const Image& srcImage, ScratchImage& image) noexcept
-{
-    if (!srcImage.pixels)
-        return E_POINTER;
-
-    HRESULT hr = image.Initialize2D(DXGI_FORMAT_R16G16B16A16_FLOAT, srcImage.width, srcImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
-    if (!scanline)
-    {
-        image.Release();
-        return E_OUTOFMEMORY;
-    }
-
-    const Image *img = image.GetImage(0, 0, 0);
-    if (!img)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    uint8_t* pDest = img->pixels;
-    if (!pDest)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    const uint8_t *pSrc = srcImage.pixels;
-    for (size_t h = 0; h < srcImage.height; ++h)
-    {
-        if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
-        {
-            image.Release();
-            return E_FAIL;
-        }
-
-        XMConvertFloatToHalfStream(
-            reinterpret_cast<HALF*>(pDest), sizeof(HALF),
-            reinterpret_cast<float*>(scanline.get()), sizeof(float),
-            srcImage.width * 4);
-
-        pSrc += srcImage.rowPitch;
-        pDest += img->rowPitch;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::Internal::ConvertFromR16G16B16A16(const Image& srcImage, const Image& destImage) noexcept
-{
-    assert(srcImage.format == DXGI_FORMAT_R16G16B16A16_FLOAT);
-
-    if (!srcImage.pixels || !destImage.pixels)
-        return E_POINTER;
-
-    if (srcImage.width != destImage.width || srcImage.height != destImage.height)
-        return E_FAIL;
-
-    auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
-    if (!scanline)
-        return E_OUTOFMEMORY;
-
-    const uint8_t *pSrc = srcImage.pixels;
-    uint8_t* pDest = destImage.pixels;
-
-    for (size_t h = 0; h < srcImage.height; ++h)
-    {
-        XMConvertHalfToFloatStream(
-            reinterpret_cast<float*>(scanline.get()), sizeof(float),
-            reinterpret_cast<const HALF*>(pSrc), sizeof(HALF),
-            srcImage.width * 4);
-
-        if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
-            return E_FAIL;
-
-        pSrc += srcImage.rowPitch;
-        pDest += destImage.rowPitch;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Convert from Linear RGB to sRGB
-//
-// if C_linear <= 0.0031308 -> C_srgb = 12.92 * C_linear
-// if C_linear >  0.0031308 -> C_srgb = ( 1 + a ) * pow( C_Linear, 1 / 2.4 ) - a
-//                             where a = 0.055
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::Internal::StoreScanlineLinear(
-    void* pDestination,
-    size_t size,
-    DXGI_FORMAT format,
-    XMVECTOR* pSource,
-    size_t count,
-    TEX_FILTER_FLAGS flags,
-    float threshold) noexcept
-{
-    if (!pSource || !count)
-        return false;
-
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-
-    switch (format)
-    {
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        flags |= TEX_FILTER_SRGB;
-        break;
-
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_UNORM:
-    case DXGI_FORMAT_R32G32_FLOAT:
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-    case DXGI_FORMAT_R11G11B10_FLOAT:
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R16G16_FLOAT:
-    case DXGI_FORMAT_R16G16_UNORM:
-    case DXGI_FORMAT_R32_FLOAT:
-    case DXGI_FORMAT_R8G8_UNORM:
-    case DXGI_FORMAT_R16_FLOAT:
-    case DXGI_FORMAT_R16_UNORM:
-    case DXGI_FORMAT_R8_UNORM:
-    case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
-    case DXGI_FORMAT_R8G8_B8G8_UNORM:
-    case DXGI_FORMAT_G8R8_G8B8_UNORM:
-    case DXGI_FORMAT_B5G6R5_UNORM:
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-        break;
-
-    default:
-        // can't treat A8, XR, Depth, SNORM, UINT, or SINT as sRGB
-        flags &= ~TEX_FILTER_SRGB;
-        break;
-    }
-
-    // sRGB output processing (Linear RGB -> sRGB)
-    if (flags & TEX_FILTER_SRGB_OUT)
-    {
-        // To avoid the need for another temporary scanline buffer, we allow this function to overwrite the source buffer in-place
-        // Given the intended usage in the filtering routines, this is not a problem.
-        XMVECTOR* ptr = pSource;
-        for (size_t i = 0; i < count; ++i, ++ptr)
-        {
-            *ptr = XMColorRGBToSRGB(*ptr);
-        }
-    }
-
-    return StoreScanline(pDestination, size, format, pSource, count, threshold);
-}
-
-
-//-------------------------------------------------------------------------------------
-// Convert from sRGB to Linear RGB
-//
-// if C_srgb <= 0.04045 -> C_linear = C_srgb / 12.92
-// if C_srgb >  0.04045 -> C_linear = pow( ( C_srgb + a ) / ( 1 + a ), 2.4 )
-//                         where a = 0.055
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::Internal::LoadScanlineLinear(
-    XMVECTOR* pDestination,
-    size_t count,
-    const void* pSource,
-    size_t size,
-    DXGI_FORMAT format,
-    TEX_FILTER_FLAGS flags) noexcept
-{
-    switch (format)
-    {
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        flags |= TEX_FILTER_SRGB;
-        break;
-
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_UNORM:
-    case DXGI_FORMAT_R32G32_FLOAT:
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-    case DXGI_FORMAT_R11G11B10_FLOAT:
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R16G16_FLOAT:
-    case DXGI_FORMAT_R16G16_UNORM:
-    case DXGI_FORMAT_R32_FLOAT:
-    case DXGI_FORMAT_R8G8_UNORM:
-    case DXGI_FORMAT_R16_FLOAT:
-    case DXGI_FORMAT_R16_UNORM:
-    case DXGI_FORMAT_R8_UNORM:
-    case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
-    case DXGI_FORMAT_R8G8_B8G8_UNORM:
-    case DXGI_FORMAT_G8R8_G8B8_UNORM:
-    case DXGI_FORMAT_B5G6R5_UNORM:
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-        break;
-
-    default:
-        // can't treat A8, XR, Depth, SNORM, UINT, or SINT as sRGB
-        flags &= ~TEX_FILTER_SRGB;
-        break;
-    }
-
-    if (LoadScanline(pDestination, count, pSource, size, format))
-    {
-        // sRGB input processing (sRGB -> Linear RGB)
-        if (flags & TEX_FILTER_SRGB_IN)
-        {
-            XMVECTOR* ptr = pDestination;
-            for (size_t i = 0; i < count; ++i, ++ptr)
-            {
-                *ptr = XMColorSRGBToRGB(*ptr);
-            }
-        }
-
-        return true;
-    }
-
-    return false;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Convert scanline based on source/target formats
-//-------------------------------------------------------------------------------------
-namespace
-{
-    struct ConvertData
-    {
-        DXGI_FORMAT format;
-        size_t      datasize;
-        uint32_t    flags;
-    };
-
-    const ConvertData g_ConvertTable[] =
-    {
-        { DXGI_FORMAT_R32G32B32A32_FLOAT,           32, CONVF_FLOAT | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R32G32B32A32_UINT,            32, CONVF_UINT | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R32G32B32A32_SINT,            32, CONVF_SINT | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R32G32B32_FLOAT,              32, CONVF_FLOAT | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_R32G32B32_UINT,               32, CONVF_UINT | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_R32G32B32_SINT,               32, CONVF_SINT | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_R16G16B16A16_FLOAT,           16, CONVF_FLOAT | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R16G16B16A16_UNORM,           16, CONVF_UNORM | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R16G16B16A16_UINT,            16, CONVF_UINT | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R16G16B16A16_SNORM,           16, CONVF_SNORM | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R16G16B16A16_SINT,            16, CONVF_SINT | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R32G32_FLOAT,                 32, CONVF_FLOAT | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_R32G32_UINT,                  32, CONVF_UINT | CONVF_R | CONVF_G  },
-        { DXGI_FORMAT_R32G32_SINT,                  32, CONVF_SINT | CONVF_R | CONVF_G  },
-        { DXGI_FORMAT_D32_FLOAT_S8X24_UINT,         32, CONVF_FLOAT | CONVF_DEPTH | CONVF_STENCIL },
-        { DXGI_FORMAT_R10G10B10A2_UNORM,            10, CONVF_UNORM | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R10G10B10A2_UINT,             10, CONVF_UINT | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R11G11B10_FLOAT,              10, CONVF_FLOAT | CONVF_POS_ONLY | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_R8G8B8A8_UNORM,                8, CONVF_UNORM | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,           8, CONVF_UNORM | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R8G8B8A8_UINT,                 8, CONVF_UINT | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R8G8B8A8_SNORM,                8, CONVF_SNORM | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R8G8B8A8_SINT,                 8, CONVF_SINT | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_R16G16_FLOAT,                 16, CONVF_FLOAT | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_R16G16_UNORM,                 16, CONVF_UNORM | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_R16G16_UINT,                  16, CONVF_UINT | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_R16G16_SNORM,                 16, CONVF_SNORM | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_R16G16_SINT,                  16, CONVF_SINT | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_D32_FLOAT,                    32, CONVF_FLOAT | CONVF_DEPTH },
-        { DXGI_FORMAT_R32_FLOAT,                    32, CONVF_FLOAT | CONVF_R },
-        { DXGI_FORMAT_R32_UINT,                     32, CONVF_UINT | CONVF_R },
-        { DXGI_FORMAT_R32_SINT,                     32, CONVF_SINT | CONVF_R },
-        { DXGI_FORMAT_D24_UNORM_S8_UINT,            32, CONVF_UNORM | CONVF_DEPTH | CONVF_STENCIL },
-        { DXGI_FORMAT_R8G8_UNORM,                    8, CONVF_UNORM | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_R8G8_UINT,                     8, CONVF_UINT | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_R8G8_SNORM,                    8, CONVF_SNORM | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_R8G8_SINT,                     8, CONVF_SINT | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_R16_FLOAT,                    16, CONVF_FLOAT | CONVF_R },
-        { DXGI_FORMAT_D16_UNORM,                    16, CONVF_UNORM | CONVF_DEPTH },
-        { DXGI_FORMAT_R16_UNORM,                    16, CONVF_UNORM | CONVF_R },
-        { DXGI_FORMAT_R16_UINT,                     16, CONVF_UINT | CONVF_R },
-        { DXGI_FORMAT_R16_SNORM,                    16, CONVF_SNORM | CONVF_R },
-        { DXGI_FORMAT_R16_SINT,                     16, CONVF_SINT | CONVF_R },
-        { DXGI_FORMAT_R8_UNORM,                      8, CONVF_UNORM | CONVF_R },
-        { DXGI_FORMAT_R8_UINT,                       8, CONVF_UINT | CONVF_R },
-        { DXGI_FORMAT_R8_SNORM,                      8, CONVF_SNORM | CONVF_R },
-        { DXGI_FORMAT_R8_SINT,                       8, CONVF_SINT | CONVF_R },
-        { DXGI_FORMAT_A8_UNORM,                      8, CONVF_UNORM | CONVF_A },
-        { DXGI_FORMAT_R1_UNORM,                      1, CONVF_UNORM | CONVF_R },
-        { DXGI_FORMAT_R9G9B9E5_SHAREDEXP,            9, CONVF_FLOAT | CONVF_SHAREDEXP | CONVF_POS_ONLY | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_R8G8_B8G8_UNORM,               8, CONVF_UNORM | CONVF_PACKED | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_G8R8_G8B8_UNORM,               8, CONVF_UNORM | CONVF_PACKED | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_BC1_UNORM,                     8, CONVF_UNORM | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_BC1_UNORM_SRGB,                8, CONVF_UNORM | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_BC2_UNORM,                     8, CONVF_UNORM | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_BC2_UNORM_SRGB,                8, CONVF_UNORM | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_BC3_UNORM,                     8, CONVF_UNORM | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_BC3_UNORM_SRGB,                8, CONVF_UNORM | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_BC4_UNORM,                     8, CONVF_UNORM | CONVF_BC | CONVF_R },
-        { DXGI_FORMAT_BC4_SNORM,                     8, CONVF_SNORM | CONVF_BC | CONVF_R },
-        { DXGI_FORMAT_BC5_UNORM,                     8, CONVF_UNORM | CONVF_BC | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_BC5_SNORM,                     8, CONVF_SNORM | CONVF_BC | CONVF_R | CONVF_G },
-        { DXGI_FORMAT_B5G6R5_UNORM,                  5, CONVF_UNORM | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_B5G5R5A1_UNORM,                5, CONVF_UNORM | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_B8G8R8A8_UNORM,                8, CONVF_UNORM | CONVF_BGR | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_B8G8R8X8_UNORM,                8, CONVF_UNORM | CONVF_BGR | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM,   10, CONVF_UNORM | CONVF_XR | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_B8G8R8A8_UNORM_SRGB,           8, CONVF_UNORM | CONVF_BGR | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_B8G8R8X8_UNORM_SRGB,           8, CONVF_UNORM | CONVF_BGR | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_BC6H_UF16,                    16, CONVF_FLOAT | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_BC6H_SF16,                    16, CONVF_FLOAT | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_BC7_UNORM,                     8, CONVF_UNORM | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_BC7_UNORM_SRGB,                8, CONVF_UNORM | CONVF_BC | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_AYUV,                          8, CONVF_UNORM | CONVF_YUV | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_Y410,                         10, CONVF_UNORM | CONVF_YUV | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_Y416,                         16, CONVF_UNORM | CONVF_YUV | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { DXGI_FORMAT_YUY2,                          8, CONVF_UNORM | CONVF_YUV | CONVF_PACKED | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_Y210,                         10, CONVF_UNORM | CONVF_YUV | CONVF_PACKED | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_Y216,                         16, CONVF_UNORM | CONVF_YUV | CONVF_PACKED | CONVF_R | CONVF_G | CONVF_B },
-        { DXGI_FORMAT_B4G4R4A4_UNORM,                4, CONVF_UNORM | CONVF_BGR | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT,  10, CONVF_FLOAT | CONVF_POS_ONLY | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT,  10, CONVF_FLOAT | CONVF_POS_ONLY | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM,10, CONVF_SNORM | CONVF_R | CONVF_G | CONVF_B | CONVF_A },
-        { XBOX_DXGI_FORMAT_R4G4_UNORM,               4, CONVF_UNORM | CONVF_R | CONVF_G },
-    };
-
-#pragma prefast( suppress : 25004, "Signature must match bsearch" );
-    int __cdecl ConvertCompare(const void* ptr1, const void *ptr2) noexcept
-    {
-        auto p1 = static_cast<const ConvertData*>(ptr1);
-        auto p2 = static_cast<const ConvertData*>(ptr2);
-        if (p1->format == p2->format) return 0;
-        else return (p1->format < p2->format) ? -1 : 1;
-    }
-}
-
-_Use_decl_annotations_
-uint32_t DirectX::Internal::GetConvertFlags(DXGI_FORMAT format) noexcept
-{
-#ifdef _DEBUG
-    // Ensure conversion table is in ascending order
-    assert(std::size(g_ConvertTable) > 0);
-    DXGI_FORMAT lastvalue = g_ConvertTable[0].format;
-    for (size_t index = 1; index < std::size(g_ConvertTable); ++index)
-    {
-        assert(g_ConvertTable[index].format > lastvalue);
-        lastvalue = g_ConvertTable[index].format;
-    }
-#endif
-
-    ConvertData key = { format, 0, 0 };
-    auto in = reinterpret_cast<const ConvertData*>(bsearch(&key, g_ConvertTable, std::size(g_ConvertTable), sizeof(ConvertData),
-        ConvertCompare));
-    return (in) ? in->flags : 0;
-}
-
-_Use_decl_annotations_
-void DirectX::Internal::ConvertScanline(
-    XMVECTOR* pBuffer,
-    size_t count,
-    DXGI_FORMAT outFormat,
-    DXGI_FORMAT inFormat,
-    TEX_FILTER_FLAGS flags) noexcept
-{
-    assert(pBuffer && count > 0 && ((reinterpret_cast<uintptr_t>(pBuffer) & 0xF) == 0));
-    assert(IsValid(outFormat) && !IsTypeless(outFormat) && !IsPlanar(outFormat) && !IsPalettized(outFormat));
-    assert(IsValid(inFormat) && !IsTypeless(inFormat) && !IsPlanar(inFormat) && !IsPalettized(inFormat));
-
-    if (!pBuffer)
-        return;
-
-#ifdef _DEBUG
-    // Ensure conversion table is in ascending order
-    assert(std::size(g_ConvertTable) > 0);
-    DXGI_FORMAT lastvalue = g_ConvertTable[0].format;
-    for (size_t index = 1; index < std::size(g_ConvertTable); ++index)
-    {
-        assert(g_ConvertTable[index].format > lastvalue);
-        lastvalue = g_ConvertTable[index].format;
-    }
-#endif
-
-    // Determine conversion details about source and dest formats
-    ConvertData key = { inFormat, 0, 0 };
-    auto in = reinterpret_cast<const ConvertData*>(
-        bsearch(&key, g_ConvertTable, std::size(g_ConvertTable), sizeof(ConvertData), ConvertCompare));
-    key.format = outFormat;
-    auto out = reinterpret_cast<const ConvertData*>(
-        bsearch(&key, g_ConvertTable, std::size(g_ConvertTable), sizeof(ConvertData), ConvertCompare));
-    if (!in || !out)
-    {
-        assert(false);
-        return;
-    }
-
-    assert(GetConvertFlags(inFormat) == in->flags);
-    assert(GetConvertFlags(outFormat) == out->flags);
-
-    // Handle SRGB filtering modes
-    switch (inFormat)
-    {
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        flags |= TEX_FILTER_SRGB_IN;
-        break;
-
-    case DXGI_FORMAT_A8_UNORM:
-    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-        flags &= ~TEX_FILTER_SRGB_IN;
-        break;
-
-    default:
-        break;
-    }
-
-    switch (outFormat)
-    {
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        flags |= TEX_FILTER_SRGB_OUT;
-        break;
-
-    case DXGI_FORMAT_A8_UNORM:
-    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-        flags &= ~TEX_FILTER_SRGB_OUT;
-        break;
-
-    default:
-        break;
-    }
-
-    if ((flags & (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT)) == (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT))
-    {
-        flags &= ~(TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT);
-    }
-
-    // sRGB input processing (sRGB -> Linear RGB)
-    if (flags & TEX_FILTER_SRGB_IN)
-    {
-        if (!(in->flags & CONVF_DEPTH) && ((in->flags & CONVF_FLOAT) || (in->flags & CONVF_UNORM)))
-        {
-            XMVECTOR* ptr = pBuffer;
-            for (size_t i = 0; i < count; ++i, ++ptr)
-            {
-                *ptr = XMColorSRGBToRGB(*ptr);
-            }
-        }
-    }
-
-    // Handle conversion special cases
-    const uint32_t diffFlags = in->flags ^ out->flags;
-    if (diffFlags != 0)
-    {
-        if (diffFlags & CONVF_DEPTH)
-        {
-            //--- Depth conversions ---
-            if (in->flags & CONVF_DEPTH)
-            {
-                // CONVF_DEPTH -> !CONVF_DEPTH
-                if (in->flags & CONVF_STENCIL)
-                {
-                    // Stencil -> Alpha
-                    static const XMVECTORF32 S = { { { 1.f, 1.f, 1.f, 255.f } } };
-
-                    if (out->flags & CONVF_UNORM)
-                    {
-                        // UINT -> UNORM
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            XMVECTOR v1 = XMVectorSplatY(v);
-                            v1 = XMVectorClamp(v1, g_XMZero, S);
-                            v1 = XMVectorDivide(v1, S);
-                            *ptr++ = XMVectorSelect(v1, v, g_XMSelect1110);
-                        }
-                    }
-                    else if (out->flags & CONVF_SNORM)
-                    {
-                        // UINT -> SNORM
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            XMVECTOR v1 = XMVectorSplatY(v);
-                            v1 = XMVectorClamp(v1, g_XMZero, S);
-                            v1 = XMVectorDivide(v1, S);
-                            v1 = XMVectorMultiplyAdd(v1, g_XMTwo, g_XMNegativeOne);
-                            *ptr++ = XMVectorSelect(v1, v, g_XMSelect1110);
-                        }
-                    }
-                    else
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSplatY(v);
-                            *ptr++ = XMVectorSelect(v1, v, g_XMSelect1110);
-                        }
-                    }
-                }
-
-                // Depth -> RGB
-                if ((out->flags & CONVF_UNORM) && (in->flags & CONVF_FLOAT))
-                {
-                    // Depth FLOAT -> UNORM
-                    XMVECTOR* ptr = pBuffer;
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        XMVECTOR v1 = XMVectorSaturate(v);
-                        v1 = XMVectorSplatX(v1);
-                        *ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
-                    }
-                }
-                else if (out->flags & CONVF_SNORM)
-                {
-                    if (in->flags & CONVF_UNORM)
-                    {
-                        // Depth UNORM -> SNORM
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            XMVECTOR v1 = XMVectorMultiplyAdd(v, g_XMTwo, g_XMNegativeOne);
-                            v1 = XMVectorSplatX(v1);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
-                        }
-                    }
-                    else
-                    {
-                        // Depth FLOAT -> SNORM
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            XMVECTOR v1 = XMVectorClamp(v, g_XMNegativeOne, g_XMOne);
-                            v1 = XMVectorSplatX(v1);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
-                        }
-                    }
-                }
-                else
-                {
-                    XMVECTOR* ptr = pBuffer;
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        const XMVECTOR v1 = XMVectorSplatX(v);
-                        *ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
-                    }
-                }
-            }
-            else
-            {
-                // !CONVF_DEPTH -> CONVF_DEPTH
-
-                // RGB -> Depth (red channel)
-                switch (flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE))
-                {
-                case TEX_FILTER_RGB_COPY_GREEN:
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSplatY(v);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
-                        }
-                    }
-                    break;
-
-                case TEX_FILTER_RGB_COPY_BLUE:
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSplatZ(v);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
-                        }
-                    }
-                    break;
-
-                default:
-                    if ((in->flags & CONVF_UNORM) && ((in->flags & CONVF_RGB_MASK) == (CONVF_R | CONVF_G | CONVF_B)))
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVector3Dot(v, g_Grayscale);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
-                        }
-                        break;
-                    }
-
-                #if (__cplusplus >= 201703L)
-                    [[fallthrough]];
-                #elif defined(__clang__)
-                    [[clang::fallthrough]];
-                #elif defined(_MSC_VER)
-                    __fallthrough;
-                #endif
-
-                case TEX_FILTER_RGB_COPY_RED:
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSplatX(v);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
-                        }
-                    }
-                    break;
-                }
-
-                // Finialize type conversion for depth (red channel)
-                if (out->flags & CONVF_UNORM)
-                {
-                    if (in->flags & CONVF_SNORM)
-                    {
-                        // SNORM -> UNORM
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorMultiplyAdd(v, g_XMOneHalf, g_XMOneHalf);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
-                        }
-                    }
-                    else if (in->flags & CONVF_FLOAT)
-                    {
-                        // FLOAT -> UNORM
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSaturate(v);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
-                        }
-                    }
-                }
-
-                if (out->flags & CONVF_STENCIL)
-                {
-                    // Alpha -> Stencil (green channel)
-                    static const XMVECTORU32 select0100 = { { { XM_SELECT_0, XM_SELECT_1, XM_SELECT_0, XM_SELECT_0 } } };
-                    static const XMVECTORF32 S = { { { 255.f, 255.f, 255.f, 255.f } } };
-
-                    if (in->flags & CONVF_UNORM)
-                    {
-                        // UNORM -> UINT
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            XMVECTOR v1 = XMVectorMultiply(v, S);
-                            v1 = XMVectorSplatW(v1);
-                            *ptr++ = XMVectorSelect(v, v1, select0100);
-                        }
-                    }
-                    else if (in->flags & CONVF_SNORM)
-                    {
-                        // SNORM -> UINT
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            XMVECTOR v1 = XMVectorMultiplyAdd(v, g_XMOneHalf, g_XMOneHalf);
-                            v1 = XMVectorMultiply(v1, S);
-                            v1 = XMVectorSplatW(v1);
-                            *ptr++ = XMVectorSelect(v, v1, select0100);
-                        }
-                    }
-                    else
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSplatW(v);
-                            *ptr++ = XMVectorSelect(v, v1, select0100);
-                        }
-                    }
-                }
-            }
-        }
-        else if (out->flags & CONVF_DEPTH)
-        {
-            // CONVF_DEPTH -> CONVF_DEPTH
-            if (diffFlags & CONVF_FLOAT)
-            {
-                if (in->flags & CONVF_FLOAT)
-                {
-                    // FLOAT -> UNORM depth, preserve stencil
-                    XMVECTOR* ptr = pBuffer;
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        const XMVECTOR v1 = XMVectorSaturate(v);
-                        *ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
-                    }
-                }
-            }
-        }
-        else if (out->flags & CONVF_UNORM)
-        {
-            //--- Converting to a UNORM ---
-            if (in->flags & CONVF_SNORM)
-            {
-                // SNORM -> UNORM
-                XMVECTOR* ptr = pBuffer;
-                for (size_t i = 0; i < count; ++i)
-                {
-                    const XMVECTOR v = *ptr;
-                    *ptr++ = XMVectorMultiplyAdd(v, g_XMOneHalf, g_XMOneHalf);
-                }
-            }
-            else if (in->flags & CONVF_FLOAT)
-            {
-                XMVECTOR* ptr = pBuffer;
-                if (!(in->flags & CONVF_POS_ONLY) && (flags & TEX_FILTER_FLOAT_X2BIAS))
-                {
-                    // FLOAT -> UNORM (x2 bias)
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        XMVECTOR v = *ptr;
-                        v = XMVectorClamp(v, g_XMNegativeOne, g_XMOne);
-                        *ptr++ = XMVectorMultiplyAdd(v, g_XMOneHalf, g_XMOneHalf);
-                    }
-                }
-                else
-                {
-                    // FLOAT -> UNORM
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        *ptr++ = XMVectorSaturate(v);
-                    }
-                }
-            }
-        }
-        else if (out->flags & CONVF_SNORM)
-        {
-            //--- Converting to a SNORM ---
-            if (in->flags & CONVF_UNORM)
-            {
-                // UNORM -> SNORM
-                XMVECTOR* ptr = pBuffer;
-                for (size_t i = 0; i < count; ++i)
-                {
-                    const XMVECTOR v = *ptr;
-                    *ptr++ = XMVectorMultiplyAdd(v, g_XMTwo, g_XMNegativeOne);
-                }
-            }
-            else if (in->flags & CONVF_FLOAT)
-            {
-                XMVECTOR* ptr = pBuffer;
-                if ((in->flags & CONVF_POS_ONLY) && (flags & TEX_FILTER_FLOAT_X2BIAS))
-                {
-                    // FLOAT (positive only, x2 bias) -> SNORM
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        XMVECTOR v = *ptr;
-                        v = XMVectorSaturate(v);
-                        *ptr++ = XMVectorMultiplyAdd(v, g_XMTwo, g_XMNegativeOne);
-                    }
-                }
-                else
-                {
-                    // FLOAT -> SNORM
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        *ptr++ = XMVectorClamp(v, g_XMNegativeOne, g_XMOne);
-                    }
-                }
-            }
-        }
-        else if (diffFlags & CONVF_UNORM)
-        {
-            //--- Converting from a UNORM ---
-            assert(in->flags & CONVF_UNORM);
-            if (out->flags & CONVF_FLOAT)
-            {
-                if (!(out->flags & CONVF_POS_ONLY) && (flags & TEX_FILTER_FLOAT_X2BIAS))
-                {
-                    // UNORM (x2 bias) -> FLOAT
-                    XMVECTOR* ptr = pBuffer;
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        *ptr++ = XMVectorMultiplyAdd(v, g_XMTwo, g_XMNegativeOne);
-                    }
-                }
-            }
-        }
-        else if (diffFlags & CONVF_POS_ONLY)
-        {
-            if (flags & TEX_FILTER_FLOAT_X2BIAS)
-            {
-                if (in->flags & CONVF_POS_ONLY)
-                {
-                    if (out->flags & CONVF_FLOAT)
-                    {
-                        // FLOAT (positive only, x2 bias) -> FLOAT
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            XMVECTOR v = *ptr;
-                            v = XMVectorSaturate(v);
-                            *ptr++ = XMVectorMultiplyAdd(v, g_XMTwo, g_XMNegativeOne);
-                        }
-                    }
-                }
-                else if (out->flags & CONVF_POS_ONLY)
-                {
-                    if (in->flags & CONVF_FLOAT)
-                    {
-                        // FLOAT -> FLOAT (positive only, x2 bias)
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            XMVECTOR v = *ptr;
-                            v = XMVectorClamp(v, g_XMNegativeOne, g_XMOne);
-                            *ptr++ = XMVectorMultiplyAdd(v, g_XMOneHalf, g_XMOneHalf);
-                        }
-                    }
-                    else if (in->flags & CONVF_SNORM)
-                    {
-                        // SNORM -> FLOAT (positive only, x2 bias)
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            *ptr++ = XMVectorMultiplyAdd(v, g_XMOneHalf, g_XMOneHalf);
-                        }
-                    }
-                }
-            }
-        }
-
-        // !CONVF_A -> CONVF_A is handled because LoadScanline ensures alpha defaults to 1.0 for no-alpha formats
-
-        // CONVF_PACKED cases are handled because LoadScanline/StoreScanline handles packing/unpacking
-
-        if (((out->flags & CONVF_RGBA_MASK) == CONVF_A) && !(in->flags & CONVF_A))
-        {
-            // !CONVF_A -> A format
-            switch (flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE))
-            {
-            case TEX_FILTER_RGB_COPY_GREEN:
-                {
-                    XMVECTOR* ptr = pBuffer;
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        *ptr++ = XMVectorSplatY(v);
-                    }
-                }
-                break;
-
-            case TEX_FILTER_RGB_COPY_BLUE:
-                {
-                    XMVECTOR* ptr = pBuffer;
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        *ptr++ = XMVectorSplatZ(v);
-                    }
-                }
-                break;
-
-            default:
-                if ((in->flags & CONVF_UNORM) && ((in->flags & CONVF_RGB_MASK) == (CONVF_R | CONVF_G | CONVF_B)))
-                {
-                    XMVECTOR* ptr = pBuffer;
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        *ptr++ = XMVector3Dot(v, g_Grayscale);
-                    }
-                    break;
-                }
-
-            #if (__cplusplus >= 201703L)
-                [[fallthrough]];
-            #elif defined(__clang__)
-                [[clang::fallthrough]];
-            #elif defined(_MSC_VER)
-                __fallthrough;
-            #endif
-
-            case TEX_FILTER_RGB_COPY_RED:
-                {
-                    XMVECTOR* ptr = pBuffer;
-                    for (size_t i = 0; i < count; ++i)
-                    {
-                        const XMVECTOR v = *ptr;
-                        *ptr++ = XMVectorSplatX(v);
-                    }
-                }
-                break;
-            }
-        }
-        else if (((in->flags & CONVF_RGBA_MASK) == CONVF_A) && !(out->flags & CONVF_A))
-        {
-            // A format -> !CONVF_A
-            XMVECTOR* ptr = pBuffer;
-            for (size_t i = 0; i < count; ++i)
-            {
-                const XMVECTOR v = *ptr;
-                *ptr++ = XMVectorSplatW(v);
-            }
-        }
-        else if ((in->flags & CONVF_RGB_MASK) == CONVF_R)
-        {
-            if ((out->flags & CONVF_RGB_MASK) == (CONVF_R | CONVF_G | CONVF_B))
-            {
-                // R format -> RGB format
-                XMVECTOR* ptr = pBuffer;
-                for (size_t i = 0; i < count; ++i)
-                {
-                    const XMVECTOR v = *ptr;
-                    const XMVECTOR v1 = XMVectorSplatX(v);
-                    *ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
-                }
-            }
-            else if ((out->flags & CONVF_RGB_MASK) == (CONVF_R | CONVF_G))
-            {
-                // R format -> RG format
-                XMVECTOR* ptr = pBuffer;
-                for (size_t i = 0; i < count; ++i)
-                {
-                    const XMVECTOR v = *ptr;
-                    const XMVECTOR v1 = XMVectorSplatX(v);
-                    *ptr++ = XMVectorSelect(v, v1, g_XMSelect1100);
-                }
-            }
-        }
-        else if ((in->flags & CONVF_RGB_MASK) == (CONVF_R | CONVF_G | CONVF_B))
-        {
-            if ((out->flags & CONVF_RGB_MASK) == CONVF_R)
-            {
-                // RGB format -> R format
-                switch (flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE))
-                {
-                case TEX_FILTER_RGB_COPY_GREEN:
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSplatY(v);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
-                        }
-                    }
-                    break;
-
-                case TEX_FILTER_RGB_COPY_BLUE:
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSplatZ(v);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
-                        }
-                    }
-                    break;
-
-                default:
-                    if (in->flags & CONVF_UNORM)
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVector3Dot(v, g_Grayscale);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
-                        }
-                        break;
-                    }
-
-                #if (__cplusplus >= 201703L)
-                    [[fallthrough]];
-                #elif defined(__clang__)
-                    [[clang::fallthrough]];
-                #elif defined(_MSC_VER)
-                    __fallthrough;
-                #endif
-
-                case TEX_FILTER_RGB_COPY_RED:
-                    // Leave data unchanged and the store will handle this...
-                    break;
-                }
-            }
-            else if ((out->flags & CONVF_RGB_MASK) == (CONVF_R | CONVF_G))
-            {
-                // RGB format -> RG format
-                switch (static_cast<int>(flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE)))
-                {
-                case (static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE)):
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSwizzle<0, 2, 0, 2>(v);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1100);
-                        }
-                    }
-                    break;
-
-                case (static_cast<int>(TEX_FILTER_RGB_COPY_GREEN) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE)):
-                    {
-                        XMVECTOR* ptr = pBuffer;
-                        for (size_t i = 0; i < count; ++i)
-                        {
-                            const XMVECTOR v = *ptr;
-                            const XMVECTOR v1 = XMVectorSwizzle<1, 2, 3, 0>(v);
-                            *ptr++ = XMVectorSelect(v, v1, g_XMSelect1100);
-                        }
-                    }
-                    break;
-
-                case (static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_GREEN)):
-                default:
-                    // Leave data unchanged and the store will handle this...
-                    break;
-                }
-            }
-        }
-    }
-
-    // sRGB output processing (Linear RGB -> sRGB)
-    if (flags & TEX_FILTER_SRGB_OUT)
-    {
-        if (!(out->flags & CONVF_DEPTH) && ((out->flags & CONVF_FLOAT) || (out->flags & CONVF_UNORM)))
-        {
-            XMVECTOR* ptr = pBuffer;
-            for (size_t i = 0; i < count; ++i, ++ptr)
-            {
-                *ptr = XMColorRGBToSRGB(*ptr);
-            }
-        }
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Dithering
-//-------------------------------------------------------------------------------------
-namespace
-{
-    // 4X4X4 ordered dithering matrix
-    const float g_Dither[] =
-    {
-        // (z & 3) + ( (y & 3) * 8) + (x & 3)
-        0.468750f,  -0.031250f, 0.343750f, -0.156250f, 0.468750f, -0.031250f, 0.343750f, -0.156250f,
-        -0.281250f,  0.218750f, -0.406250f, 0.093750f, -0.281250f, 0.218750f, -0.406250f, 0.093750f,
-        0.281250f,  -0.218750f, 0.406250f, -0.093750f, 0.281250f, -0.218750f, 0.406250f, -0.093750f,
-        -0.468750f,  0.031250f, -0.343750f, 0.156250f, -0.468750f, 0.031250f, -0.343750f, 0.156250f,
-    };
-
-    const XMVECTORF32 g_Scale16pc = { { { 65535.f, 65535.f, 65535.f, 65535.f } } };
-    const XMVECTORF32 g_Scale15pc = { { { 32767.f, 32767.f, 32767.f, 32767.f } } };
-    const XMVECTORF32 g_Scale10pc = { { {  1023.f,  1023.f,  1023.f,     3.f } } };
-    const XMVECTORF32 g_Scale9pc = { { {   511.f,   511.f,   511.f,     3.f } } };
-    const XMVECTORF32 g_Scale8pc = { { {   255.f,   255.f,   255.f,   255.f } } };
-    const XMVECTORF32 g_Scale7pc = { { {   127.f,   127.f,   127.f,   127.f } } };
-    const XMVECTORF32 g_Scale565pc = { { {    31.f,    63.f,    31.f,     1.f } } };
-    const XMVECTORF32 g_Scale5551pc = { { {    31.f,    31.f,    31.f,     1.f } } };
-    const XMVECTORF32 g_Scale4pc = { { {    15.f,    15.f,    15.f,    15.f } } };
-
-    const XMVECTORF32 g_ErrorWeight3 = { { { 3.f / 16.f, 3.f / 16.f, 3.f / 16.f, 3.f / 16.f } } };
-    const XMVECTORF32 g_ErrorWeight5 = { { { 5.f / 16.f, 5.f / 16.f, 5.f / 16.f, 5.f / 16.f } } };
-    const XMVECTORF32 g_ErrorWeight1 = { { { 1.f / 16.f, 1.f / 16.f, 1.f / 16.f, 1.f / 16.f } } };
-    const XMVECTORF32 g_ErrorWeight7 = { { { 7.f / 16.f, 7.f / 16.f, 7.f / 16.f, 7.f / 16.f } } };
-
-#define STORE_SCANLINE( type, scalev, clampzero, norm, itype, mask, row, bgr ) \
-        if (size >= sizeof(type)) \
-        { \
-            type * __restrict dest = reinterpret_cast<type*>(pDestination); \
-            for(size_t i = 0; i < count; ++i) \
-            { \
-                auto index = static_cast<ptrdiff_t>((row & 1) ? (count - i - 1) : i ); \
-                ptrdiff_t delta = (row & 1) ? -2 : 0; \
-                \
-                XMVECTOR v = sPtr[ index ]; \
-                if (bgr) { v = XMVectorSwizzle<2, 1, 0, 3>(v); } \
-                if (norm && clampzero) v = XMVectorSaturate(v) ; \
-                else if (clampzero) v = XMVectorClamp(v, g_XMZero, scalev); \
-                else if (norm) v = XMVectorClamp(v, g_XMNegativeOne, g_XMOne); \
-                else v = XMVectorClamp(v, XMVectorAdd(XMVectorNegate(scalev), g_XMOne), scalev); \
-                v = XMVectorAdd(v, vError); \
-                if (norm) v = XMVectorMultiply(v, scalev); \
-                \
-                XMVECTOR target; \
-                if (pDiffusionErrors) \
-                { \
-                    target = XMVectorRound(v); \
-                    vError = XMVectorSubtract(v, target); \
-                    if (norm) vError = XMVectorDivide(vError, scalev); \
-                    \
-                    /* Distribute error to next scanline and next pixel */ \
-                    pDiffusionErrors[ index-delta ]   = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[ index-delta ]); \
-                    pDiffusionErrors[ index+1 ]       = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[ index+1 ]); \
-                    pDiffusionErrors[ index+2+delta ] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[ index+2+delta ]); \
-                    vError = XMVectorMultiply(vError, g_ErrorWeight7); \
-                } \
-                else \
-                { \
-                    /* Applied ordered dither */ \
-                    target = XMVectorAdd(v, ordered[ index & 3 ]); \
-                    target = XMVectorRound(target); \
-                } \
-                \
-                target = XMVectorMin(scalev, target); \
-                target = XMVectorMax((clampzero) ? g_XMZero : (XMVectorAdd(XMVectorNegate(scalev), g_XMOne)), target); \
-                \
-                XMFLOAT4A tmp; \
-                XMStoreFloat4A(&tmp, target); \
-                \
-                auto dPtr = &dest[ index ]; \
-                if (dPtr >= ePtr) break; \
-                dPtr->x = itype(static_cast<itype>(tmp.x) & mask); \
-                dPtr->y = itype(static_cast<itype>(tmp.y) & mask); \
-                dPtr->z = itype(static_cast<itype>(tmp.z) & mask); \
-                dPtr->w = itype(static_cast<itype>(tmp.w) & mask); \
-            } \
-            return true; \
-        } \
-        return false;
-
-#define STORE_SCANLINE2( type, scalev, clampzero, norm, itype, mask, row ) \
-        /* The 2 component cases are always bgr=false */ \
-        if (size >= sizeof(type)) \
-        { \
-            type * __restrict dest = reinterpret_cast<type*>(pDestination); \
-            for(size_t i = 0; i < count; ++i) \
-            { \
-                auto index = static_cast<ptrdiff_t>((row & 1) ? (count - i - 1) : i ); \
-                ptrdiff_t delta = (row & 1) ? -2 : 0; \
-                \
-                XMVECTOR v = sPtr[ index ]; \
-                if (norm && clampzero) v = XMVectorSaturate(v) ; \
-                else if (clampzero) v = XMVectorClamp(v, g_XMZero, scalev); \
-                else if (norm) v = XMVectorClamp(v, g_XMNegativeOne, g_XMOne); \
-                else v = XMVectorClamp(v, XMVectorAdd(XMVectorNegate(scalev), g_XMOne), scalev); \
-                v = XMVectorAdd(v, vError); \
-                if (norm) v = XMVectorMultiply(v, scalev); \
-                \
-                XMVECTOR target; \
-                if (pDiffusionErrors) \
-                { \
-                    target = XMVectorRound(v); \
-                    vError = XMVectorSubtract(v, target); \
-                    if (norm) vError = XMVectorDivide(vError, scalev); \
-                    \
-                    /* Distribute error to next scanline and next pixel */ \
-                    pDiffusionErrors[ index-delta ]   = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[ index-delta ]); \
-                    pDiffusionErrors[ index+1 ]       = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[ index+1 ]); \
-                    pDiffusionErrors[ index+2+delta ] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[ index+2+delta ]); \
-                    vError = XMVectorMultiply(vError, g_ErrorWeight7); \
-                } \
-                else \
-                { \
-                    /* Applied ordered dither */ \
-                    target = XMVectorAdd(v, ordered[ index & 3 ]); \
-                    target = XMVectorRound(target); \
-                } \
-                \
-                target = XMVectorMin(scalev, target); \
-                target = XMVectorMax((clampzero) ? g_XMZero : (XMVectorAdd(XMVectorNegate(scalev), g_XMOne)), target); \
-                \
-                XMFLOAT4A tmp; \
-                XMStoreFloat4A(&tmp, target); \
-                \
-                auto dPtr = &dest[ index ]; \
-                if (dPtr >= ePtr) break; \
-                dPtr->x = itype(static_cast<itype>(tmp.x) & mask); \
-                dPtr->y = itype(static_cast<itype>(tmp.y) & mask); \
-            } \
-            return true; \
-        } \
-        return false;
-
-#define STORE_SCANLINE1( type, scalev, clampzero, norm, mask, row, selectw ) \
-        /* The 1 component cases are always bgr=false */ \
-        if (size >= sizeof(type)) \
-        { \
-            type * __restrict dest = reinterpret_cast<type*>(pDestination); \
-            for(size_t i = 0; i < count; ++i) \
-            { \
-                auto index = static_cast<ptrdiff_t>((row & 1) ? (count - i - 1) : i ); \
-                ptrdiff_t delta = (row & 1) ? -2 : 0; \
-                \
-                XMVECTOR v = sPtr[ index ]; \
-                if (norm && clampzero) v = XMVectorSaturate(v) ; \
-                else if (clampzero) v = XMVectorClamp(v, g_XMZero, scalev); \
-                else if (norm) v = XMVectorClamp(v, g_XMNegativeOne, g_XMOne); \
-                else v = XMVectorClamp(v, XMVectorAdd(XMVectorNegate(scalev), g_XMOne), scalev); \
-                v = XMVectorAdd(v, vError); \
-                if (norm) v = XMVectorMultiply(v, scalev); \
-                \
-                XMVECTOR target; \
-                if (pDiffusionErrors) \
-                { \
-                    target = XMVectorRound(v); \
-                    vError = XMVectorSubtract(v, target); \
-                    if (norm) vError = XMVectorDivide(vError, scalev); \
-                    \
-                    /* Distribute error to next scanline and next pixel */ \
-                    pDiffusionErrors[ index-delta ]   = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[ index-delta ]); \
-                    pDiffusionErrors[ index+1 ]       = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[ index+1 ]); \
-                    pDiffusionErrors[ index+2+delta ] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[ index+2+delta ]); \
-                    vError = XMVectorMultiply(vError, g_ErrorWeight7); \
-                } \
-                else \
-                { \
-                    /* Applied ordered dither */ \
-                    target = XMVectorAdd(v, ordered[ index & 3 ]); \
-                    target = XMVectorRound(target); \
-                } \
-                \
-                target = XMVectorMin(scalev, target); \
-                target = XMVectorMax((clampzero) ? g_XMZero : (XMVectorAdd(XMVectorNegate(scalev), g_XMOne)), target); \
-                \
-                auto dPtr = &dest[ index ]; \
-                if (dPtr >= ePtr) break; \
-                *dPtr = type(static_cast<type>((selectw) ? XMVectorGetW(target) : XMVectorGetX(target)) & mask); \
-            } \
-            return true; \
-        } \
-        return false;
-}
-
-#pragma warning(push)
-#pragma warning( disable : 4127 )
-
-_Use_decl_annotations_
-bool DirectX::Internal::StoreScanlineDither(
-    void* pDestination,
-    size_t size,
-    DXGI_FORMAT format,
-    XMVECTOR* pSource,
-    size_t count,
-    float threshold,
-    size_t y,
-    size_t z,
-    XMVECTOR* pDiffusionErrors) noexcept
-{
-    assert(pDestination != nullptr);
-    assert(IsValid(format) && !IsTypeless(format) && !IsCompressed(format) && !IsPlanar(format) && !IsPalettized(format));
-
-    if (!size || !count)
-        return false;
-
-    const XMVECTOR* __restrict sPtr = pSource;
-    if (!sPtr)
-        return false;
-
-    assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
-
-    XMVECTOR ordered[4];
-    if (pDiffusionErrors)
-    {
-        // If pDiffusionErrors != 0, then this function performs error diffusion dithering (aka Floyd-Steinberg dithering)
-
-        // To avoid the need for another temporary scanline buffer, we allow this function to overwrite the source buffer in-place
-        // Given the intended usage in the conversion routines, this is not a problem.
-
-        XMVECTOR* ptr = pSource;
-        const XMVECTOR* err = pDiffusionErrors + 1;
-        for (size_t i = 0; i < count; ++i)
-        {
-            // Add contribution from previous scanline
-            XMVECTOR v = XMVectorAdd(*ptr, *err++);
-            *ptr++ = v;
-        }
-
-        // Reset errors for next scanline
-        memset(pDiffusionErrors, 0, sizeof(XMVECTOR)*(count + 2));
-    }
-    else
-    {
-        // If pDiffusionErrors == 0, then this function performs ordered dithering
-
-        const XMVECTOR dither = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(g_Dither + (z & 3) + ((y & 3) * 8)));
-
-        ordered[0] = XMVectorSplatX(dither);
-        ordered[1] = XMVectorSplatY(dither);
-        ordered[2] = XMVectorSplatZ(dither);
-        ordered[3] = XMVectorSplatW(dither);
-    }
-
-    const void* ePtr = static_cast<const uint8_t*>(pDestination) + size;
-
-#ifdef _PREFAST_
-    *reinterpret_cast<uint8_t*>(pDestination) = 0;
-#endif
-
-    XMVECTOR vError = XMVectorZero();
-
-    switch (static_cast<int>(format))
-    {
-    case DXGI_FORMAT_R16G16B16A16_UNORM:
-        STORE_SCANLINE(XMUSHORTN4, g_Scale16pc, true, true, uint16_t, 0xFFFF, y, false)
-
-    case DXGI_FORMAT_R16G16B16A16_UINT:
-        STORE_SCANLINE(XMUSHORT4, g_Scale16pc, true, false, uint16_t, 0xFFFF, y, false)
-
-    case DXGI_FORMAT_R16G16B16A16_SNORM:
-        STORE_SCANLINE(XMSHORTN4, g_Scale15pc, false, true, int16_t, 0xFFFF, y, false)
-
-    case DXGI_FORMAT_R16G16B16A16_SINT:
-        STORE_SCANLINE(XMSHORT4, g_Scale15pc, false, false, int16_t, 0xFFFF, y, false)
-
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-        STORE_SCANLINE(XMUDECN4, g_Scale10pc, true, true, uint16_t, 0x3FF, y, false)
-
-    case DXGI_FORMAT_R10G10B10A2_UINT:
-        STORE_SCANLINE(XMUDEC4, g_Scale10pc, true, false, uint16_t, 0x3FF, y, false)
-
-    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-        if (size >= sizeof(XMUDEC4))
-        {
-            static const XMVECTORF32  Scale = { { { 510.0f, 510.0f, 510.0f, 3.0f } } };
-            static const XMVECTORF32  Bias = { { { 384.0f, 384.0f, 384.0f, 0.0f } } };
-            static const XMVECTORF32  MinXR = { { { -0.7529f, -0.7529f, -0.7529f, 0.f } } };
-            static const XMVECTORF32  MaxXR = { { { 1.2529f, 1.2529f, 1.2529f, 1.0f } } };
-
-            XMUDEC4 * __restrict dest = static_cast<XMUDEC4*>(pDestination);
-            for (size_t i = 0; i < count; ++i)
-            {
-                auto index = static_cast<ptrdiff_t>((y & 1) ? (count - i - 1) : i);
-                ptrdiff_t delta = (y & 1) ? -2 : 0;
-
-                XMVECTOR v = XMVectorClamp(sPtr[index], MinXR, MaxXR);
-                v = XMVectorMultiplyAdd(v, Scale, vError);
-
-                XMVECTOR target;
-                if (pDiffusionErrors)
-                {
-                    target = XMVectorRound(v);
-                    vError = XMVectorSubtract(v, target);
-                    vError = XMVectorDivide(vError, Scale);
-
-                    // Distribute error to next scanline and next pixel
-                    pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
-                    pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
-                    pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
-                    vError = XMVectorMultiply(vError, g_ErrorWeight7);
-                }
-                else
-                {
-                    // Applied ordered dither
-                    target = XMVectorAdd(v, ordered[index & 3]);
-                    target = XMVectorRound(target);
-                }
-
-                target = XMVectorAdd(target, Bias);
-                target = XMVectorClamp(target, g_XMZero, g_Scale10pc);
-
-                XMFLOAT4A tmp;
-                XMStoreFloat4A(&tmp, target);
-
-                auto dPtr = &dest[index];
-                if (dPtr >= ePtr) break;
-                dPtr->x = uint16_t(static_cast<uint16_t>(tmp.x) & 0x3FF);
-                dPtr->y = uint16_t(static_cast<uint16_t>(tmp.y) & 0x3FF);
-                dPtr->z = uint16_t(static_cast<uint16_t>(tmp.z) & 0x3FF);
-                dPtr->w = static_cast<uint16_t>(tmp.w);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-        STORE_SCANLINE(XMUBYTEN4, g_Scale8pc, true, true, uint8_t, 0xFF, y, false)
-
-    case DXGI_FORMAT_R8G8B8A8_UINT:
-        STORE_SCANLINE(XMUBYTE4, g_Scale8pc, true, false, uint8_t, 0xFF, y, false)
-
-    case DXGI_FORMAT_R8G8B8A8_SNORM:
-        STORE_SCANLINE(XMBYTEN4, g_Scale7pc, false, true, int8_t, 0xFF, y, false)
-
-    case DXGI_FORMAT_R8G8B8A8_SINT:
-        STORE_SCANLINE(XMBYTE4, g_Scale7pc, false, false, int8_t, 0xFF, y, false)
-
-    case DXGI_FORMAT_R16G16_UNORM:
-        STORE_SCANLINE2(XMUSHORTN2, g_Scale16pc, true, true, uint16_t, 0xFFFF, y)
-
-    case DXGI_FORMAT_R16G16_UINT:
-        STORE_SCANLINE2(XMUSHORT2, g_Scale16pc, true, false, uint16_t, 0xFFFF, y)
-
-    case DXGI_FORMAT_R16G16_SNORM:
-        STORE_SCANLINE2(XMSHORTN2, g_Scale15pc, false, true, int16_t, 0xFFFF, y)
-
-    case DXGI_FORMAT_R16G16_SINT:
-        STORE_SCANLINE2(XMSHORT2, g_Scale15pc, false, false, int16_t, 0xFFFF, y)
-
-    case DXGI_FORMAT_D24_UNORM_S8_UINT:
-        if (size >= sizeof(uint32_t))
-        {
-            static const XMVECTORF32 Clamp = { { { 1.f,  255.f, 0.f, 0.f } } };
-            static const XMVECTORF32 Scale = { { { 16777215.f,   1.f, 0.f, 0.f } } };
-            static const XMVECTORF32 Scale2 = { { { 16777215.f, 255.f, 0.f, 0.f } } };
-
-            uint32_t * __restrict dest = static_cast<uint32_t*>(pDestination);
-            for (size_t i = 0; i < count; ++i)
-            {
-                auto index = static_cast<ptrdiff_t>((y & 1) ? (count - i - 1) : i);
-                ptrdiff_t delta = (y & 1) ? -2 : 0;
-
-                XMVECTOR v = XMVectorClamp(sPtr[index], g_XMZero, Clamp);
-                v = XMVectorAdd(v, vError);
-                v = XMVectorMultiply(v, Scale);
-
-                XMVECTOR target;
-                if (pDiffusionErrors)
-                {
-                    target = XMVectorRound(v);
-                    vError = XMVectorSubtract(v, target);
-                    vError = XMVectorDivide(vError, Scale);
-
-                    // Distribute error to next scanline and next pixel
-                    pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
-                    pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
-                    pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
-                    vError = XMVectorMultiply(vError, g_ErrorWeight7);
-                }
-                else
-                {
-                    // Applied ordered dither
-                    target = XMVectorAdd(v, ordered[index & 3]);
-                    target = XMVectorRound(target);
-                }
-
-                target = XMVectorClamp(target, g_XMZero, Scale2);
-
-                XMFLOAT4A tmp;
-                XMStoreFloat4A(&tmp, target);
-
-                auto dPtr = &dest[index];
-                if (dPtr >= ePtr) break;
-                *dPtr = (static_cast<uint32_t>(tmp.x) & 0xFFFFFF)
-                    | ((static_cast<uint32_t>(tmp.y) & 0xFF) << 24);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_R8G8_UNORM:
-        STORE_SCANLINE2(XMUBYTEN2, g_Scale8pc, true, true, uint8_t, 0xFF, y)
-
-    case DXGI_FORMAT_R8G8_UINT:
-        STORE_SCANLINE2(XMUBYTE2, g_Scale8pc, true, false, uint8_t, 0xFF, y)
-
-    case DXGI_FORMAT_R8G8_SNORM:
-        STORE_SCANLINE2(XMBYTEN2, g_Scale7pc, false, true, int8_t, 0xFF, y)
-
-    case DXGI_FORMAT_R8G8_SINT:
-        STORE_SCANLINE2(XMBYTE2, g_Scale7pc, false, false, int8_t, 0xFF, y)
-
-    case DXGI_FORMAT_D16_UNORM:
-    case DXGI_FORMAT_R16_UNORM:
-        STORE_SCANLINE1(uint16_t, g_Scale16pc, true, true, 0xFFFF, y, false)
-
-    case DXGI_FORMAT_R16_UINT:
-        STORE_SCANLINE1(uint16_t, g_Scale16pc, true, false, 0xFFFF, y, false)
-
-    case DXGI_FORMAT_R16_SNORM:
-        STORE_SCANLINE1(int16_t, g_Scale15pc, false, true, 0xFFFF, y, false)
-
-    case DXGI_FORMAT_R16_SINT:
-        STORE_SCANLINE1(int16_t, g_Scale15pc, false, false, 0xFFFF, y, false)
-
-    case DXGI_FORMAT_R8_UNORM:
-        STORE_SCANLINE1(uint8_t, g_Scale8pc, true, true, 0xFF, y, false)
-
-    case DXGI_FORMAT_R8_UINT:
-        STORE_SCANLINE1(uint8_t, g_Scale8pc, true, false, 0xFF, y, false)
-
-    case DXGI_FORMAT_R8_SNORM:
-        STORE_SCANLINE1(int8_t, g_Scale7pc, false, true, 0xFF, y, false)
-
-    case DXGI_FORMAT_R8_SINT:
-        STORE_SCANLINE1(int8_t, g_Scale7pc, false, false, 0xFF, y, false)
-
-    case DXGI_FORMAT_A8_UNORM:
-        STORE_SCANLINE1(uint8_t, g_Scale8pc, true, true, 0xFF, y, true)
-
-    case DXGI_FORMAT_B5G6R5_UNORM:
-        if (size >= sizeof(XMU565))
-        {
-            XMU565 * __restrict dest = static_cast<XMU565*>(pDestination);
-            for (size_t i = 0; i < count; ++i)
-            {
-                auto index = static_cast<ptrdiff_t>((y & 1) ? (count - i - 1) : i);
-                ptrdiff_t delta = (y & 1) ? -2 : 0;
-
-                XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(sPtr[index]);
-                v = XMVectorSaturate(v);
-                v = XMVectorAdd(v, vError);
-                v = XMVectorMultiply(v, g_Scale565pc);
-
-                XMVECTOR target;
-                if (pDiffusionErrors)
-                {
-                    target = XMVectorRound(v);
-                    vError = XMVectorSubtract(v, target);
-                    vError = XMVectorDivide(vError, g_Scale565pc);
-
-                    // Distribute error to next scanline and next pixel
-                    pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
-                    pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
-                    pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
-                    vError = XMVectorMultiply(vError, g_ErrorWeight7);
-                }
-                else
-                {
-                    // Applied ordered dither
-                    target = XMVectorAdd(v, ordered[index & 3]);
-                    target = XMVectorRound(target);
-                }
-
-                target = XMVectorClamp(target, g_XMZero, g_Scale565pc);
-
-                XMFLOAT4A tmp;
-                XMStoreFloat4A(&tmp, target);
-
-                auto dPtr = &dest[index];
-                if (dPtr >= ePtr) break;
-                dPtr->x = uint16_t(static_cast<uint16_t>(tmp.x) & 0x1F);
-                dPtr->y = uint16_t(static_cast<uint16_t>(tmp.y) & 0x3F);
-                dPtr->z = uint16_t(static_cast<uint16_t>(tmp.z) & 0x1F);
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-        if (size >= sizeof(XMU555))
-        {
-            XMU555 * __restrict dest = static_cast<XMU555*>(pDestination);
-            for (size_t i = 0; i < count; ++i)
-            {
-                auto index = static_cast<ptrdiff_t>((y & 1) ? (count - i - 1) : i);
-                ptrdiff_t delta = (y & 1) ? -2 : 0;
-
-                XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(sPtr[index]);
-                v = XMVectorSaturate(v);
-                v = XMVectorAdd(v, vError);
-                v = XMVectorMultiply(v, g_Scale5551pc);
-
-                XMVECTOR target;
-                if (pDiffusionErrors)
-                {
-                    target = XMVectorRound(v);
-                    vError = XMVectorSubtract(v, target);
-                    vError = XMVectorDivide(vError, g_Scale5551pc);
-
-                    // Distribute error to next scanline and next pixel
-                    pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
-                    pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
-                    pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
-                    vError = XMVectorMultiply(vError, g_ErrorWeight7);
-                }
-                else
-                {
-                    // Applied ordered dither
-                    target = XMVectorAdd(v, ordered[index & 3]);
-                    target = XMVectorRound(target);
-                }
-
-                target = XMVectorClamp(target, g_XMZero, g_Scale5551pc);
-
-                XMFLOAT4A tmp;
-                XMStoreFloat4A(&tmp, target);
-
-                auto dPtr = &dest[index];
-                if (dPtr >= ePtr) break;
-                dPtr->x = uint16_t(static_cast<uint16_t>(tmp.x) & 0x1F);
-                dPtr->y = uint16_t(static_cast<uint16_t>(tmp.y) & 0x1F);
-                dPtr->z = uint16_t(static_cast<uint16_t>(tmp.z) & 0x1F);
-                dPtr->w = (XMVectorGetW(target) > threshold) ? 1u : 0u;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        STORE_SCANLINE(XMUBYTEN4, g_Scale8pc, true, true, uint8_t, 0xFF, y, true)
-
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        if (size >= sizeof(XMUBYTEN4))
-        {
-            XMUBYTEN4 * __restrict dest = static_cast<XMUBYTEN4*>(pDestination);
-            for (size_t i = 0; i < count; ++i)
-            {
-                auto index = static_cast<ptrdiff_t>((y & 1) ? (count - i - 1) : i);
-                ptrdiff_t delta = (y & 1) ? -2 : 0;
-
-                XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(sPtr[index]);
-                v = XMVectorSaturate(v);
-                v = XMVectorAdd(v, vError);
-                v = XMVectorMultiply(v, g_Scale8pc);
-
-                XMVECTOR target;
-                if (pDiffusionErrors)
-                {
-                    target = XMVectorRound(v);
-                    vError = XMVectorSubtract(v, target);
-                    vError = XMVectorDivide(vError, g_Scale8pc);
-
-                    // Distribute error to next scanline and next pixel
-                    pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
-                    pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
-                    pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
-                    vError = XMVectorMultiply(vError, g_ErrorWeight7);
-                }
-                else
-                {
-                    // Applied ordered dither
-                    target = XMVectorAdd(v, ordered[index & 3]);
-                    target = XMVectorRound(target);
-                }
-
-                target = XMVectorClamp(target, g_XMZero, g_Scale8pc);
-
-                XMFLOAT4A tmp;
-                XMStoreFloat4A(&tmp, target);
-
-                auto dPtr = &dest[index];
-                if (dPtr >= ePtr) break;
-                dPtr->x = uint8_t(static_cast<uint8_t>(tmp.x) & 0xFF);
-                dPtr->y = uint8_t(static_cast<uint8_t>(tmp.y) & 0xFF);
-                dPtr->z = uint8_t(static_cast<uint8_t>(tmp.z) & 0xFF);
-                dPtr->w = 0;
-            }
-            return true;
-        }
-        return false;
-
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-        STORE_SCANLINE(XMUNIBBLE4, g_Scale4pc, true, true, uint8_t, 0xF, y, true)
-
-    case XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM:
-        STORE_SCANLINE(XMXDECN4, g_Scale9pc, false, true, uint16_t, 0x3FF, y, false)
-
-    case XBOX_DXGI_FORMAT_R4G4_UNORM:
-        if (size >= sizeof(uint8_t))
-        {
-            uint8_t * __restrict dest = static_cast<uint8_t*>(pDestination);
-            for (size_t i = 0; i < count; ++i)
-            {
-                auto index = static_cast<ptrdiff_t>((y & 1) ? (count - i - 1) : i);
-                ptrdiff_t delta = (y & 1) ? -2 : 0;
-
-                XMVECTOR v = XMVectorSaturate(sPtr[index]);
-                v = XMVectorAdd(v, vError);
-                v = XMVectorMultiply(v, g_Scale4pc);
-
-                XMVECTOR target;
-                if (pDiffusionErrors)
-                {
-                    target = XMVectorRound(v);
-                    vError = XMVectorSubtract(v, target);
-                    vError = XMVectorDivide(vError, g_Scale4pc);
-
-                    // Distribute error to next scanline and next pixel
-                    pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
-                    pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
-                    pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
-                    vError = XMVectorMultiply(vError, g_ErrorWeight7);
-                }
-                else
-                {
-                    // Applied ordered dither
-                    target = XMVectorAdd(v, ordered[index & 3]);
-                    target = XMVectorRound(target);
-                }
-
-                target = XMVectorClamp(target, g_XMZero, g_Scale4pc);
-
-                XMFLOAT4A tmp;
-                XMStoreFloat4A(&tmp, target);
-
-                auto dPtr = &dest[index];
-                if (dPtr >= ePtr) break;
-                *dPtr = static_cast<uint8_t>((unsigned(tmp.x) & 0xF) | ((unsigned(tmp.y) & 0xF) << 4));
-            }
-            return true;
-        }
-        return false;
-
-    default:
-        return StoreScanline(pDestination, size, format, pSource, count, threshold);
-    }
-}
-
-#pragma warning(pop)
-
-#undef STORE_SCANLINE
-#undef STORE_SCANLINE2
-#undef STORE_SCANLINE1
-
-namespace
-{
-    //-------------------------------------------------------------------------------------
-    // Selection logic for using WIC vs. our own routines
-    //-------------------------------------------------------------------------------------
-    inline bool UseWICConversion(
-        _In_ TEX_FILTER_FLAGS filter,
-        _In_ DXGI_FORMAT sformat,
-        _In_ DXGI_FORMAT tformat,
-        _Out_ WICPixelFormatGUID& pfGUID,
-        _Out_ WICPixelFormatGUID& targetGUID) noexcept
-    {
-    #ifndef _WIN32
-        UNREFERENCED_PARAMETER(filter);
-        UNREFERENCED_PARAMETER(sformat);
-        UNREFERENCED_PARAMETER(tformat);
-        UNREFERENCED_PARAMETER(pfGUID);
-        UNREFERENCED_PARAMETER(targetGUID);
-        return false;
-    #else
-        memset(&pfGUID, 0, sizeof(GUID));
-        memset(&targetGUID, 0, sizeof(GUID));
-
-        if (filter & TEX_FILTER_FORCE_NON_WIC)
-        {
-            // Explicit flag indicates use of non-WIC code paths
-            return false;
-        }
-
-        if (!DXGIToWIC(sformat, pfGUID) || !DXGIToWIC(tformat, targetGUID))
-        {
-            // Source or target format are not WIC supported native pixel formats
-            return false;
-        }
-
-        if (filter & TEX_FILTER_FORCE_WIC)
-        {
-            // Explicit flag to use WIC code paths, skips all the case checks below
-            return true;
-        }
-
-        if (filter & TEX_FILTER_SEPARATE_ALPHA)
-        {
-            // Alpha is not premultiplied, so use non-WIC code paths
-            return false;
-        }
-
-        if (filter & TEX_FILTER_FLOAT_X2BIAS)
-        {
-            // X2 Scale & Bias conversions not supported by WIC code paths
-            return false;
-        }
-
-        // Check for special cases
-    #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
-        if (sformat == DXGI_FORMAT_R16G16B16A16_FLOAT
-            || sformat == DXGI_FORMAT_R16_FLOAT
-            || tformat == DXGI_FORMAT_R16G16B16A16_FLOAT
-            || tformat == DXGI_FORMAT_R16_FLOAT)
-        {
-            // Use non-WIC code paths as these conversions are not supported by Xbox version of WIC
-            return false;
-        }
-    #endif
-
-        switch (sformat)
-        {
-        case DXGI_FORMAT_R32G32B32A32_FLOAT:
-        case DXGI_FORMAT_R32G32B32_FLOAT:
-        case DXGI_FORMAT_R32G32_FLOAT:
-        case DXGI_FORMAT_R32_FLOAT:
-        case DXGI_FORMAT_D32_FLOAT:
-            switch (tformat)
-            {
-            case DXGI_FORMAT_R16G16B16A16_FLOAT:
-            case DXGI_FORMAT_R16G16_FLOAT:
-            case DXGI_FORMAT_R16_FLOAT:
-                // WIC conversions for FP32->FP16 can result in NaN values instead of clamping for min/max value
-                return false;
-
-            default:
-                break;
-            }
-            break;
-
-        default:
-            break;
-        }
-
-        switch (sformat)
-        {
-        case DXGI_FORMAT_R32G32B32A32_FLOAT:
-        case DXGI_FORMAT_R32G32B32_FLOAT:
-        case DXGI_FORMAT_R16G16B16A16_FLOAT:
-            switch (tformat)
-            {
-            case DXGI_FORMAT_R16_FLOAT:
-            case DXGI_FORMAT_R32_FLOAT:
-            case DXGI_FORMAT_D32_FLOAT:
-                // WIC converts via UNORM formats and ends up converting colorspaces for these cases
-            case DXGI_FORMAT_A8_UNORM:
-                // Conversion logic for these kinds of textures is unintuitive for WIC code paths
-                return false;
-
-            default:
-                break;
-            }
-            break;
-
-        case DXGI_FORMAT_R16_FLOAT:
-            switch (tformat)
-            {
-            case DXGI_FORMAT_R32_FLOAT:
-            case DXGI_FORMAT_D32_FLOAT:
-                // WIC converts via UNORM formats and ends up converting colorspaces for these cases
-            case DXGI_FORMAT_A8_UNORM:
-                // Conversion logic for these kinds of textures is unintuitive for WIC code paths
-                return false;
-
-            default:
-                break;
-            }
-            break;
-
-        case DXGI_FORMAT_A8_UNORM:
-            // Conversion logic for these kinds of textures is unintuitive for WIC code paths
-            return false;
-
-        default:
-            switch (tformat)
-            {
-            case DXGI_FORMAT_A8_UNORM:
-                // Conversion logic for these kinds of textures is unintuitive for WIC code paths
-                return false;
-
-            default:
-                break;
-            }
-        }
-
-        // Check for implicit color space changes
-        if (IsSRGB(sformat))
-            filter |= TEX_FILTER_SRGB_IN;
-
-        if (IsSRGB(tformat))
-            filter |= TEX_FILTER_SRGB_OUT;
-
-        if ((filter & (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT)) == (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT))
-        {
-            filter &= ~(TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT);
-        }
-
-        auto const wicsrgb = CheckWICColorSpace(pfGUID, targetGUID);
-
-        if (wicsrgb != (filter & (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT)))
-        {
-            // WIC will perform a colorspace conversion we didn't request
-            return false;
-        }
-
-        return true;
-    #endif // WIN32
-    }
-
-    //-------------------------------------------------------------------------------------
-    // Convert the source image using WIC
-    //-------------------------------------------------------------------------------------
-    HRESULT ConvertUsingWIC(
-        _In_ const Image& srcImage,
-        _In_ const WICPixelFormatGUID& pfGUID,
-        _In_ const WICPixelFormatGUID& targetGUID,
-        _In_ TEX_FILTER_FLAGS filter,
-        _In_ float threshold,
-        _In_ const Image& destImage)
-    {
-    #ifndef _WIN32
-        UNREFERENCED_PARAMETER(srcImage);
-        UNREFERENCED_PARAMETER(pfGUID);
-        UNREFERENCED_PARAMETER(targetGUID);
-        UNREFERENCED_PARAMETER(filter);
-        UNREFERENCED_PARAMETER(threshold);
-        UNREFERENCED_PARAMETER(destImage);
-        return E_NOTIMPL;
-    #else
-        assert(srcImage.width == destImage.width);
-        assert(srcImage.height == destImage.height);
-
-        bool iswic2 = false;
-        auto pWIC = GetWICFactory(iswic2);
-        if (!pWIC)
-            return E_NOINTERFACE;
-
-        ComPtr<IWICFormatConverter> FC;
-        HRESULT hr = pWIC->CreateFormatConverter(FC.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        // Note that WIC conversion ignores the TEX_FILTER_SRGB_IN and TEX_FILTER_SRGB_OUT flags,
-        // but also always assumes UNORM <-> FLOAT conversions are changing color spaces sRGB <-> scRGB
-
-        BOOL canConvert = FALSE;
-        hr = FC->CanConvert(pfGUID, targetGUID, &canConvert);
-        if (FAILED(hr) || !canConvert)
-        {
-            // This case is not an issue for the subset of WIC formats that map directly to DXGI
-            return E_UNEXPECTED;
-        }
-
-        if (srcImage.rowPitch > UINT32_MAX || srcImage.slicePitch > UINT32_MAX
-            || destImage.rowPitch > UINT32_MAX || destImage.slicePitch > UINT32_MAX)
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-        ComPtr<IWICBitmap> source;
-        hr = pWIC->CreateBitmapFromMemory(static_cast<UINT>(srcImage.width), static_cast<UINT>(srcImage.height), pfGUID,
-            static_cast<UINT>(srcImage.rowPitch), static_cast<UINT>(srcImage.slicePitch),
-            srcImage.pixels, source.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        hr = FC->Initialize(source.Get(), targetGUID, GetWICDither(filter), nullptr,
-            static_cast<double>(threshold) * 100.0, WICBitmapPaletteTypeMedianCut);
-        if (FAILED(hr))
-            return hr;
-
-        hr = FC->CopyPixels(nullptr, static_cast<UINT>(destImage.rowPitch), static_cast<UINT>(destImage.slicePitch), destImage.pixels);
-        if (FAILED(hr))
-            return hr;
-
-        return S_OK;
-    #endif // WIN32
-    }
-
-    //-------------------------------------------------------------------------------------
-    // Convert the source image (not using WIC)
-    //-------------------------------------------------------------------------------------
-    HRESULT ConvertCustom(
-        _In_ const Image& srcImage,
-        _In_ TEX_FILTER_FLAGS filter,
-        _In_ const Image& destImage,
-        _In_ float threshold,
-        size_t z) noexcept
-    {
-        assert(srcImage.width == destImage.width);
-        assert(srcImage.height == destImage.height);
-
-        const uint8_t *pSrc = srcImage.pixels;
-        uint8_t *pDest = destImage.pixels;
-        if (!pSrc || !pDest)
-            return E_POINTER;
-
-        size_t width = srcImage.width;
-
-        if (filter & TEX_FILTER_DITHER_DIFFUSION)
-        {
-            // Error diffusion dithering (aka Floyd-Steinberg dithering)
-            auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 2 + 2);
-            if (!scanline)
-                return E_OUTOFMEMORY;
-
-            XMVECTOR* pDiffusionErrors = scanline.get() + width;
-            memset(pDiffusionErrors, 0, sizeof(XMVECTOR)*(width + 2));
-
-            for (size_t h = 0; h < srcImage.height; ++h)
-            {
-                if (!LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
-                    return E_FAIL;
-
-                ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
-
-                if (!StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, pDiffusionErrors))
-                    return E_FAIL;
-
-                pSrc += srcImage.rowPitch;
-                pDest += destImage.rowPitch;
-            }
-        }
-        else
-        {
-            auto scanline = make_AlignedArrayXMVECTOR(width);
-            if (!scanline)
-                return E_OUTOFMEMORY;
-
-            if (filter & TEX_FILTER_DITHER)
-            {
-                // Ordered dithering
-                for (size_t h = 0; h < srcImage.height; ++h)
-                {
-                    if (!LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
-                        return E_FAIL;
-
-                    ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
-
-                    if (!StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, nullptr))
-                        return E_FAIL;
-
-                    pSrc += srcImage.rowPitch;
-                    pDest += destImage.rowPitch;
-                }
-            }
-            else
-            {
-                // No dithering
-                for (size_t h = 0; h < srcImage.height; ++h)
-                {
-                    if (!LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
-                        return E_FAIL;
-
-                    ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
-
-                    if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold))
-                        return E_FAIL;
-
-                    pSrc += srcImage.rowPitch;
-                    pDest += destImage.rowPitch;
-                }
-            }
-        }
-
-        return S_OK;
-    }
-
-    //-------------------------------------------------------------------------------------
-    DXGI_FORMAT PlanarToSingle(_In_ DXGI_FORMAT format) noexcept
-    {
-        switch (format)
-        {
-        case DXGI_FORMAT_NV12:
-        case DXGI_FORMAT_NV11:
-            return DXGI_FORMAT_YUY2;
-
-        case DXGI_FORMAT_P010:
-            return DXGI_FORMAT_Y210;
-
-        case DXGI_FORMAT_P016:
-            return DXGI_FORMAT_Y216;
-
-            // We currently do not support conversion for Xbox One specific 16-bit depth formats
-
-            // We can't do anything with DXGI_FORMAT_420_OPAQUE because it's an opaque blob of bits
-
-            // We don't support conversion of JPEG Hardware decode formats
-
-        default:
-            return DXGI_FORMAT_UNKNOWN;
-        }
-    }
-
-    //-------------------------------------------------------------------------------------
-    // Convert the image from a planar to non-planar image
-    //-------------------------------------------------------------------------------------
-#define CONVERT_420_TO_422( srcType, destType )\
-        {\
-            const size_t rowPitch = srcImage.rowPitch;\
-            \
-            auto const sourceE = reinterpret_cast<const srcType*>(pSrc + srcImage.slicePitch);\
-            auto pSrcUV = pSrc + (srcImage.height * rowPitch);\
-            \
-            for(size_t y = 0; y < srcImage.height; y+= 2)\
-            {\
-                auto sPtrY0 = reinterpret_cast<const srcType*>(pSrc);\
-                auto sPtrY2 = reinterpret_cast<const srcType*>(pSrc + rowPitch);\
-                auto sPtrUV = reinterpret_cast<const srcType*>(pSrcUV);\
-                \
-                destType * __restrict dPtr0 = reinterpret_cast<destType*>(pDest);\
-                destType * __restrict dPtr1 = reinterpret_cast<destType*>(pDest + destImage.rowPitch);\
-                \
-                for(size_t x = 0; x < srcImage.width; x+= 2)\
-                {\
-                    if ((sPtrUV+1) >= sourceE) break;\
-                    \
-                    const srcType u = *(sPtrUV++);\
-                    const srcType v = *(sPtrUV++);\
-                    \
-                    dPtr0->x = *(sPtrY0++);\
-                    dPtr0->y = u;\
-                    dPtr0->z = *(sPtrY0++);\
-                    dPtr0->w = v;\
-                    ++dPtr0;\
-                    \
-                    dPtr1->x = *(sPtrY2++);\
-                    dPtr1->y = u;\
-                    dPtr1->z = *(sPtrY2++);\
-                    dPtr1->w = v;\
-                    ++dPtr1;\
-                }\
-                \
-                pSrc += rowPitch * 2;\
-                pSrcUV += rowPitch;\
-                \
-                pDest += destImage.rowPitch * 2;\
-            }\
-        }
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wextra-semi-stmt"
-#endif
-
-    HRESULT ConvertToSinglePlane_(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept
-    {
-        assert(srcImage.width == destImage.width);
-        assert(srcImage.height == destImage.height);
-
-        const uint8_t *pSrc = srcImage.pixels;
-        uint8_t *pDest = destImage.pixels;
-        if (!pSrc || !pDest)
-            return E_POINTER;
-
-        switch (srcImage.format)
-        {
-        case DXGI_FORMAT_NV12:
-            assert(destImage.format == DXGI_FORMAT_YUY2);
-            CONVERT_420_TO_422(uint8_t, XMUBYTEN4);
-            return S_OK;
-
-        case DXGI_FORMAT_P010:
-            assert(destImage.format == DXGI_FORMAT_Y210);
-            CONVERT_420_TO_422(uint16_t, XMUSHORTN4);
-            return S_OK;
-
-        case DXGI_FORMAT_P016:
-            assert(destImage.format == DXGI_FORMAT_Y216);
-            CONVERT_420_TO_422(uint16_t, XMUSHORTN4);
-            return S_OK;
-
-        case DXGI_FORMAT_NV11:
-            assert(destImage.format == DXGI_FORMAT_YUY2);
-            // Convert 4:1:1 to 4:2:2
-            {
-                const size_t rowPitch = srcImage.rowPitch;
-
-                const uint8_t* sourceE = pSrc + srcImage.slicePitch;
-                const uint8_t* pSrcUV = pSrc + (srcImage.height * rowPitch);
-
-                for (size_t y = 0; y < srcImage.height; ++y)
-                {
-                    const uint8_t* sPtrY = pSrc;
-                    const uint8_t* sPtrUV = pSrcUV;
-
-                    XMUBYTEN4 * __restrict dPtr = reinterpret_cast<XMUBYTEN4*>(pDest);
-
-                    for (size_t x = 0; x < srcImage.width; x += 4)
-                    {
-                        if ((sPtrUV + 1) >= sourceE) break;
-
-                        const uint8_t u = *(sPtrUV++);
-                        const uint8_t v = *(sPtrUV++);
-
-                        dPtr->x = *(sPtrY++);
-                        dPtr->y = u;
-                        dPtr->z = *(sPtrY++);
-                        dPtr->w = v;
-                        ++dPtr;
-
-                        dPtr->x = *(sPtrY++);
-                        dPtr->y = u;
-                        dPtr->z = *(sPtrY++);
-                        dPtr->w = v;
-                        ++dPtr;
-                    }
-
-                    pSrc += rowPitch;
-                    pSrcUV += (rowPitch >> 1);
-
-                    pDest += destImage.rowPitch;
-                }
-            }
-            return S_OK;
-
-        default:
-            return E_UNEXPECTED;
-        }
-    }
-
-#undef CONVERT_420_TO_422
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Convert image
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::Convert(
-    const Image& srcImage,
-    DXGI_FORMAT format,
-    TEX_FILTER_FLAGS filter,
-    float threshold,
-    ScratchImage& image) noexcept
-{
-    if ((srcImage.format == format) || !IsValid(format))
-        return E_INVALIDARG;
-
-    if (!srcImage.pixels)
-        return E_POINTER;
-
-    if (IsCompressed(srcImage.format) || IsCompressed(format)
-        || IsPlanar(srcImage.format) || IsPlanar(format)
-        || IsPalettized(srcImage.format) || IsPalettized(format)
-        || IsTypeless(srcImage.format) || IsTypeless(format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if ((srcImage.width > UINT32_MAX) || (srcImage.height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    HRESULT hr = image.Initialize2D(format, srcImage.width, srcImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *rimage = image.GetImage(0, 0, 0);
-    if (!rimage)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    WICPixelFormatGUID pfGUID, targetGUID;
-    if (UseWICConversion(filter, srcImage.format, format, pfGUID, targetGUID))
-    {
-        hr = ConvertUsingWIC(srcImage, pfGUID, targetGUID, filter, threshold, *rimage);
-    }
-    else
-    {
-        hr = ConvertCustom(srcImage, filter, *rimage, threshold, 0);
-    }
-
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Convert image (complex)
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::Convert(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    DXGI_FORMAT format,
-    TEX_FILTER_FLAGS filter,
-    float threshold,
-    ScratchImage& result) noexcept
-{
-    if (!srcImages || !nimages || (metadata.format == format) || !IsValid(format))
-        return E_INVALIDARG;
-
-    if (IsCompressed(metadata.format) || IsCompressed(format)
-        || IsPlanar(metadata.format) || IsPlanar(format)
-        || IsPalettized(metadata.format) || IsPalettized(format)
-        || IsTypeless(metadata.format) || IsTypeless(format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if ((metadata.width > UINT32_MAX) || (metadata.height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    TexMetadata mdata2 = metadata;
-    mdata2.format = format;
-    HRESULT hr = result.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != result.GetImageCount())
-    {
-        result.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = result.GetImages();
-    if (!dest)
-    {
-        result.Release();
-        return E_POINTER;
-    }
-
-    WICPixelFormatGUID pfGUID, targetGUID;
-    const bool usewic = !metadata.IsPMAlpha() && UseWICConversion(filter, metadata.format, format, pfGUID, targetGUID);
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-    case TEX_DIMENSION_TEXTURE2D:
-        for (size_t index = 0; index < nimages; ++index)
-        {
-            const Image& src = srcImages[index];
-            if (src.format != metadata.format)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            const Image& dst = dest[index];
-            assert(dst.format == format);
-
-            if (src.width != dst.width || src.height != dst.height)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            if (usewic)
-            {
-                hr = ConvertUsingWIC(src, pfGUID, targetGUID, filter, threshold, dst);
-            }
-            else
-            {
-                hr = ConvertCustom(src, filter, dst, threshold, 0);
-            }
-
-            if (FAILED(hr))
-            {
-                result.Release();
-                return hr;
-            }
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        {
-            size_t index = 0;
-            size_t d = metadata.depth;
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                for (size_t slice = 0; slice < d; ++slice, ++index)
-                {
-                    if (index >= nimages)
-                    {
-                        result.Release();
-                        return E_FAIL;
-                    }
-
-                    const Image& src = srcImages[index];
-                    if (src.format != metadata.format)
-                    {
-                        result.Release();
-                        return E_FAIL;
-                    }
-
-                    if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
-                    {
-                        result.Release();
-                        return E_FAIL;
-                    }
-
-                    const Image& dst = dest[index];
-                    assert(dst.format == format);
-
-                    if (src.width != dst.width || src.height != dst.height)
-                    {
-                        result.Release();
-                        return E_FAIL;
-                    }
-
-                    if (usewic)
-                    {
-                        hr = ConvertUsingWIC(src, pfGUID, targetGUID, filter, threshold, dst);
-                    }
-                    else
-                    {
-                        hr = ConvertCustom(src, filter, dst, threshold, slice);
-                    }
-
-                    if (FAILED(hr))
-                    {
-                        result.Release();
-                        return hr;
-                    }
-                }
-
-                if (d > 1)
-                    d >>= 1;
-            }
-        }
-        break;
-
-    default:
-        result.Release();
-        return E_FAIL;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Convert image from planar to single plane (image)
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::ConvertToSinglePlane(const Image& srcImage, ScratchImage& image) noexcept
-{
-    if (!IsPlanar(srcImage.format))
-        return E_INVALIDARG;
-
-    if (!srcImage.pixels)
-        return E_POINTER;
-
-    const DXGI_FORMAT format = PlanarToSingle(srcImage.format);
-    if (format == DXGI_FORMAT_UNKNOWN)
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if ((srcImage.width > UINT32_MAX) || (srcImage.height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    HRESULT hr = image.Initialize2D(format, srcImage.width, srcImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *rimage = image.GetImage(0, 0, 0);
-    if (!rimage)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    hr = ConvertToSinglePlane_(srcImage, *rimage);
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Convert image from planar to single plane (complex)
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::ConvertToSinglePlane(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    ScratchImage& result) noexcept
-{
-    if (!srcImages || !nimages)
-        return E_INVALIDARG;
-
-    if (metadata.IsVolumemap())
-    {
-        // Direct3D does not support any planar formats for Texture3D
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    const DXGI_FORMAT format = PlanarToSingle(metadata.format);
-    if (format == DXGI_FORMAT_UNKNOWN)
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if ((metadata.width > UINT32_MAX) || (metadata.height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    TexMetadata mdata2 = metadata;
-    mdata2.format = format;
-    HRESULT hr = result.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != result.GetImageCount())
-    {
-        result.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = result.GetImages();
-    if (!dest)
-    {
-        result.Release();
-        return E_POINTER;
-    }
-
-    for (size_t index = 0; index < nimages; ++index)
-    {
-        const Image& src = srcImages[index];
-        if (src.format != metadata.format)
-        {
-            result.Release();
-            return E_FAIL;
-        }
-
-        if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
-            return E_FAIL;
-
-        const Image& dst = dest[index];
-        assert(dst.format == format);
-
-        if (src.width != dst.width || src.height != dst.height)
-        {
-            result.Release();
-            return E_FAIL;
-        }
-
-        hr = ConvertToSinglePlane_(src, dst);
-        if (FAILED(hr))
-        {
-            result.Release();
-            return hr;
-        }
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Returns the data type of a DXGI_FORMAT
-//-------------------------------------------------------------------------------------
-DirectX::FORMAT_TYPE DirectX::FormatDataType(_In_ DXGI_FORMAT fmt) noexcept
-{
-    const auto cflags = GetConvertFlags(fmt);
-
-    switch (cflags & (CONVF_FLOAT | CONVF_UNORM | CONVF_UINT | CONVF_SNORM | CONVF_SINT))
-    {
-    case CONVF_FLOAT:
-        return FORMAT_TYPE_FLOAT;
-
-    case CONVF_UNORM:
-        return FORMAT_TYPE_UNORM;
-
-    case CONVF_UINT:
-        return FORMAT_TYPE_UINT;
-
-    case CONVF_SNORM:
-        return FORMAT_TYPE_SNORM;
-
-    case CONVF_SINT:
-        return FORMAT_TYPE_SINT;
-
-    default:
-        return FORMAT_TYPE_TYPELESS;
-    }
-}
diff --git a/thirdparty/directxtex/DirectXTexD3D11.cpp b/thirdparty/directxtex/DirectXTexD3D11.cpp
deleted file mode 100644
index 555e1ce..0000000
--- a/thirdparty/directxtex/DirectXTexD3D11.cpp
+++ /dev/null
@@ -1,987 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexD3D11.cpp
-//
-// DirectX Texture Library - Direct3D 11 helpers
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#ifdef _GAMING_XBOX
-#error This module is not supported for GDK
-#elif !defined(_XBOX_ONE) || !defined(_TITLE)
-#include <d3d10.h>
-#endif
-
-#ifndef IID_GRAPHICS_PPV_ARGS
-#define IID_GRAPHICS_PPV_ARGS(x) IID_PPV_ARGS(x)
-#endif
-
-using namespace DirectX;
-using Microsoft::WRL::ComPtr;
-
-static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE1D) == static_cast<int>(D3D11_RESOURCE_DIMENSION_TEXTURE1D), "header enum mismatch");
-static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE2D) == static_cast<int>(D3D11_RESOURCE_DIMENSION_TEXTURE2D), "header enum mismatch");
-static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE3D) == static_cast<int>(D3D11_RESOURCE_DIMENSION_TEXTURE3D), "header enum mismatch");
-
-namespace
-{
-    HRESULT Capture(
-        _In_ ID3D11DeviceContext* pContext,
-        _In_ ID3D11Resource* pSource,
-        const TexMetadata& metadata,
-        const ScratchImage& result) noexcept
-    {
-        if (!pContext || !pSource || !result.GetPixels())
-            return E_POINTER;
-
-    #if defined(_XBOX_ONE) && defined(_TITLE)
-
-        ComPtr<ID3D11Device> d3dDevice;
-        pContext->GetDevice(d3dDevice.GetAddressOf());
-
-        if (d3dDevice->GetCreationFlags() & D3D11_CREATE_DEVICE_IMMEDIATE_CONTEXT_FAST_SEMANTICS)
-        {
-            ComPtr<ID3D11DeviceX> d3dDeviceX;
-            HRESULT hr = d3dDevice.As(&d3dDeviceX);
-            if (FAILED(hr))
-                return hr;
-
-            ComPtr<ID3D11DeviceContextX> d3dContextX;
-            hr = pContext->QueryInterface(IID_GRAPHICS_PPV_ARGS(d3dContextX.GetAddressOf()));
-            if (FAILED(hr))
-                return hr;
-
-            UINT64 copyFence = d3dContextX->InsertFence(0);
-
-            while (d3dDeviceX->IsFencePending(copyFence))
-            {
-                SwitchToThread();
-            }
-        }
-
-    #endif
-
-        if (metadata.IsVolumemap())
-        {
-            //--- Volume texture ----------------------------------------------------------
-            assert(metadata.arraySize == 1);
-
-            size_t height = metadata.height;
-            size_t depth = metadata.depth;
-
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                const UINT dindex = D3D11CalcSubresource(static_cast<UINT>(level), 0, static_cast<UINT>(metadata.mipLevels));
-
-                D3D11_MAPPED_SUBRESOURCE mapped;
-                HRESULT hr = pContext->Map(pSource, dindex, D3D11_MAP_READ, 0, &mapped);
-                if (FAILED(hr))
-                    return hr;
-
-                auto pslice = static_cast<const uint8_t*>(mapped.pData);
-                if (!pslice)
-                {
-                    pContext->Unmap(pSource, dindex);
-                    return E_POINTER;
-                }
-
-                const size_t lines = ComputeScanlines(metadata.format, height);
-                if (!lines)
-                {
-                    pContext->Unmap(pSource, dindex);
-                    return E_UNEXPECTED;
-                }
-
-                for (size_t slice = 0; slice < depth; ++slice)
-                {
-                    const Image* img = result.GetImage(level, 0, slice);
-                    if (!img)
-                    {
-                        pContext->Unmap(pSource, dindex);
-                        return E_FAIL;
-                    }
-
-                    if (!img->pixels)
-                    {
-                        pContext->Unmap(pSource, dindex);
-                        return E_POINTER;
-                    }
-
-                    const uint8_t* sptr = pslice;
-                    uint8_t* dptr = img->pixels;
-                    for (size_t h = 0; h < lines; ++h)
-                    {
-                        const size_t msize = std::min<size_t>(img->rowPitch, mapped.RowPitch);
-                        memcpy(dptr, sptr, msize);
-                        sptr += mapped.RowPitch;
-                        dptr += img->rowPitch;
-                    }
-
-                    pslice += mapped.DepthPitch;
-                }
-
-                pContext->Unmap(pSource, dindex);
-
-                if (height > 1)
-                    height >>= 1;
-                if (depth > 1)
-                    depth >>= 1;
-            }
-        }
-        else
-        {
-            //--- 1D or 2D texture --------------------------------------------------------
-            assert(metadata.depth == 1);
-
-            for (size_t item = 0; item < metadata.arraySize; ++item)
-            {
-                size_t height = metadata.height;
-
-                for (size_t level = 0; level < metadata.mipLevels; ++level)
-                {
-                    const UINT dindex = D3D11CalcSubresource(static_cast<UINT>(level), static_cast<UINT>(item), static_cast<UINT>(metadata.mipLevels));
-
-                    D3D11_MAPPED_SUBRESOURCE mapped;
-                    HRESULT hr = pContext->Map(pSource, dindex, D3D11_MAP_READ, 0, &mapped);
-                    if (FAILED(hr))
-                        return hr;
-
-                    const Image* img = result.GetImage(level, item, 0);
-                    if (!img)
-                    {
-                        pContext->Unmap(pSource, dindex);
-                        return E_FAIL;
-                    }
-
-                    if (!img->pixels)
-                    {
-                        pContext->Unmap(pSource, dindex);
-                        return E_POINTER;
-                    }
-
-                    const size_t lines = ComputeScanlines(metadata.format, height);
-                    if (!lines)
-                    {
-                        pContext->Unmap(pSource, dindex);
-                        return E_UNEXPECTED;
-                    }
-
-                    const size_t msize = (metadata.dimension == TEX_DIMENSION_TEXTURE2D)
-                        ? std::min<size_t>(img->rowPitch, mapped.RowPitch) : img->rowPitch;
-
-                    auto sptr = static_cast<const uint8_t*>(mapped.pData);
-                    uint8_t* dptr = img->pixels;
-                    for (size_t h = 0; h < lines; ++h)
-                    {
-                        memcpy(dptr, sptr, msize);
-                        sptr += mapped.RowPitch;
-                        dptr += img->rowPitch;
-                    }
-
-                    pContext->Unmap(pSource, dindex);
-
-                    if (height > 1)
-                        height >>= 1;
-                }
-            }
-        }
-
-        return S_OK;
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Determine if given texture metadata is supported on the given device
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::IsSupportedTexture(
-    ID3D11Device* pDevice,
-    const TexMetadata& metadata) noexcept
-{
-    if (!pDevice)
-        return false;
-
-    const D3D_FEATURE_LEVEL fl = pDevice->GetFeatureLevel();
-
-    // Validate format
-    const DXGI_FORMAT fmt = metadata.format;
-
-    if (!IsValid(fmt))
-        return false;
-
-    switch (fmt)
-    {
-    case DXGI_FORMAT_BC4_TYPELESS:
-    case DXGI_FORMAT_BC4_UNORM:
-    case DXGI_FORMAT_BC4_SNORM:
-    case DXGI_FORMAT_BC5_TYPELESS:
-    case DXGI_FORMAT_BC5_UNORM:
-    case DXGI_FORMAT_BC5_SNORM:
-        if (fl < D3D_FEATURE_LEVEL_10_0)
-            return false;
-        break;
-
-    case DXGI_FORMAT_BC6H_TYPELESS:
-    case DXGI_FORMAT_BC6H_UF16:
-    case DXGI_FORMAT_BC6H_SF16:
-    case DXGI_FORMAT_BC7_TYPELESS:
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        if (fl < D3D_FEATURE_LEVEL_11_0)
-            return false;
-        break;
-
-    default:
-        break;
-    }
-
-    // Validate miplevel count
-    if (metadata.mipLevels > D3D11_REQ_MIP_LEVELS)
-        return false;
-
-    // Validate array size, dimension, and width/height
-    const size_t arraySize = metadata.arraySize;
-    const size_t iWidth = metadata.width;
-    const size_t iHeight = metadata.height;
-    const size_t iDepth = metadata.depth;
-
-    // Most cases are known apriori based on feature level, but we use this for robustness to handle the few optional cases
-    UINT formatSupport = 0;
-    HRESULT hr = pDevice->CheckFormatSupport(fmt, &formatSupport);
-    if (FAILED(hr))
-    {
-        formatSupport = 0;
-    }
-
-    if (metadata.mipLevels > 1 && !(formatSupport & D3D11_FORMAT_SUPPORT_MIP))
-    {
-        return false;
-    }
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-        if (!(formatSupport & D3D11_FORMAT_SUPPORT_TEXTURE1D))
-            return false;
-
-        if ((arraySize > D3D11_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION)
-            || (iWidth > D3D11_REQ_TEXTURE1D_U_DIMENSION))
-            return false;
-
-        if (fl < D3D_FEATURE_LEVEL_11_0)
-        {
-            if ((arraySize > D3D10_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION)
-                || (iWidth > D3D10_REQ_TEXTURE1D_U_DIMENSION))
-                return false;
-
-            if (fl < D3D_FEATURE_LEVEL_10_0)
-            {
-                if ((arraySize > 1) || (iWidth > D3D_FL9_3_REQ_TEXTURE1D_U_DIMENSION))
-                    return false;
-
-                if ((fl < D3D_FEATURE_LEVEL_9_3) && (iWidth > D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION))
-                    return false;
-            }
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE2D:
-        if (metadata.IsCubemap())
-        {
-            if (!(formatSupport & D3D11_FORMAT_SUPPORT_TEXTURECUBE))
-                return false;
-
-            if ((arraySize > D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
-                || (iWidth > D3D11_REQ_TEXTURECUBE_DIMENSION)
-                || (iHeight > D3D11_REQ_TEXTURECUBE_DIMENSION))
-                return false;
-
-            if (fl < D3D_FEATURE_LEVEL_11_0)
-            {
-                if ((arraySize > D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
-                    || (iWidth > D3D10_REQ_TEXTURECUBE_DIMENSION)
-                    || (iHeight > D3D10_REQ_TEXTURECUBE_DIMENSION))
-                    return false;
-
-                if ((fl < D3D_FEATURE_LEVEL_10_1) && (arraySize != 6))
-                    return false;
-
-                if (fl < D3D_FEATURE_LEVEL_10_0)
-                {
-                    if ((iWidth > D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION)
-                        || (iHeight > D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION))
-                        return false;
-
-                    if ((fl < D3D_FEATURE_LEVEL_9_3)
-                        && ((iWidth > D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION)
-                            || (iHeight > D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION)))
-                        return false;
-                }
-            }
-        }
-        else // Not a cube map
-        {
-            if (!(formatSupport & D3D11_FORMAT_SUPPORT_TEXTURE2D))
-                return false;
-
-            if ((arraySize > D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
-                || (iWidth > D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION)
-                || (iHeight > D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION))
-                return false;
-
-            if (fl < D3D_FEATURE_LEVEL_11_0)
-            {
-                if ((arraySize > D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
-                    || (iWidth > D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION)
-                    || (iHeight > D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION))
-                    return false;
-
-                if (fl < D3D_FEATURE_LEVEL_10_0)
-                {
-                    if ((arraySize > 1)
-                        || (iWidth > D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION)
-                        || (iHeight > D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION))
-                        return false;
-
-                    if ((fl < D3D_FEATURE_LEVEL_9_3)
-                        && ((iWidth > D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION)
-                            || (iHeight > D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION)))
-                        return false;
-                }
-            }
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        if (!(formatSupport & D3D11_FORMAT_SUPPORT_TEXTURE3D))
-            return false;
-
-        if ((arraySize > 1)
-            || (iWidth > D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
-            || (iHeight > D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
-            || (iDepth > D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION))
-            return false;
-
-        if (fl < D3D_FEATURE_LEVEL_11_0)
-        {
-            if ((iWidth > D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
-                || (iHeight > D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
-                || (iDepth > D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION))
-                return false;
-
-            if (fl < D3D_FEATURE_LEVEL_10_0)
-            {
-                if ((iWidth > D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
-                    || (iHeight > D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
-                    || (iDepth > D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION))
-                    return false;
-            }
-        }
-        break;
-
-    default:
-        // Not a supported dimension
-        return false;
-    }
-
-    return true;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Create a texture resource
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::CreateTexture(
-    ID3D11Device* pDevice,
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    ID3D11Resource** ppResource) noexcept
-{
-    return CreateTextureEx(
-        pDevice, srcImages, nimages, metadata,
-        D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, CREATETEX_DEFAULT,
-        ppResource);
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::CreateTextureEx(
-    ID3D11Device* pDevice,
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    D3D11_USAGE usage,
-    unsigned int bindFlags,
-    unsigned int cpuAccessFlags,
-    unsigned int miscFlags,
-    CREATETEX_FLAGS flags,
-    ID3D11Resource** ppResource) noexcept
-{
-    if (!pDevice || !srcImages || !nimages || !ppResource)
-        return E_INVALIDARG;
-
-    *ppResource = nullptr;
-
-    if (!metadata.mipLevels || !metadata.arraySize)
-        return E_INVALIDARG;
-
-    if ((metadata.width > UINT32_MAX) || (metadata.height > UINT32_MAX)
-        || (metadata.mipLevels > UINT16_MAX) || (metadata.arraySize > UINT16_MAX))
-        return E_INVALIDARG;
-
-    std::unique_ptr<D3D11_SUBRESOURCE_DATA[]> initData(new (std::nothrow) D3D11_SUBRESOURCE_DATA[metadata.mipLevels * metadata.arraySize]);
-    if (!initData)
-        return E_OUTOFMEMORY;
-
-    // Fill out subresource array
-    if (metadata.IsVolumemap())
-    {
-        //--- Volume case -------------------------------------------------------------
-        if (!metadata.depth)
-            return E_INVALIDARG;
-
-        if (metadata.depth > UINT16_MAX)
-            return E_INVALIDARG;
-
-        if (metadata.arraySize > 1)
-            // Direct3D 11 doesn't support arrays of 3D textures
-            return HRESULT_E_NOT_SUPPORTED;
-
-        size_t depth = metadata.depth;
-
-        size_t idx = 0;
-        for (size_t level = 0; level < metadata.mipLevels; ++level)
-        {
-            const size_t index = metadata.ComputeIndex(level, 0, 0);
-            if (index >= nimages)
-                return E_FAIL;
-
-            const Image& img = srcImages[index];
-
-            if (img.format != metadata.format)
-                return E_FAIL;
-
-            if (!img.pixels)
-                return E_POINTER;
-
-            // Verify pixels in image 1 .. (depth-1) are exactly image->slicePitch apart
-            // For 3D textures, this relies on all slices of the same miplevel being continous in memory
-            // (this is how ScratchImage lays them out), which is why we just give the 0th slice to Direct3D 11
-            const uint8_t* pSlice = img.pixels + img.slicePitch;
-            for (size_t slice = 1; slice < depth; ++slice)
-            {
-                const size_t tindex = metadata.ComputeIndex(level, 0, slice);
-                if (tindex >= nimages)
-                    return E_FAIL;
-
-                const Image& timg = srcImages[tindex];
-
-                if (!timg.pixels)
-                    return E_POINTER;
-
-                if (timg.pixels != pSlice
-                    || timg.format != metadata.format
-                    || timg.rowPitch != img.rowPitch
-                    || timg.slicePitch != img.slicePitch)
-                    return E_FAIL;
-
-                pSlice = timg.pixels + img.slicePitch;
-            }
-
-            assert(idx < (metadata.mipLevels * metadata.arraySize));
-
-            initData[idx].pSysMem = img.pixels;
-            initData[idx].SysMemPitch = static_cast<DWORD>(img.rowPitch);
-            initData[idx].SysMemSlicePitch = static_cast<DWORD>(img.slicePitch);
-            ++idx;
-
-            if (depth > 1)
-                depth >>= 1;
-        }
-    }
-    else
-    {
-        //--- 1D or 2D texture case ---------------------------------------------------
-        size_t idx = 0;
-        for (size_t item = 0; item < metadata.arraySize; ++item)
-        {
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                const size_t index = metadata.ComputeIndex(level, item, 0);
-                if (index >= nimages)
-                    return E_FAIL;
-
-                const Image& img = srcImages[index];
-
-                if (img.format != metadata.format)
-                    return E_FAIL;
-
-                if (!img.pixels)
-                    return E_POINTER;
-
-                assert(idx < (metadata.mipLevels * metadata.arraySize));
-
-                initData[idx].pSysMem = img.pixels;
-                initData[idx].SysMemPitch = static_cast<DWORD>(img.rowPitch);
-                initData[idx].SysMemSlicePitch = static_cast<DWORD>(img.slicePitch);
-                ++idx;
-            }
-        }
-    }
-
-    // Create texture using static initialization data
-    HRESULT hr = E_UNEXPECTED;
-
-    DXGI_FORMAT format = metadata.format;
-    if (flags & CREATETEX_FORCE_SRGB)
-    {
-        format = MakeSRGB(format);
-    }
-    else if (flags & CREATETEX_IGNORE_SRGB)
-    {
-        format = MakeLinear(format);
-    }
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-        {
-            D3D11_TEXTURE1D_DESC desc = {};
-            desc.Width = static_cast<UINT>(metadata.width);
-            desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
-            desc.ArraySize = static_cast<UINT>(metadata.arraySize);
-            desc.Format = format;
-            desc.Usage = usage;
-            desc.BindFlags = bindFlags;
-            desc.CPUAccessFlags = cpuAccessFlags;
-            desc.MiscFlags = miscFlags & ~static_cast<uint32_t>(D3D11_RESOURCE_MISC_TEXTURECUBE);
-
-            hr = pDevice->CreateTexture1D(&desc, initData.get(), reinterpret_cast<ID3D11Texture1D**>(ppResource));
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE2D:
-        {
-            D3D11_TEXTURE2D_DESC desc = {};
-            desc.Width = static_cast<UINT>(metadata.width);
-            desc.Height = static_cast<UINT>(metadata.height);
-            desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
-            desc.ArraySize = static_cast<UINT>(metadata.arraySize);
-            desc.Format = format;
-            desc.SampleDesc.Count = 1;
-            desc.SampleDesc.Quality = 0;
-            desc.Usage = usage;
-            desc.BindFlags = bindFlags;
-            desc.CPUAccessFlags = cpuAccessFlags;
-            if (metadata.IsCubemap())
-                desc.MiscFlags = miscFlags | D3D11_RESOURCE_MISC_TEXTURECUBE;
-            else
-                desc.MiscFlags = miscFlags & ~static_cast<uint32_t>(D3D11_RESOURCE_MISC_TEXTURECUBE);
-
-            hr = pDevice->CreateTexture2D(&desc, initData.get(), reinterpret_cast<ID3D11Texture2D**>(ppResource));
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        {
-            D3D11_TEXTURE3D_DESC desc = {};
-            desc.Width = static_cast<UINT>(metadata.width);
-            desc.Height = static_cast<UINT>(metadata.height);
-            desc.Depth = static_cast<UINT>(metadata.depth);
-            desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
-            desc.Format = format;
-            desc.Usage = usage;
-            desc.BindFlags = bindFlags;
-            desc.CPUAccessFlags = cpuAccessFlags;
-            desc.MiscFlags = miscFlags & ~static_cast<uint32_t>(D3D11_RESOURCE_MISC_TEXTURECUBE);
-
-            hr = pDevice->CreateTexture3D(&desc, initData.get(), reinterpret_cast<ID3D11Texture3D**>(ppResource));
-        }
-        break;
-    }
-
-    return hr;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Create a shader resource view and associated texture
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::CreateShaderResourceView(
-    ID3D11Device* pDevice,
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    ID3D11ShaderResourceView** ppSRV) noexcept
-{
-    return CreateShaderResourceViewEx(
-        pDevice, srcImages, nimages, metadata,
-        D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, CREATETEX_DEFAULT,
-        ppSRV);
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::CreateShaderResourceViewEx(
-    ID3D11Device* pDevice,
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    D3D11_USAGE usage,
-    unsigned int bindFlags,
-    unsigned int cpuAccessFlags,
-    unsigned int miscFlags,
-    CREATETEX_FLAGS flags,
-    ID3D11ShaderResourceView** ppSRV) noexcept
-{
-    if (!ppSRV)
-        return E_INVALIDARG;
-
-    *ppSRV = nullptr;
-
-    if (!(bindFlags & D3D11_BIND_SHADER_RESOURCE))
-        return E_INVALIDARG;
-
-    ComPtr<ID3D11Resource> resource;
-    HRESULT hr = CreateTextureEx(pDevice, srcImages, nimages, metadata,
-        usage, bindFlags, cpuAccessFlags, miscFlags, flags,
-        resource.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    assert(resource);
-
-    D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc = {};
-    if (flags & CREATETEX_FORCE_SRGB)
-    {
-        SRVDesc.Format = MakeSRGB(metadata.format);
-    }
-    else if (flags & CREATETEX_IGNORE_SRGB)
-    {
-        SRVDesc.Format = MakeLinear(metadata.format);
-    }
-    else
-    {
-        SRVDesc.Format = metadata.format;
-    }
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-        if (metadata.arraySize > 1)
-        {
-            SRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE1DARRAY;
-            SRVDesc.Texture1DArray.MipLevels = static_cast<UINT>(metadata.mipLevels);
-            SRVDesc.Texture1DArray.ArraySize = static_cast<UINT>(metadata.arraySize);
-        }
-        else
-        {
-            SRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE1D;
-            SRVDesc.Texture1D.MipLevels = static_cast<UINT>(metadata.mipLevels);
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE2D:
-        if (metadata.IsCubemap())
-        {
-            if (metadata.arraySize > 6)
-            {
-                assert((metadata.arraySize % 6) == 0);
-                SRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURECUBEARRAY;
-                SRVDesc.TextureCubeArray.MipLevels = static_cast<UINT>(metadata.mipLevels);
-                SRVDesc.TextureCubeArray.NumCubes = static_cast<UINT>(metadata.arraySize / 6);
-            }
-            else
-            {
-                SRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURECUBE;
-                SRVDesc.TextureCube.MipLevels = static_cast<UINT>(metadata.mipLevels);
-            }
-        }
-        else if (metadata.arraySize > 1)
-        {
-            SRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2DARRAY;
-            SRVDesc.Texture2DArray.MipLevels = static_cast<UINT>(metadata.mipLevels);
-            SRVDesc.Texture2DArray.ArraySize = static_cast<UINT>(metadata.arraySize);
-        }
-        else
-        {
-            SRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2D;
-            SRVDesc.Texture2D.MipLevels = static_cast<UINT>(metadata.mipLevels);
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        assert(metadata.arraySize == 1);
-        SRVDesc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE3D;
-        SRVDesc.Texture3D.MipLevels = static_cast<UINT>(metadata.mipLevels);
-        break;
-
-    default:
-        return E_FAIL;
-    }
-
-    hr = pDevice->CreateShaderResourceView(resource.Get(), &SRVDesc, ppSRV);
-    if (FAILED(hr))
-        return hr;
-
-    assert(*ppSRV);
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a texture resource
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::CaptureTexture(
-    ID3D11Device* pDevice,
-    ID3D11DeviceContext* pContext,
-    ID3D11Resource* pSource,
-    ScratchImage& result) noexcept
-{
-    if (!pDevice || !pContext || !pSource)
-        return E_INVALIDARG;
-
-    D3D11_RESOURCE_DIMENSION resType = D3D11_RESOURCE_DIMENSION_UNKNOWN;
-    pSource->GetType(&resType);
-
-    HRESULT hr = E_UNEXPECTED;
-
-    switch (resType)
-    {
-    case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
-        {
-            ComPtr<ID3D11Texture1D> pTexture;
-            hr = pSource->QueryInterface(IID_GRAPHICS_PPV_ARGS(pTexture.GetAddressOf()));
-            if (FAILED(hr))
-                break;
-
-            assert(pTexture);
-
-            D3D11_TEXTURE1D_DESC desc;
-            pTexture->GetDesc(&desc);
-
-            ComPtr<ID3D11Texture1D> pStaging;
-            if ((desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
-            {
-                // Handle case where the source is already a staging texture we can use directly
-                pStaging = pTexture;
-            }
-            else
-            {
-                desc.BindFlags = 0;
-                desc.MiscFlags = 0;
-                desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-                desc.Usage = D3D11_USAGE_STAGING;
-
-                hr = pDevice->CreateTexture1D(&desc, nullptr, pStaging.GetAddressOf());
-                if (FAILED(hr))
-                    break;
-
-                assert(pStaging);
-
-                pContext->CopyResource(pStaging.Get(), pSource);
-            }
-
-            TexMetadata mdata;
-            mdata.width = desc.Width;
-            mdata.height = mdata.depth = 1;
-            mdata.arraySize = desc.ArraySize;
-            mdata.mipLevels = desc.MipLevels;
-            mdata.miscFlags = 0;
-            mdata.miscFlags2 = 0;
-            mdata.format = desc.Format;
-            mdata.dimension = TEX_DIMENSION_TEXTURE1D;
-
-            hr = result.Initialize(mdata);
-            if (FAILED(hr))
-                break;
-
-            hr = Capture(pContext, pStaging.Get(), mdata, result);
-        }
-        break;
-
-    case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
-        {
-            ComPtr<ID3D11Texture2D> pTexture;
-            hr = pSource->QueryInterface(IID_GRAPHICS_PPV_ARGS(pTexture.GetAddressOf()));
-            if (FAILED(hr))
-                break;
-
-            assert(pTexture);
-
-            D3D11_TEXTURE2D_DESC desc;
-            pTexture->GetDesc(&desc);
-
-            ComPtr<ID3D11Texture2D> pStaging;
-            if (desc.SampleDesc.Count > 1)
-            {
-                desc.SampleDesc.Count = 1;
-                desc.SampleDesc.Quality = 0;
-
-                ComPtr<ID3D11Texture2D> pTemp;
-                hr = pDevice->CreateTexture2D(&desc, nullptr, pTemp.GetAddressOf());
-                if (FAILED(hr))
-                    break;
-
-                assert(pTemp);
-
-                DXGI_FORMAT fmt = desc.Format;
-                if (IsTypeless(fmt))
-                {
-                    // Assume a UNORM if it exists otherwise use FLOAT
-                    fmt = MakeTypelessUNORM(fmt);
-                    fmt = MakeTypelessFLOAT(fmt);
-                }
-
-                UINT support = 0;
-                hr = pDevice->CheckFormatSupport(fmt, &support);
-                if (FAILED(hr))
-                    break;
-
-                if (!(support & D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE))
-                {
-                    hr = E_FAIL;
-                    break;
-                }
-
-                for (UINT item = 0; item < desc.ArraySize; ++item)
-                {
-                    for (UINT level = 0; level < desc.MipLevels; ++level)
-                    {
-                        const UINT index = D3D11CalcSubresource(level, item, desc.MipLevels);
-                        pContext->ResolveSubresource(pTemp.Get(), index, pSource, index, fmt);
-                    }
-                }
-
-                desc.BindFlags = 0;
-                desc.MiscFlags &= D3D11_RESOURCE_MISC_TEXTURECUBE;
-                desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-                desc.Usage = D3D11_USAGE_STAGING;
-
-                hr = pDevice->CreateTexture2D(&desc, nullptr, pStaging.GetAddressOf());
-                if (FAILED(hr))
-                    break;
-
-                assert(pStaging);
-
-                pContext->CopyResource(pStaging.Get(), pTemp.Get());
-            }
-            else if ((desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
-            {
-                // Handle case where the source is already a staging texture we can use directly
-                pStaging = pTexture;
-            }
-            else
-            {
-                desc.BindFlags = 0;
-                desc.MiscFlags &= D3D11_RESOURCE_MISC_TEXTURECUBE;
-                desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-                desc.Usage = D3D11_USAGE_STAGING;
-
-                hr = pDevice->CreateTexture2D(&desc, nullptr, &pStaging);
-                if (FAILED(hr))
-                    break;
-
-                assert(pStaging);
-
-                pContext->CopyResource(pStaging.Get(), pSource);
-            }
-
-            TexMetadata mdata;
-            mdata.width = desc.Width;
-            mdata.height = desc.Height;
-            mdata.depth = 1;
-            mdata.arraySize = desc.ArraySize;
-            mdata.mipLevels = desc.MipLevels;
-            mdata.miscFlags = (desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE) ? TEX_MISC_TEXTURECUBE : 0u;
-            mdata.miscFlags2 = 0;
-            mdata.format = desc.Format;
-            mdata.dimension = TEX_DIMENSION_TEXTURE2D;
-
-            hr = result.Initialize(mdata);
-            if (FAILED(hr))
-                break;
-
-            hr = Capture(pContext, pStaging.Get(), mdata, result);
-        }
-        break;
-
-    case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
-        {
-            ComPtr<ID3D11Texture3D> pTexture;
-            hr = pSource->QueryInterface(IID_GRAPHICS_PPV_ARGS(pTexture.GetAddressOf()));
-            if (FAILED(hr))
-                break;
-
-            assert(pTexture);
-
-            D3D11_TEXTURE3D_DESC desc;
-            pTexture->GetDesc(&desc);
-
-            ComPtr<ID3D11Texture3D> pStaging;
-            if ((desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
-            {
-                // Handle case where the source is already a staging texture we can use directly
-                pStaging = pTexture;
-            }
-            else
-            {
-                desc.BindFlags = 0;
-                desc.MiscFlags = 0;
-                desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-                desc.Usage = D3D11_USAGE_STAGING;
-
-                hr = pDevice->CreateTexture3D(&desc, nullptr, pStaging.GetAddressOf());
-                if (FAILED(hr))
-                    break;
-
-                assert(pStaging);
-
-                pContext->CopyResource(pStaging.Get(), pSource);
-            }
-
-            TexMetadata mdata;
-            mdata.width = desc.Width;
-            mdata.height = desc.Height;
-            mdata.depth = desc.Depth;
-            mdata.arraySize = 1;
-            mdata.mipLevels = desc.MipLevels;
-            mdata.miscFlags = 0;
-            mdata.miscFlags2 = 0;
-            mdata.format = desc.Format;
-            mdata.dimension = TEX_DIMENSION_TEXTURE3D;
-
-            hr = result.Initialize(mdata);
-            if (FAILED(hr))
-                break;
-
-            hr = Capture(pContext, pStaging.Get(), mdata, result);
-        }
-        break;
-
-    default:
-        hr = E_FAIL;
-        break;
-    }
-
-    if (FAILED(hr))
-    {
-        result.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexD3D12.cpp b/thirdparty/directxtex/DirectXTexD3D12.cpp
deleted file mode 100644
index 9256193..0000000
--- a/thirdparty/directxtex/DirectXTexD3D12.cpp
+++ /dev/null
@@ -1,826 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexD3D12.cpp
-//
-// DirectX Texture Library - Direct3D 12 helpers
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wsign-conversion"
-#pragma clang diagnostic ignored "-Wunused-macros"
-#endif
-
-#define D3DX12_NO_STATE_OBJECT_HELPERS
-#define D3DX12_NO_CHECK_FEATURE_SUPPORT_CLASS
-#ifdef _GAMING_XBOX_SCARLETT
-#include <d3dx12_xs.h>
-#elif (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
-#include "d3dx12_x.h"
-#elif !defined(_WIN32) || defined(USING_DIRECTX_HEADERS)
-#include "directx/d3dx12.h"
-#include "dxguids/dxguids.h"
-#else
-#include "d3dx12.h"
-#endif
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-#ifndef IID_GRAPHICS_PPV_ARGS
-#define IID_GRAPHICS_PPV_ARGS(x) IID_PPV_ARGS(x)
-#endif
-
-using namespace DirectX;
-using Microsoft::WRL::ComPtr;
-
-static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE1D) == static_cast<int>(D3D12_RESOURCE_DIMENSION_TEXTURE1D), "header enum mismatch");
-static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE2D) == static_cast<int>(D3D12_RESOURCE_DIMENSION_TEXTURE2D), "header enum mismatch");
-static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE3D) == static_cast<int>(D3D12_RESOURCE_DIMENSION_TEXTURE3D), "header enum mismatch");
-
-namespace
-{
-    template<typename T, typename PT> void AdjustPlaneResource(
-        _In_ DXGI_FORMAT fmt,
-        _In_ size_t height,
-        _In_ size_t slicePlane,
-        _Inout_ T& res) noexcept
-    {
-        switch (static_cast<int>(fmt))
-        {
-        case DXGI_FORMAT_NV12:
-        case DXGI_FORMAT_P010:
-        case DXGI_FORMAT_P016:
-        case XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT:
-        case XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
-        case XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT:
-            if (!slicePlane)
-            {
-                // Plane 0
-                res.SlicePitch = res.RowPitch * static_cast<PT>(height);
-            }
-            else
-            {
-                // Plane 1
-                res.pData = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(res.pData) + res.RowPitch * PT(height));
-                res.SlicePitch = res.RowPitch * static_cast<PT>((height + 1) >> 1);
-            }
-            break;
-
-        case DXGI_FORMAT_NV11:
-            if (!slicePlane)
-            {
-                // Plane 0
-                res.SlicePitch = res.RowPitch * static_cast<PT>(height);
-            }
-            else
-            {
-                // Plane 1
-                res.pData = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(res.pData) + res.RowPitch * PT(height));
-                res.RowPitch = (res.RowPitch >> 1);
-                res.SlicePitch = res.RowPitch * static_cast<PT>(height);
-            }
-            break;
-        }
-    }
-
-
-    //--------------------------------------------------------------------------------------
-    inline void TransitionResource(
-        _In_ ID3D12GraphicsCommandList* commandList,
-        _In_ ID3D12Resource* resource,
-        _In_ D3D12_RESOURCE_STATES stateBefore,
-        _In_ D3D12_RESOURCE_STATES stateAfter)
-    {
-        assert(commandList != nullptr);
-        assert(resource != nullptr);
-
-        if (stateBefore == stateAfter)
-            return;
-
-        D3D12_RESOURCE_BARRIER desc = {};
-        desc.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
-        desc.Transition.pResource = resource;
-        desc.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
-        desc.Transition.StateBefore = stateBefore;
-        desc.Transition.StateAfter = stateAfter;
-
-        commandList->ResourceBarrier(1, &desc);
-    }
-
-
-    //--------------------------------------------------------------------------------------
-    HRESULT Capture(_In_ ID3D12Device* device,
-        _In_ ID3D12CommandQueue* pCommandQ,
-        _In_ ID3D12Resource* pSource,
-        const D3D12_RESOURCE_DESC& desc,
-        ComPtr<ID3D12Resource>& pStaging,
-        std::unique_ptr<uint8_t[]>& layoutBuff,
-        UINT& numberOfPlanes,
-        UINT& numberOfResources,
-        D3D12_RESOURCE_STATES beforeState,
-        D3D12_RESOURCE_STATES afterState) noexcept
-    {
-        if (!pCommandQ || !pSource)
-            return E_INVALIDARG;
-
-        numberOfPlanes = D3D12GetFormatPlaneCount(device, desc.Format);
-        if (!numberOfPlanes)
-            return E_INVALIDARG;
-
-        if ((numberOfPlanes > 1) && IsDepthStencil(desc.Format))
-        {
-            // DirectX 12 uses planes for stencil, DirectX 11 does not
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        numberOfResources = (desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D)
-            ? 1u : desc.DepthOrArraySize;
-        numberOfResources *= desc.MipLevels;
-        numberOfResources *= numberOfPlanes;
-
-        if (numberOfResources > D3D12_REQ_SUBRESOURCES)
-            return E_UNEXPECTED;
-
-        const size_t memAlloc = (sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * numberOfResources;
-        if (memAlloc > SIZE_MAX)
-            return E_UNEXPECTED;
-
-        layoutBuff.reset(new (std::nothrow) uint8_t[memAlloc]);
-        if (!layoutBuff)
-            return E_OUTOFMEMORY;
-
-        auto pLayout = reinterpret_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(layoutBuff.get());
-        auto pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayout + numberOfResources);
-        auto pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + numberOfResources);
-
-        UINT64 totalResourceSize = 0;
-        device->GetCopyableFootprints(&desc, 0, numberOfResources, 0,
-            pLayout, pNumRows, pRowSizesInBytes, &totalResourceSize);
-
-        D3D12_HEAP_PROPERTIES sourceHeapProperties;
-        HRESULT hr = pSource->GetHeapProperties(&sourceHeapProperties, nullptr);
-        if (SUCCEEDED(hr) && sourceHeapProperties.Type == D3D12_HEAP_TYPE_READBACK)
-        {
-            // Handle case where the source is already a staging texture we can use directly
-            pStaging = pSource;
-            return S_OK;
-        }
-
-        // Create a command allocator
-        ComPtr<ID3D12CommandAllocator> commandAlloc;
-        hr = device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_GRAPHICS_PPV_ARGS(commandAlloc.GetAddressOf()));
-        if (FAILED(hr))
-            return hr;
-
-        // Spin up a new command list
-        ComPtr<ID3D12GraphicsCommandList> commandList;
-        hr = device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, commandAlloc.Get(), nullptr, IID_GRAPHICS_PPV_ARGS(commandList.GetAddressOf()));
-        if (FAILED(hr))
-            return hr;
-
-        // Create a fence
-        ComPtr<ID3D12Fence> fence;
-        hr = device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_GRAPHICS_PPV_ARGS(fence.GetAddressOf()));
-        if (FAILED(hr))
-            return hr;
-
-        const CD3DX12_HEAP_PROPERTIES defaultHeapProperties(D3D12_HEAP_TYPE_DEFAULT);
-        const CD3DX12_HEAP_PROPERTIES readBackHeapProperties(D3D12_HEAP_TYPE_READBACK);
-
-        // Readback resources must be buffers
-        D3D12_RESOURCE_DESC bufferDesc = {};
-        bufferDesc.DepthOrArraySize = 1;
-        bufferDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
-        bufferDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
-        bufferDesc.Format = DXGI_FORMAT_UNKNOWN;
-        bufferDesc.Height = 1;
-        bufferDesc.Width = totalResourceSize;
-        bufferDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
-        bufferDesc.MipLevels = 1;
-        bufferDesc.SampleDesc.Count = 1;
-
-        ComPtr<ID3D12Resource> copySource(pSource);
-        if (desc.SampleDesc.Count > 1)
-        {
-            // MSAA content must be resolved before being copied to a staging texture
-            auto descCopy = desc;
-            descCopy.SampleDesc.Count = 1;
-            descCopy.SampleDesc.Quality = 0;
-            descCopy.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
-
-            ComPtr<ID3D12Resource> pTemp;
-            hr = device->CreateCommittedResource(
-                &defaultHeapProperties,
-                D3D12_HEAP_FLAG_NONE,
-                &descCopy,
-                D3D12_RESOURCE_STATE_COPY_DEST,
-                nullptr,
-                IID_GRAPHICS_PPV_ARGS(pTemp.GetAddressOf()));
-            if (FAILED(hr))
-                return hr;
-
-            assert(pTemp);
-
-            DXGI_FORMAT fmt = desc.Format;
-            if (IsTypeless(fmt))
-            {
-                // Assume a UNORM if it exists otherwise use FLOAT
-                fmt = MakeTypelessUNORM(fmt);
-                fmt = MakeTypelessFLOAT(fmt);
-            }
-
-            D3D12_FEATURE_DATA_FORMAT_SUPPORT formatInfo = { fmt, D3D12_FORMAT_SUPPORT1_NONE, D3D12_FORMAT_SUPPORT2_NONE };
-            hr = device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &formatInfo, sizeof(formatInfo));
-            if (FAILED(hr))
-                return hr;
-
-            if (!(formatInfo.Support1 & D3D12_FORMAT_SUPPORT1_TEXTURE2D))
-                return E_FAIL;
-
-            for (UINT plane = 0; plane < numberOfPlanes; ++plane)
-            {
-                for (UINT item = 0; item < desc.DepthOrArraySize; ++item)
-                {
-                    for (UINT level = 0; level < desc.MipLevels; ++level)
-                    {
-                        const UINT index = D3D12CalcSubresource(level, item, plane, desc.MipLevels, desc.DepthOrArraySize);
-                        commandList->ResolveSubresource(pTemp.Get(), index, pSource, index, fmt);
-                    }
-                }
-            }
-
-            copySource = pTemp;
-        }
-
-        // Create a staging texture
-        hr = device->CreateCommittedResource(
-            &readBackHeapProperties,
-            D3D12_HEAP_FLAG_NONE,
-            &bufferDesc,
-            D3D12_RESOURCE_STATE_COPY_DEST,
-            nullptr,
-            IID_GRAPHICS_PPV_ARGS(pStaging.GetAddressOf()));
-        if (FAILED(hr))
-            return hr;
-
-        assert(pStaging);
-
-        // Transition the resource if necessary
-        TransitionResource(commandList.Get(), pSource, beforeState, D3D12_RESOURCE_STATE_COPY_SOURCE);
-
-        // Get the copy target location
-        for (UINT j = 0; j < numberOfResources; ++j)
-        {
-            const CD3DX12_TEXTURE_COPY_LOCATION copyDest(pStaging.Get(), pLayout[j]);
-            const CD3DX12_TEXTURE_COPY_LOCATION copySrc(copySource.Get(), j);
-            commandList->CopyTextureRegion(&copyDest, 0, 0, 0, &copySrc, nullptr);
-        }
-
-        // Transition the resource to the next state
-        TransitionResource(commandList.Get(), pSource, D3D12_RESOURCE_STATE_COPY_SOURCE, afterState);
-
-        hr = commandList->Close();
-        if (FAILED(hr))
-            return hr;
-
-        // Execute the command list
-        pCommandQ->ExecuteCommandLists(1, CommandListCast(commandList.GetAddressOf()));
-
-        // Signal the fence
-        hr = pCommandQ->Signal(fence.Get(), 1);
-        if (FAILED(hr))
-            return hr;
-
-        // Block until the copy is complete
-        while (fence->GetCompletedValue() < 1)
-        {
-        #ifdef _WIN32
-            SwitchToThread();
-        #else
-            std::this_thread::yield();
-        #endif
-        }
-
-        return S_OK;
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Determine if given texture metadata is supported on the given device
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::IsSupportedTexture(
-    ID3D12Device* pDevice,
-    const TexMetadata& metadata) noexcept
-{
-    if (!pDevice)
-        return false;
-
-    // Validate format
-    const DXGI_FORMAT fmt = metadata.format;
-
-    if (!IsValid(fmt))
-        return false;
-
-    // Validate miplevel count
-    if (metadata.mipLevels > D3D12_REQ_MIP_LEVELS)
-        return false;
-
-    // Validate array size, dimension, and width/height
-    const size_t arraySize = metadata.arraySize;
-    const size_t iWidth = metadata.width;
-    const size_t iHeight = metadata.height;
-    const size_t iDepth = metadata.depth;
-
-    // Most cases are known apriori based on feature level, but we use this for robustness to handle the few optional cases
-    D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport = { fmt, D3D12_FORMAT_SUPPORT1_NONE, D3D12_FORMAT_SUPPORT2_NONE };
-    HRESULT hr = pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &formatSupport, sizeof(formatSupport));
-    if (FAILED(hr))
-    {
-        memset(&formatSupport, 0, sizeof(formatSupport));
-    }
-
-    if (metadata.mipLevels > 1 && !(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_MIP))
-    {
-        return false;
-    }
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-        if (!(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_TEXTURE1D))
-            return false;
-
-        if ((arraySize > D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION)
-            || (iWidth > D3D12_REQ_TEXTURE1D_U_DIMENSION))
-            return false;
-
-        {
-            const uint64_t numberOfResources = uint64_t(arraySize) * uint64_t(metadata.mipLevels);
-            if (numberOfResources > D3D12_REQ_SUBRESOURCES)
-                return false;
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE2D:
-        if (metadata.IsCubemap())
-        {
-            if (!(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_TEXTURECUBE))
-                return false;
-
-            if ((arraySize > D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
-                || (iWidth > D3D12_REQ_TEXTURECUBE_DIMENSION)
-                || (iHeight > D3D12_REQ_TEXTURECUBE_DIMENSION))
-                return false;
-        }
-        else // Not a cube map
-        {
-            if (!(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_TEXTURE2D))
-                return false;
-
-            if ((arraySize > D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
-                || (iWidth > D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION)
-                || (iHeight > D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION))
-                return false;
-        }
-
-        {
-            const uint64_t numberOfResources = uint64_t(arraySize) * uint64_t(metadata.mipLevels);
-            if (numberOfResources > D3D12_REQ_SUBRESOURCES)
-                return false;
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        if (!(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_TEXTURE3D))
-            return false;
-
-        if ((arraySize > 1)
-            || (iWidth > D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
-            || (iHeight > D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
-            || (iDepth > D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION))
-            return false;
-
-        {
-            if (metadata.mipLevels > D3D12_REQ_SUBRESOURCES)
-                return false;
-        }
-        break;
-
-    default:
-        // Not a supported dimension
-        return false;
-    }
-
-    return true;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Create a texture resource
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::CreateTexture(
-    ID3D12Device* pDevice,
-    const TexMetadata& metadata,
-    ID3D12Resource** ppResource) noexcept
-{
-    return CreateTextureEx(
-        pDevice, metadata,
-        D3D12_RESOURCE_FLAG_NONE, CREATETEX_DEFAULT,
-        ppResource);
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::CreateTextureEx(
-    ID3D12Device* pDevice,
-    const TexMetadata& metadata,
-    D3D12_RESOURCE_FLAGS resFlags,
-    CREATETEX_FLAGS flags,
-    ID3D12Resource** ppResource) noexcept
-{
-    if (!pDevice || !ppResource)
-        return E_INVALIDARG;
-
-    *ppResource = nullptr;
-
-    if (!metadata.mipLevels || !metadata.arraySize)
-        return E_INVALIDARG;
-
-    if ((metadata.width > UINT32_MAX) || (metadata.height > UINT32_MAX)
-        || (metadata.mipLevels > UINT16_MAX) || (metadata.arraySize > UINT16_MAX))
-        return E_INVALIDARG;
-
-    DXGI_FORMAT format = metadata.format;
-    if (flags & CREATETEX_FORCE_SRGB)
-    {
-        format = MakeSRGB(format);
-    }
-    else if (flags & CREATETEX_IGNORE_SRGB)
-    {
-        format = MakeLinear(format);
-    }
-
-    D3D12_RESOURCE_DESC desc = {};
-    desc.Width = static_cast<UINT>(metadata.width);
-    desc.Height = static_cast<UINT>(metadata.height);
-    desc.MipLevels = static_cast<UINT16>(metadata.mipLevels);
-    desc.DepthOrArraySize = (metadata.dimension == TEX_DIMENSION_TEXTURE3D)
-        ? static_cast<UINT16>(metadata.depth)
-        : static_cast<UINT16>(metadata.arraySize);
-    desc.Format = format;
-    desc.Flags = resFlags;
-    desc.SampleDesc.Count = 1;
-    desc.Dimension = static_cast<D3D12_RESOURCE_DIMENSION>(metadata.dimension);
-
-    const CD3DX12_HEAP_PROPERTIES defaultHeapProperties(D3D12_HEAP_TYPE_DEFAULT);
-
-    HRESULT hr = pDevice->CreateCommittedResource(
-        &defaultHeapProperties,
-        D3D12_HEAP_FLAG_NONE,
-        &desc,
-        D3D12_RESOURCE_STATE_COPY_DEST,
-        nullptr,
-        IID_GRAPHICS_PPV_ARGS(ppResource));
-
-    return hr;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Prepares a texture resource for upload
-//-------------------------------------------------------------------------------------
-
-_Use_decl_annotations_
-HRESULT DirectX::PrepareUpload(
-    ID3D12Device* pDevice,
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    std::vector<D3D12_SUBRESOURCE_DATA>& subresources)
-{
-    if (!pDevice || !srcImages || !nimages || !metadata.mipLevels || !metadata.arraySize)
-        return E_INVALIDARG;
-
-    const UINT numberOfPlanes = D3D12GetFormatPlaneCount(pDevice, metadata.format);
-    if (!numberOfPlanes)
-        return E_INVALIDARG;
-
-    if ((numberOfPlanes > 1) && IsDepthStencil(metadata.format))
-    {
-        // DirectX 12 uses planes for stencil, DirectX 11 does not
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    size_t numberOfResources = (metadata.dimension == TEX_DIMENSION_TEXTURE3D)
-        ? 1u : metadata.arraySize;
-    numberOfResources *= metadata.mipLevels;
-    numberOfResources *= numberOfPlanes;
-
-    if (numberOfResources > D3D12_REQ_SUBRESOURCES)
-        return E_INVALIDARG;
-
-    subresources.clear();
-    subresources.reserve(numberOfResources);
-
-    // Fill out subresource array
-    if (metadata.IsVolumemap())
-    {
-        //--- Volume case -------------------------------------------------------------
-        if (!metadata.depth)
-            return E_INVALIDARG;
-
-        if (metadata.depth > UINT16_MAX)
-            return E_INVALIDARG;
-
-        if (metadata.arraySize > 1)
-            // Direct3D 12 doesn't support arrays of 3D textures
-            return HRESULT_E_NOT_SUPPORTED;
-
-        for (size_t plane = 0; plane < numberOfPlanes; ++plane)
-        {
-            size_t depth = metadata.depth;
-
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                const size_t index = metadata.ComputeIndex(level, 0, 0);
-                if (index >= nimages)
-                    return E_FAIL;
-
-                const Image& img = srcImages[index];
-
-                if (img.format != metadata.format)
-                    return E_FAIL;
-
-                if (!img.pixels)
-                    return E_POINTER;
-
-                // Verify pixels in image 1 .. (depth-1) are exactly image->slicePitch apart
-                // For 3D textures, this relies on all slices of the same miplevel being continous in memory
-                // (this is how ScratchImage lays them out), which is why we just give the 0th slice to Direct3D 11
-                const uint8_t* pSlice = img.pixels + img.slicePitch;
-                for (size_t slice = 1; slice < depth; ++slice)
-                {
-                    const size_t tindex = metadata.ComputeIndex(level, 0, slice);
-                    if (tindex >= nimages)
-                        return E_FAIL;
-
-                    const Image& timg = srcImages[tindex];
-
-                    if (!timg.pixels)
-                        return E_POINTER;
-
-                    if (timg.pixels != pSlice
-                        || timg.format != metadata.format
-                        || timg.rowPitch != img.rowPitch
-                        || timg.slicePitch != img.slicePitch)
-                        return E_FAIL;
-
-                    pSlice = timg.pixels + img.slicePitch;
-                }
-
-                D3D12_SUBRESOURCE_DATA res =
-                {
-                    img.pixels,
-                    static_cast<LONG_PTR>(img.rowPitch),
-                    static_cast<LONG_PTR>(img.slicePitch)
-                };
-
-                AdjustPlaneResource<D3D12_SUBRESOURCE_DATA, intptr_t>(metadata.format, img.height, plane, res);
-
-                subresources.emplace_back(res);
-
-                if (depth > 1)
-                    depth >>= 1;
-            }
-        }
-    }
-    else
-    {
-        //--- 1D or 2D texture case ---------------------------------------------------
-        for (size_t plane = 0; plane < numberOfPlanes; ++plane)
-        {
-            for (size_t item = 0; item < metadata.arraySize; ++item)
-            {
-                for (size_t level = 0; level < metadata.mipLevels; ++level)
-                {
-                    const size_t index = metadata.ComputeIndex(level, item, 0);
-                    if (index >= nimages)
-                        return E_FAIL;
-
-                    const Image& img = srcImages[index];
-
-                    if (img.format != metadata.format)
-                        return E_FAIL;
-
-                    if (!img.pixels)
-                        return E_POINTER;
-
-                    D3D12_SUBRESOURCE_DATA res =
-                    {
-                        img.pixels,
-                        static_cast<LONG_PTR>(img.rowPitch),
-                        static_cast<LONG_PTR>(img.slicePitch)
-                    };
-
-                    AdjustPlaneResource<D3D12_SUBRESOURCE_DATA, intptr_t>(metadata.format, img.height, plane, res);
-
-                    subresources.emplace_back(res);
-                }
-            }
-        }
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a texture resource
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::CaptureTexture(
-    ID3D12CommandQueue* pCommandQueue,
-    ID3D12Resource* pSource,
-    bool isCubeMap,
-    ScratchImage& result,
-    D3D12_RESOURCE_STATES beforeState,
-    D3D12_RESOURCE_STATES afterState) noexcept
-{
-    if (!pCommandQueue || !pSource)
-        return E_INVALIDARG;
-
-    ComPtr<ID3D12Device> device;
-    pCommandQueue->GetDevice(IID_GRAPHICS_PPV_ARGS(device.GetAddressOf()));
-
-#if defined(_MSC_VER) || !defined(_WIN32)
-    auto const desc = pSource->GetDesc();
-#else
-    D3D12_RESOURCE_DESC tmpDesc;
-    auto const& desc = *pSource->GetDesc(&tmpDesc);
-#endif
-
-    ComPtr<ID3D12Resource> pStaging;
-    std::unique_ptr<uint8_t[]> layoutBuff;
-    UINT numberOfPlanes, numberOfResources;
-    HRESULT hr = Capture(device.Get(),
-        pCommandQueue,
-        pSource,
-        desc,
-        pStaging,
-        layoutBuff,
-        numberOfPlanes,
-        numberOfResources,
-        beforeState,
-        afterState);
-    if (FAILED(hr))
-        return hr;
-
-    if (!layoutBuff || !numberOfPlanes || !numberOfResources)
-        return E_UNEXPECTED;
-
-    auto pLayout = reinterpret_cast<const D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(layoutBuff.get());
-    auto pRowSizesInBytes = reinterpret_cast<const UINT64*>(pLayout + numberOfResources);
-    auto pNumRows = reinterpret_cast<const UINT*>(pRowSizesInBytes + numberOfResources);
-
-    switch (desc.Dimension)
-    {
-    case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
-        {
-            TexMetadata mdata;
-            mdata.width = static_cast<size_t>(desc.Width);
-            mdata.height = mdata.depth = 1;
-            mdata.arraySize = desc.DepthOrArraySize;
-            mdata.mipLevels = desc.MipLevels;
-            mdata.miscFlags = 0;
-            mdata.miscFlags2 = 0;
-            mdata.format = desc.Format;
-            mdata.dimension = TEX_DIMENSION_TEXTURE1D;
-
-            hr = result.Initialize(mdata);
-            if (FAILED(hr))
-                return hr;
-        }
-        break;
-
-    case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
-        {
-            TexMetadata mdata;
-            mdata.width = static_cast<size_t>(desc.Width);
-            mdata.height = desc.Height;
-            mdata.depth = 1;
-            mdata.arraySize = desc.DepthOrArraySize;
-            mdata.mipLevels = desc.MipLevels;
-            mdata.miscFlags = isCubeMap ? TEX_MISC_TEXTURECUBE : 0u;
-            mdata.miscFlags2 = 0;
-            mdata.format = desc.Format;
-            mdata.dimension = TEX_DIMENSION_TEXTURE2D;
-
-            hr = result.Initialize(mdata);
-            if (FAILED(hr))
-                return hr;
-        }
-        break;
-
-    case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
-        {
-            TexMetadata mdata;
-            mdata.width = static_cast<size_t>(desc.Width);
-            mdata.height = desc.Height;
-            mdata.depth = desc.DepthOrArraySize;
-            mdata.arraySize = 1;
-            mdata.mipLevels = desc.MipLevels;
-            mdata.miscFlags = 0;
-            mdata.miscFlags2 = 0;
-            mdata.format = desc.Format;
-            mdata.dimension = TEX_DIMENSION_TEXTURE3D;
-
-            hr = result.Initialize(mdata);
-            if (FAILED(hr))
-                return hr;
-        }
-        break;
-
-    default:
-        return E_FAIL;
-    }
-
-    BYTE* pData;
-    hr = pStaging->Map(0, nullptr, reinterpret_cast<void**>(&pData));
-    if (FAILED(hr))
-    {
-        result.Release();
-        return E_FAIL;
-    }
-
-    const UINT arraySize = (desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D)
-        ? 1u
-        : desc.DepthOrArraySize;
-
-    for (UINT plane = 0; plane < numberOfPlanes; ++plane)
-    {
-        for (UINT item = 0; item < arraySize; ++item)
-        {
-            for (UINT level = 0; level < desc.MipLevels; ++level)
-            {
-                const UINT dindex = D3D12CalcSubresource(level, item, plane, desc.MipLevels, arraySize);
-                assert(dindex < numberOfResources);
-
-                const Image* img = result.GetImage(level, item, 0);
-                if (!img)
-                {
-                    pStaging->Unmap(0, nullptr);
-                    result.Release();
-                    return E_FAIL;
-                }
-
-                if (!img->pixels)
-                {
-                    pStaging->Unmap(0, nullptr);
-                    result.Release();
-                    return E_POINTER;
-                }
-
-                D3D12_MEMCPY_DEST destData = { img->pixels, img->rowPitch, img->slicePitch };
-
-                AdjustPlaneResource<D3D12_MEMCPY_DEST, uintptr_t>(img->format, img->height, plane, destData);
-
-                D3D12_SUBRESOURCE_DATA srcData =
-                {
-                    pData + pLayout[dindex].Offset,
-                    static_cast<LONG_PTR>(pLayout[dindex].Footprint.RowPitch),
-                    static_cast<LONG_PTR>(pLayout[dindex].Footprint.RowPitch) * static_cast<LONG_PTR>(pNumRows[dindex])
-                };
-
-                if (pRowSizesInBytes[dindex] > SIZE_T(-1))
-                {
-                    pStaging->Unmap(0, nullptr);
-                    result.Release();
-                    return E_FAIL;
-                }
-
-                MemcpySubresource(&destData, &srcData,
-                    static_cast<SIZE_T>(pRowSizesInBytes[dindex]),
-                    pNumRows[dindex],
-                    pLayout[dindex].Footprint.Depth);
-            }
-        }
-    }
-
-    pStaging->Unmap(0, nullptr);
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexDDS.cpp b/thirdparty/directxtex/DirectXTexDDS.cpp
deleted file mode 100644
index ebbe283..0000000
--- a/thirdparty/directxtex/DirectXTexDDS.cpp
+++ /dev/null
@@ -1,2448 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexDDS.cpp
-//
-// DirectX Texture Library - Microsoft DirectDraw Surface (DDS) file format reader/writer
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#include "DDS.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-
-static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE1D) == static_cast<int>(DDS_DIMENSION_TEXTURE1D), "header enum mismatch");
-static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE2D) == static_cast<int>(DDS_DIMENSION_TEXTURE2D), "header enum mismatch");
-static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE3D) == static_cast<int>(DDS_DIMENSION_TEXTURE3D), "header enum mismatch");
-
-namespace
-{
-    constexpr size_t MAX_HEADER_SIZE = sizeof(uint32_t) + sizeof(DDS_HEADER) + sizeof(DDS_HEADER_DXT10);
-
-    //-------------------------------------------------------------------------------------
-    // Legacy format mapping table (used for DDS files without 'DX10' extended header)
-    //-------------------------------------------------------------------------------------
-    enum CONVERSION_FLAGS : uint32_t
-    {
-        CONV_FLAGS_NONE = 0x0,
-        CONV_FLAGS_EXPAND = 0x1,      // Conversion requires expanded pixel size
-        CONV_FLAGS_NOALPHA = 0x2,      // Conversion requires setting alpha to known value
-        CONV_FLAGS_SWIZZLE = 0x4,      // BGR/RGB order swizzling required
-        CONV_FLAGS_PAL8 = 0x8,      // Has an 8-bit palette
-        CONV_FLAGS_888 = 0x10,     // Source is an 8:8:8 (24bpp) format
-        CONV_FLAGS_565 = 0x20,     // Source is a 5:6:5 (16bpp) format
-        CONV_FLAGS_5551 = 0x40,     // Source is a 5:5:5:1 (16bpp) format
-        CONV_FLAGS_4444 = 0x80,     // Source is a 4:4:4:4 (16bpp) format
-        CONV_FLAGS_44 = 0x100,    // Source is a 4:4 (8bpp) format
-        CONV_FLAGS_332 = 0x200,    // Source is a 3:3:2 (8bpp) format
-        CONV_FLAGS_8332 = 0x400,    // Source is a 8:3:3:2 (16bpp) format
-        CONV_FLAGS_A8P8 = 0x800,    // Has an 8-bit palette with an alpha channel
-        CONV_FLAGS_DX10 = 0x10000,  // Has the 'DX10' extension header
-        CONV_FLAGS_PMALPHA = 0x20000,  // Contains premultiplied alpha data
-        CONV_FLAGS_L8 = 0x40000,  // Source is a 8 luminance format
-        CONV_FLAGS_L16 = 0x80000,  // Source is a 16 luminance format
-        CONV_FLAGS_A8L8 = 0x100000, // Source is a 8:8 luminance format
-    };
-
-    struct LegacyDDS
-    {
-        DXGI_FORMAT     format;
-        uint32_t        convFlags;
-        DDS_PIXELFORMAT ddpf;
-    };
-
-    const LegacyDDS g_LegacyDDSMap[] =
-    {
-        { DXGI_FORMAT_BC1_UNORM,          CONV_FLAGS_NONE,        DDSPF_DXT1 }, // D3DFMT_DXT1
-        { DXGI_FORMAT_BC2_UNORM,          CONV_FLAGS_NONE,        DDSPF_DXT3 }, // D3DFMT_DXT3
-        { DXGI_FORMAT_BC3_UNORM,          CONV_FLAGS_NONE,        DDSPF_DXT5 }, // D3DFMT_DXT5
-
-        { DXGI_FORMAT_BC2_UNORM,          CONV_FLAGS_PMALPHA,     DDSPF_DXT2 }, // D3DFMT_DXT2
-        { DXGI_FORMAT_BC3_UNORM,          CONV_FLAGS_PMALPHA,     DDSPF_DXT4 }, // D3DFMT_DXT4
-
-        { DXGI_FORMAT_BC4_UNORM,          CONV_FLAGS_NONE,        DDSPF_BC4_UNORM },
-        { DXGI_FORMAT_BC4_SNORM,          CONV_FLAGS_NONE,        DDSPF_BC4_SNORM },
-        { DXGI_FORMAT_BC5_UNORM,          CONV_FLAGS_NONE,        DDSPF_BC5_UNORM },
-        { DXGI_FORMAT_BC5_SNORM,          CONV_FLAGS_NONE,        DDSPF_BC5_SNORM },
-
-        { DXGI_FORMAT_BC4_UNORM,          CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('A', 'T', 'I', '1'), 0, 0, 0, 0, 0 } },
-        { DXGI_FORMAT_BC5_UNORM,          CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('A', 'T', 'I', '2'), 0, 0, 0, 0, 0 } },
-
-        { DXGI_FORMAT_BC6H_UF16,          CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B', 'C', '6', 'H'), 0, 0, 0, 0, 0 } },
-        { DXGI_FORMAT_BC7_UNORM,          CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B', 'C', '7', 'L'), 0, 0, 0, 0, 0 } },
-        { DXGI_FORMAT_BC7_UNORM,          CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B', 'C', '7', '\0'), 0, 0, 0, 0, 0 } },
-
-        { DXGI_FORMAT_R8G8_B8G8_UNORM,    CONV_FLAGS_NONE,        DDSPF_R8G8_B8G8 }, // D3DFMT_R8G8_B8G8
-        { DXGI_FORMAT_G8R8_G8B8_UNORM,    CONV_FLAGS_NONE,        DDSPF_G8R8_G8B8 }, // D3DFMT_G8R8_G8B8
-
-        { DXGI_FORMAT_B8G8R8A8_UNORM,     CONV_FLAGS_NONE,        DDSPF_A8R8G8B8 }, // D3DFMT_A8R8G8B8 (uses DXGI 1.1 format)
-        { DXGI_FORMAT_B8G8R8X8_UNORM,     CONV_FLAGS_NONE,        DDSPF_X8R8G8B8 }, // D3DFMT_X8R8G8B8 (uses DXGI 1.1 format)
-        { DXGI_FORMAT_R8G8B8A8_UNORM,     CONV_FLAGS_NONE,        DDSPF_A8B8G8R8 }, // D3DFMT_A8B8G8R8
-        { DXGI_FORMAT_R8G8B8A8_UNORM,     CONV_FLAGS_NOALPHA,     DDSPF_X8B8G8R8 }, // D3DFMT_X8B8G8R8
-        { DXGI_FORMAT_R16G16_UNORM,       CONV_FLAGS_NONE,        DDSPF_G16R16   }, // D3DFMT_G16R16
-
-        { DXGI_FORMAT_R10G10B10A2_UNORM,  CONV_FLAGS_SWIZZLE,     DDSPF_A2R10G10B10 }, // D3DFMT_A2R10G10B10 (D3DX reversal issue)
-        { DXGI_FORMAT_R10G10B10A2_UNORM,  CONV_FLAGS_NONE,        DDSPF_A2B10G10R10 }, // D3DFMT_A2B10G10R10 (D3DX reversal issue)
-
-        { DXGI_FORMAT_R8G8B8A8_UNORM,     CONV_FLAGS_EXPAND
-                                          | CONV_FLAGS_NOALPHA
-                                          | CONV_FLAGS_888,       DDSPF_R8G8B8 }, // D3DFMT_R8G8B8
-
-        { DXGI_FORMAT_B5G6R5_UNORM,       CONV_FLAGS_565,         DDSPF_R5G6B5 }, // D3DFMT_R5G6B5
-        { DXGI_FORMAT_B5G5R5A1_UNORM,     CONV_FLAGS_5551,        DDSPF_A1R5G5B5 }, // D3DFMT_A1R5G5B5
-        { DXGI_FORMAT_B5G5R5A1_UNORM,     CONV_FLAGS_5551
-                                          | CONV_FLAGS_NOALPHA,   DDSPF_X1R5G5B5 }, // D3DFMT_X1R5G5B5
-
-        { DXGI_FORMAT_R8G8B8A8_UNORM,     CONV_FLAGS_EXPAND
-                                          | CONV_FLAGS_8332,      DDSPF_A8R3G3B2 }, // D3DFMT_A8R3G3B2
-        { DXGI_FORMAT_B5G6R5_UNORM,       CONV_FLAGS_EXPAND
-                                          | CONV_FLAGS_332,       DDSPF_R3G3B2 }, // D3DFMT_R3G3B2
-
-        { DXGI_FORMAT_R8_UNORM,           CONV_FLAGS_NONE,        DDSPF_L8 }, // D3DFMT_L8
-        { DXGI_FORMAT_R16_UNORM,          CONV_FLAGS_NONE,        DDSPF_L16 }, // D3DFMT_L16
-        { DXGI_FORMAT_R8G8_UNORM,         CONV_FLAGS_NONE,        DDSPF_A8L8 }, // D3DFMT_A8L8
-        { DXGI_FORMAT_R8G8_UNORM,         CONV_FLAGS_NONE,        DDSPF_A8L8_ALT }, // D3DFMT_A8L8 (alternative bitcount)
-
-        // NVTT v1 wrote these with RGB instead of LUMINANCE
-        { DXGI_FORMAT_R8_UNORM,           CONV_FLAGS_NONE,        DDSPF_L8_NVTT1 }, // D3DFMT_L8
-        { DXGI_FORMAT_R16_UNORM,          CONV_FLAGS_NONE,        DDSPF_L16_NVTT1  }, // D3DFMT_L16
-        { DXGI_FORMAT_R8G8_UNORM,         CONV_FLAGS_NONE,        DDSPF_A8L8_NVTT1 }, // D3DFMT_A8L8
-
-        { DXGI_FORMAT_A8_UNORM,           CONV_FLAGS_NONE,        DDSPF_A8   }, // D3DFMT_A8
-
-        { DXGI_FORMAT_R16G16B16A16_UNORM, CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC,   36,  0, 0, 0, 0, 0 } }, // D3DFMT_A16B16G16R16
-        { DXGI_FORMAT_R16G16B16A16_SNORM, CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC,  110,  0, 0, 0, 0, 0 } }, // D3DFMT_Q16W16V16U16
-        { DXGI_FORMAT_R16_FLOAT,          CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC,  111,  0, 0, 0, 0, 0 } }, // D3DFMT_R16F
-        { DXGI_FORMAT_R16G16_FLOAT,       CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC,  112,  0, 0, 0, 0, 0 } }, // D3DFMT_G16R16F
-        { DXGI_FORMAT_R16G16B16A16_FLOAT, CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC,  113,  0, 0, 0, 0, 0 } }, // D3DFMT_A16B16G16R16F
-        { DXGI_FORMAT_R32_FLOAT,          CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC,  114,  0, 0, 0, 0, 0 } }, // D3DFMT_R32F
-        { DXGI_FORMAT_R32G32_FLOAT,       CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC,  115,  0, 0, 0, 0, 0 } }, // D3DFMT_G32R32F
-        { DXGI_FORMAT_R32G32B32A32_FLOAT, CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_FOURCC,  116,  0, 0, 0, 0, 0 } }, // D3DFMT_A32B32G32R32F
-
-        { DXGI_FORMAT_R32_FLOAT,          CONV_FLAGS_NONE,        { sizeof(DDS_PIXELFORMAT), DDS_RGB,       0, 32, 0xffffffff, 0, 0, 0 } }, // D3DFMT_R32F (D3DX uses FourCC 114 instead)
-
-        { DXGI_FORMAT_R8G8B8A8_UNORM,     CONV_FLAGS_EXPAND
-                                          | CONV_FLAGS_PAL8
-                                          | CONV_FLAGS_A8P8,      { sizeof(DDS_PIXELFORMAT), DDS_PAL8A,     0, 16, 0, 0, 0, 0 } }, // D3DFMT_A8P8
-        { DXGI_FORMAT_R8G8B8A8_UNORM,     CONV_FLAGS_EXPAND
-                                          | CONV_FLAGS_PAL8,      { sizeof(DDS_PIXELFORMAT), DDS_PAL8,      0,  8, 0, 0, 0, 0 } }, // D3DFMT_P8
-
-        { DXGI_FORMAT_B4G4R4A4_UNORM,     CONV_FLAGS_4444,        DDSPF_A4R4G4B4 }, // D3DFMT_A4R4G4B4 (uses DXGI 1.2 format)
-        { DXGI_FORMAT_B4G4R4A4_UNORM,     CONV_FLAGS_NOALPHA
-                                          | CONV_FLAGS_4444,      DDSPF_X4R4G4B4 }, // D3DFMT_X4R4G4B4 (uses DXGI 1.2 format)
-        { DXGI_FORMAT_B4G4R4A4_UNORM,     CONV_FLAGS_EXPAND
-                                          | CONV_FLAGS_44,        DDSPF_A4L4 }, // D3DFMT_A4L4 (uses DXGI 1.2 format)
-
-        { DXGI_FORMAT_YUY2,               CONV_FLAGS_NONE,        DDSPF_YUY2 }, // D3DFMT_YUY2 (uses DXGI 1.2 format)
-        { DXGI_FORMAT_YUY2,               CONV_FLAGS_SWIZZLE,     DDSPF_UYVY }, // D3DFMT_UYVY (uses DXGI 1.2 format)
-
-        { DXGI_FORMAT_R8G8_SNORM,         CONV_FLAGS_NONE,        DDSPF_V8U8 },     // D3DFMT_V8U8
-        { DXGI_FORMAT_R8G8B8A8_SNORM,     CONV_FLAGS_NONE,        DDSPF_Q8W8V8U8 }, // D3DFMT_Q8W8V8U8
-        { DXGI_FORMAT_R16G16_SNORM,       CONV_FLAGS_NONE,        DDSPF_V16U16 },   // D3DFMT_V16U16
-    };
-
-    // Note that many common DDS reader/writers (including D3DX) swap the
-    // the RED/BLUE masks for 10:10:10:2 formats. We assumme
-    // below that the 'backwards' header mask is being used since it is most
-    // likely written by D3DX. The more robust solution is to use the 'DX10'
-    // header extension and specify the DXGI_FORMAT_R10G10B10A2_UNORM format directly
-
-    // We do not support the following legacy Direct3D 9 formats:
-    //      BumpDuDv D3DFMT_A2W10V10U10
-    //      BumpLuminance D3DFMT_L6V5U5, D3DFMT_X8L8V8U8
-    //      FourCC 117 D3DFMT_CxV8U8
-    //      ZBuffer D3DFMT_D16_LOCKABLE
-    //      FourCC 82 D3DFMT_D32F_LOCKABLE
-
-    // We do not support the following known FourCC codes:
-    //      FourCC CTX1 (Xbox 360 only)
-    //      FourCC EAR, EARG, ET2, ET2A (Ericsson Texture Compression)
-
-    DXGI_FORMAT GetDXGIFormat(const DDS_HEADER& hdr, const DDS_PIXELFORMAT& ddpf,
-        DDS_FLAGS flags,
-        _Inout_ uint32_t& convFlags) noexcept
-    {
-        uint32_t ddpfFlags = ddpf.flags;
-        if (hdr.reserved1[9] == MAKEFOURCC('N', 'V', 'T', 'T'))
-        {
-            // Clear out non-standard nVidia DDS flags
-            ddpfFlags &= ~0xC0000000 /* DDPF_SRGB | DDPF_NORMAL */;
-        }
-
-        constexpr size_t MAP_SIZE = sizeof(g_LegacyDDSMap) / sizeof(LegacyDDS);
-        size_t index = 0;
-        for (index = 0; index < MAP_SIZE; ++index)
-        {
-            const LegacyDDS* entry = &g_LegacyDDSMap[index];
-
-            if ((ddpfFlags & DDS_FOURCC) && (entry->ddpf.flags & DDS_FOURCC))
-            {
-                // In case of FourCC codes, ignore any other bits in ddpf.flags
-                if (ddpf.fourCC == entry->ddpf.fourCC)
-                    break;
-            }
-            else if (ddpfFlags == entry->ddpf.flags)
-            {
-                if (entry->ddpf.flags & DDS_PAL8)
-                {
-                    if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount)
-                        break;
-                }
-                else if (entry->ddpf.flags & DDS_ALPHA)
-                {
-                    if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount
-                        && ddpf.ABitMask == entry->ddpf.ABitMask)
-                        break;
-                }
-                else if (entry->ddpf.flags & DDS_LUMINANCE)
-                {
-                    if (entry->ddpf.flags & DDS_ALPHAPIXELS)
-                    {
-                        // LUMINANCEA
-                        if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount
-                            && ddpf.RBitMask == entry->ddpf.RBitMask
-                            && ddpf.ABitMask == entry->ddpf.ABitMask)
-                            break;
-                    }
-                    else
-                    {
-                        // LUMINANCE
-                        if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount
-                            && ddpf.RBitMask == entry->ddpf.RBitMask)
-                            break;
-                    }
-                }
-                else if (entry->ddpf.flags & DDS_BUMPDUDV)
-                {
-                    if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount
-                        && ddpf.RBitMask == entry->ddpf.RBitMask
-                        && ddpf.GBitMask == entry->ddpf.GBitMask
-                        && ddpf.BBitMask == entry->ddpf.BBitMask
-                        && ddpf.ABitMask == entry->ddpf.ABitMask)
-                        break;
-                }
-                else if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount)
-                {
-                    if (entry->ddpf.flags & DDS_ALPHAPIXELS)
-                    {
-                        // RGBA
-                        if (ddpf.RBitMask == entry->ddpf.RBitMask
-                            && ddpf.GBitMask == entry->ddpf.GBitMask
-                            && ddpf.BBitMask == entry->ddpf.BBitMask
-                            && ddpf.ABitMask == entry->ddpf.ABitMask)
-                            break;
-                    }
-                    else
-                    {
-                        // RGB
-                        if (ddpf.RBitMask == entry->ddpf.RBitMask
-                            && ddpf.GBitMask == entry->ddpf.GBitMask
-                            && ddpf.BBitMask == entry->ddpf.BBitMask)
-                            break;
-                    }
-                }
-            }
-        }
-
-        if (index >= MAP_SIZE)
-            return DXGI_FORMAT_UNKNOWN;
-
-        uint32_t cflags = g_LegacyDDSMap[index].convFlags;
-        DXGI_FORMAT format = g_LegacyDDSMap[index].format;
-
-        if ((cflags & CONV_FLAGS_EXPAND) && (flags & DDS_FLAGS_NO_LEGACY_EXPANSION))
-            return DXGI_FORMAT_UNKNOWN;
-
-        if ((format == DXGI_FORMAT_R10G10B10A2_UNORM) && (flags & DDS_FLAGS_NO_R10B10G10A2_FIXUP))
-        {
-            cflags ^= CONV_FLAGS_SWIZZLE;
-        }
-
-        if ((hdr.reserved1[9] == MAKEFOURCC('N', 'V', 'T', 'T'))
-            && (ddpf.flags & 0x40000000 /* DDPF_SRGB */))
-        {
-            format = MakeSRGB(format);
-        }
-
-        convFlags = cflags;
-
-        return format;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Decodes DDS header including optional DX10 extended header
-    //-------------------------------------------------------------------------------------
-    HRESULT DecodeDDSHeader(
-        _In_reads_bytes_(size) const void* pSource,
-        size_t size,
-        DDS_FLAGS flags,
-        _Out_ TexMetadata& metadata,
-        _Inout_ uint32_t& convFlags) noexcept
-    {
-        if (!pSource)
-            return E_INVALIDARG;
-
-        memset(&metadata, 0, sizeof(TexMetadata));
-
-        if (size < (sizeof(DDS_HEADER) + sizeof(uint32_t)))
-        {
-            return HRESULT_E_INVALID_DATA;
-        }
-
-        // DDS files always start with the same magic number ("DDS ")
-        auto const dwMagicNumber = *static_cast<const uint32_t*>(pSource);
-        if (dwMagicNumber != DDS_MAGIC)
-        {
-            return E_FAIL;
-        }
-
-        auto pHeader = reinterpret_cast<const DDS_HEADER*>(static_cast<const uint8_t*>(pSource) + sizeof(uint32_t));
-
-        // Verify header to validate DDS file
-        if (pHeader->size != sizeof(DDS_HEADER)
-            || pHeader->ddspf.size != sizeof(DDS_PIXELFORMAT))
-        {
-            return E_FAIL;
-        }
-
-        metadata.mipLevels = pHeader->mipMapCount;
-        if (metadata.mipLevels == 0)
-            metadata.mipLevels = 1;
-
-        // Check for DX10 extension
-        if ((pHeader->ddspf.flags & DDS_FOURCC)
-            && (MAKEFOURCC('D', 'X', '1', '0') == pHeader->ddspf.fourCC))
-        {
-            // Buffer must be big enough for both headers and magic value
-            if (size < (sizeof(DDS_HEADER) + sizeof(uint32_t) + sizeof(DDS_HEADER_DXT10)))
-            {
-                return E_FAIL;
-            }
-
-            auto d3d10ext = reinterpret_cast<const DDS_HEADER_DXT10*>(static_cast<const uint8_t*>(pSource) + sizeof(uint32_t) + sizeof(DDS_HEADER));
-            convFlags |= CONV_FLAGS_DX10;
-
-            metadata.arraySize = d3d10ext->arraySize;
-            if (metadata.arraySize == 0)
-            {
-                return HRESULT_E_INVALID_DATA;
-            }
-
-            metadata.format = d3d10ext->dxgiFormat;
-            if (!IsValid(metadata.format) || IsPalettized(metadata.format))
-            {
-                return HRESULT_E_NOT_SUPPORTED;
-            }
-
-            static_assert(static_cast<int>(TEX_MISC_TEXTURECUBE) == static_cast<int>(DDS_RESOURCE_MISC_TEXTURECUBE), "DDS header mismatch");
-
-            metadata.miscFlags = d3d10ext->miscFlag & ~static_cast<uint32_t>(TEX_MISC_TEXTURECUBE);
-
-            switch (d3d10ext->resourceDimension)
-            {
-            case DDS_DIMENSION_TEXTURE1D:
-
-                // D3DX writes 1D textures with a fixed Height of 1
-                if ((pHeader->flags & DDS_HEIGHT) && pHeader->height != 1)
-                {
-                    return HRESULT_E_INVALID_DATA;
-                }
-
-                metadata.width = pHeader->width;
-                metadata.height = 1;
-                metadata.depth = 1;
-                metadata.dimension = TEX_DIMENSION_TEXTURE1D;
-                break;
-
-            case DDS_DIMENSION_TEXTURE2D:
-                if (d3d10ext->miscFlag & DDS_RESOURCE_MISC_TEXTURECUBE)
-                {
-                    metadata.miscFlags |= TEX_MISC_TEXTURECUBE;
-                    metadata.arraySize *= 6;
-                }
-
-                metadata.width = pHeader->width;
-                metadata.height = pHeader->height;
-                metadata.depth = 1;
-                metadata.dimension = TEX_DIMENSION_TEXTURE2D;
-                break;
-
-            case DDS_DIMENSION_TEXTURE3D:
-                if (!(pHeader->flags & DDS_HEADER_FLAGS_VOLUME))
-                {
-                    return HRESULT_E_INVALID_DATA;
-                }
-
-                if (metadata.arraySize > 1)
-                    return HRESULT_E_NOT_SUPPORTED;
-
-                metadata.width = pHeader->width;
-                metadata.height = pHeader->height;
-                metadata.depth = pHeader->depth;
-                metadata.dimension = TEX_DIMENSION_TEXTURE3D;
-                break;
-
-            default:
-                return HRESULT_E_INVALID_DATA;
-            }
-
-            static_assert(static_cast<int>(TEX_MISC2_ALPHA_MODE_MASK) == static_cast<int>(DDS_MISC_FLAGS2_ALPHA_MODE_MASK), "DDS header mismatch");
-
-            static_assert(static_cast<int>(TEX_ALPHA_MODE_UNKNOWN) == static_cast<int>(DDS_ALPHA_MODE_UNKNOWN), "DDS header mismatch");
-            static_assert(static_cast<int>(TEX_ALPHA_MODE_STRAIGHT) == static_cast<int>(DDS_ALPHA_MODE_STRAIGHT), "DDS header mismatch");
-            static_assert(static_cast<int>(TEX_ALPHA_MODE_PREMULTIPLIED) == static_cast<int>(DDS_ALPHA_MODE_PREMULTIPLIED), "DDS header mismatch");
-            static_assert(static_cast<int>(TEX_ALPHA_MODE_OPAQUE) == static_cast<int>(DDS_ALPHA_MODE_OPAQUE), "DDS header mismatch");
-            static_assert(static_cast<int>(TEX_ALPHA_MODE_CUSTOM) == static_cast<int>(DDS_ALPHA_MODE_CUSTOM), "DDS header mismatch");
-
-            metadata.miscFlags2 = d3d10ext->miscFlags2;
-        }
-        else
-        {
-            metadata.arraySize = 1;
-
-            if (pHeader->flags & DDS_HEADER_FLAGS_VOLUME)
-            {
-                metadata.width = pHeader->width;
-                metadata.height = pHeader->height;
-                metadata.depth = pHeader->depth;
-                metadata.dimension = TEX_DIMENSION_TEXTURE3D;
-            }
-            else
-            {
-                if (pHeader->caps2 & DDS_CUBEMAP)
-                {
-                    // We require all six faces to be defined
-                    if ((pHeader->caps2 & DDS_CUBEMAP_ALLFACES) != DDS_CUBEMAP_ALLFACES)
-                        return HRESULT_E_NOT_SUPPORTED;
-
-                    metadata.arraySize = 6;
-                    metadata.miscFlags |= TEX_MISC_TEXTURECUBE;
-                }
-
-                metadata.width = pHeader->width;
-                metadata.height = pHeader->height;
-                metadata.depth = 1;
-                metadata.dimension = TEX_DIMENSION_TEXTURE2D;
-
-                // Note there's no way for a legacy Direct3D 9 DDS to express a '1D' texture
-            }
-
-            metadata.format = GetDXGIFormat(*pHeader, pHeader->ddspf, flags, convFlags);
-
-            if (metadata.format == DXGI_FORMAT_UNKNOWN)
-                return HRESULT_E_NOT_SUPPORTED;
-
-            // Special flag for handling LUMINANCE legacy formats
-            if (flags & DDS_FLAGS_EXPAND_LUMINANCE)
-            {
-                switch (metadata.format)
-                {
-                case DXGI_FORMAT_R8_UNORM:
-                    metadata.format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                    convFlags |= CONV_FLAGS_L8 | CONV_FLAGS_EXPAND;
-                    break;
-
-                case DXGI_FORMAT_R8G8_UNORM:
-                    metadata.format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                    convFlags |= CONV_FLAGS_A8L8 | CONV_FLAGS_EXPAND;
-                    break;
-
-                case DXGI_FORMAT_R16_UNORM:
-                    metadata.format = DXGI_FORMAT_R16G16B16A16_UNORM;
-                    convFlags |= CONV_FLAGS_L16 | CONV_FLAGS_EXPAND;
-                    break;
-
-                default:
-                    break;
-                }
-            }
-        }
-
-        // Special flag for handling BGR DXGI 1.1 formats
-        if (flags & DDS_FLAGS_FORCE_RGB)
-        {
-            switch (metadata.format)
-            {
-            case DXGI_FORMAT_B8G8R8A8_UNORM:
-                metadata.format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                convFlags |= CONV_FLAGS_SWIZZLE;
-                break;
-
-            case DXGI_FORMAT_B8G8R8X8_UNORM:
-                metadata.format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                convFlags |= CONV_FLAGS_SWIZZLE | CONV_FLAGS_NOALPHA;
-                break;
-
-            case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-                metadata.format = DXGI_FORMAT_R8G8B8A8_TYPELESS;
-                convFlags |= CONV_FLAGS_SWIZZLE;
-                break;
-
-            case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-                metadata.format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
-                convFlags |= CONV_FLAGS_SWIZZLE;
-                break;
-
-            case DXGI_FORMAT_B8G8R8X8_TYPELESS:
-                metadata.format = DXGI_FORMAT_R8G8B8A8_TYPELESS;
-                convFlags |= CONV_FLAGS_SWIZZLE | CONV_FLAGS_NOALPHA;
-                break;
-
-            case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-                metadata.format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
-                convFlags |= CONV_FLAGS_SWIZZLE | CONV_FLAGS_NOALPHA;
-                break;
-
-            default:
-                break;
-            }
-        }
-
-        // Special flag for handling 16bpp formats
-        if (flags & DDS_FLAGS_NO_16BPP)
-        {
-            switch (metadata.format)
-            {
-            case DXGI_FORMAT_B5G6R5_UNORM:
-            case DXGI_FORMAT_B5G5R5A1_UNORM:
-            case DXGI_FORMAT_B4G4R4A4_UNORM:
-                if (metadata.format == DXGI_FORMAT_B5G6R5_UNORM)
-                    convFlags |= CONV_FLAGS_NOALPHA;
-                metadata.format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                convFlags |= CONV_FLAGS_EXPAND;
-                break;
-
-            default:
-                break;
-            }
-        }
-
-        // Implicit alpha mode
-        if (convFlags & CONV_FLAGS_NOALPHA)
-        {
-            metadata.SetAlphaMode(TEX_ALPHA_MODE_OPAQUE);
-        }
-        else if (convFlags & CONV_FLAGS_PMALPHA)
-        {
-            metadata.SetAlphaMode(TEX_ALPHA_MODE_PREMULTIPLIED);
-        }
-
-        // Check for .dds files that exceed known hardware support
-        if (!(flags & DDS_FLAGS_ALLOW_LARGE_FILES))
-        {
-            // 16k is the maximum required resource size supported by Direct3D
-            if (metadata.width > 16384u /* D3D12_REQ_TEXTURE1D_U_DIMENSION, D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION */
-                || metadata.height > 16384u /* D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION */
-                || metadata.mipLevels > 15u /* D3D12_REQ_MIP_LEVELS */)
-            {
-                return HRESULT_E_NOT_SUPPORTED;
-            }
-
-            // 2048 is the maximum required depth/array size supported by Direct3D
-            if (metadata.arraySize > 2048u /* D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION, D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION */
-                || metadata.depth > 2048u /* D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION */)
-            {
-                return HRESULT_E_NOT_SUPPORTED;
-            }
-        }
-
-        return S_OK;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Encodes DDS file header (magic value, header, optional DX10 extended header)
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::EncodeDDSHeader(
-    const TexMetadata& metadata,
-    DDS_FLAGS flags,
-    void* pDestination,
-    size_t maxsize,
-    size_t& required) noexcept
-{
-    if (!IsValid(metadata.format))
-        return E_INVALIDARG;
-
-    if (IsPalettized(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (metadata.arraySize > 1)
-    {
-        if ((metadata.arraySize != 6) || (metadata.dimension != TEX_DIMENSION_TEXTURE2D) || !(metadata.IsCubemap()))
-        {
-            // Texture1D arrays, Texture2D arrays, and Cubemap arrays must be stored using 'DX10' extended header
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-                return HRESULT_E_CANNOT_MAKE;
-
-            flags |= DDS_FLAGS_FORCE_DX10_EXT;
-        }
-    }
-
-    if (flags & DDS_FLAGS_FORCE_DX10_EXT_MISC2)
-    {
-        flags |= DDS_FLAGS_FORCE_DX10_EXT;
-    }
-
-    DDS_PIXELFORMAT ddpf = {};
-    if (!(flags & DDS_FLAGS_FORCE_DX10_EXT))
-    {
-        switch (metadata.format)
-        {
-        case DXGI_FORMAT_R8G8B8A8_UNORM:        memcpy(&ddpf, &DDSPF_A8B8G8R8, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_R16G16_UNORM:          memcpy(&ddpf, &DDSPF_G16R16, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_R8G8_UNORM:            memcpy(&ddpf, &DDSPF_A8L8, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_R16_UNORM:             memcpy(&ddpf, &DDSPF_L16, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_R8_UNORM:              memcpy(&ddpf, &DDSPF_L8, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_A8_UNORM:              memcpy(&ddpf, &DDSPF_A8, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_R8G8_B8G8_UNORM:       memcpy(&ddpf, &DDSPF_R8G8_B8G8, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_G8R8_G8B8_UNORM:       memcpy(&ddpf, &DDSPF_G8R8_G8B8, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_BC1_UNORM:             memcpy(&ddpf, &DDSPF_DXT1, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_BC2_UNORM:             memcpy(&ddpf, metadata.IsPMAlpha() ? (&DDSPF_DXT2) : (&DDSPF_DXT3), sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_BC3_UNORM:             memcpy(&ddpf, metadata.IsPMAlpha() ? (&DDSPF_DXT4) : (&DDSPF_DXT5), sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_BC4_SNORM:             memcpy(&ddpf, &DDSPF_BC4_SNORM, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_BC5_SNORM:             memcpy(&ddpf, &DDSPF_BC5_SNORM, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_B5G6R5_UNORM:          memcpy(&ddpf, &DDSPF_R5G6B5, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_B5G5R5A1_UNORM:        memcpy(&ddpf, &DDSPF_A1R5G5B5, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_R8G8_SNORM:            memcpy(&ddpf, &DDSPF_V8U8, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_R8G8B8A8_SNORM:        memcpy(&ddpf, &DDSPF_Q8W8V8U8, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_R16G16_SNORM:          memcpy(&ddpf, &DDSPF_V16U16, sizeof(DDS_PIXELFORMAT)); break;
-        case DXGI_FORMAT_B8G8R8A8_UNORM:        memcpy(&ddpf, &DDSPF_A8R8G8B8, sizeof(DDS_PIXELFORMAT)); break; // DXGI 1.1
-        case DXGI_FORMAT_B8G8R8X8_UNORM:        memcpy(&ddpf, &DDSPF_X8R8G8B8, sizeof(DDS_PIXELFORMAT)); break; // DXGI 1.1
-        case DXGI_FORMAT_B4G4R4A4_UNORM:        memcpy(&ddpf, &DDSPF_A4R4G4B4, sizeof(DDS_PIXELFORMAT)); break; // DXGI 1.2
-        case DXGI_FORMAT_YUY2:                  memcpy(&ddpf, &DDSPF_YUY2, sizeof(DDS_PIXELFORMAT)); break; // DXGI 1.2
-
-        // Legacy D3DX formats using D3DFMT enum value as FourCC
-        case DXGI_FORMAT_R32G32B32A32_FLOAT:
-            ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 116;  // D3DFMT_A32B32G32R32F
-            break;
-        case DXGI_FORMAT_R16G16B16A16_FLOAT:
-            ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 113;  // D3DFMT_A16B16G16R16F
-            break;
-        case DXGI_FORMAT_R16G16B16A16_UNORM:
-            ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 36;  // D3DFMT_A16B16G16R16
-            break;
-        case DXGI_FORMAT_R16G16B16A16_SNORM:
-            ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 110;  // D3DFMT_Q16W16V16U16
-            break;
-        case DXGI_FORMAT_R32G32_FLOAT:
-            ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 115;  // D3DFMT_G32R32F
-            break;
-        case DXGI_FORMAT_R16G16_FLOAT:
-            ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 112;  // D3DFMT_G16R16F
-            break;
-        case DXGI_FORMAT_R32_FLOAT:
-            ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 114;  // D3DFMT_R32F
-            break;
-        case DXGI_FORMAT_R16_FLOAT:
-            ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 111;  // D3DFMT_R16F
-            break;
-
-        // DX9 legacy pixel formats
-        case DXGI_FORMAT_R10G10B10A2_UNORM:
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            {
-                // Write using the 'incorrect' mask version to match D3DX bug
-                memcpy(&ddpf, &DDSPF_A2B10G10R10, sizeof(DDS_PIXELFORMAT));
-            }
-            break;
-
-        case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            {
-                memcpy(&ddpf, &DDSPF_A8B8G8R8, sizeof(DDS_PIXELFORMAT));
-            }
-            break;
-
-        case DXGI_FORMAT_BC1_UNORM_SRGB:
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            {
-                memcpy(&ddpf, &DDSPF_DXT1, sizeof(DDS_PIXELFORMAT));
-            }
-            break;
-
-        case DXGI_FORMAT_BC2_UNORM_SRGB:
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            {
-                memcpy(&ddpf, metadata.IsPMAlpha() ? (&DDSPF_DXT2) : (&DDSPF_DXT3), sizeof(DDS_PIXELFORMAT));
-            }
-            break;
-
-        case DXGI_FORMAT_BC3_UNORM_SRGB:
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            {
-                memcpy(&ddpf, metadata.IsPMAlpha() ? (&DDSPF_DXT4) : (&DDSPF_DXT5), sizeof(DDS_PIXELFORMAT));
-            }
-            break;
-
-        case DXGI_FORMAT_BC4_UNORM:
-            memcpy(&ddpf, &DDSPF_BC4_UNORM, sizeof(DDS_PIXELFORMAT));
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            {
-                ddpf.fourCC = MAKEFOURCC('A', 'T', 'I', '1');
-            }
-            break;
-
-        case DXGI_FORMAT_BC5_UNORM:
-            memcpy(&ddpf, &DDSPF_BC5_UNORM, sizeof(DDS_PIXELFORMAT));
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            {
-                ddpf.fourCC = MAKEFOURCC('A', 'T', 'I', '2');
-            }
-            break;
-
-        case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            {
-                memcpy(&ddpf, &DDSPF_A8R8G8B8, sizeof(DDS_PIXELFORMAT));
-            }
-            break;
-
-        case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-            if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            {
-                memcpy(&ddpf, &DDSPF_X8R8G8B8, sizeof(DDS_PIXELFORMAT));
-            }
-            break;
-
-        default:
-            break;
-        }
-    }
-
-    required = sizeof(uint32_t) + sizeof(DDS_HEADER);
-
-    if (ddpf.size == 0)
-    {
-        if (flags & DDS_FLAGS_FORCE_DX9_LEGACY)
-            return HRESULT_E_CANNOT_MAKE;
-
-        required += sizeof(DDS_HEADER_DXT10);
-    }
-
-    if (!pDestination)
-        return S_OK;
-
-    if (maxsize < required)
-        return E_NOT_SUFFICIENT_BUFFER;
-
-    *static_cast<uint32_t*>(pDestination) = DDS_MAGIC;
-
-    auto header = reinterpret_cast<DDS_HEADER*>(static_cast<uint8_t*>(pDestination) + sizeof(uint32_t));
-    assert(header);
-
-    memset(header, 0, sizeof(DDS_HEADER));
-    header->size = sizeof(DDS_HEADER);
-    header->flags = DDS_HEADER_FLAGS_TEXTURE;
-    header->caps = DDS_SURFACE_FLAGS_TEXTURE;
-
-    if (metadata.mipLevels > 0)
-    {
-        header->flags |= DDS_HEADER_FLAGS_MIPMAP;
-
-        if (metadata.mipLevels > UINT16_MAX)
-            return E_INVALIDARG;
-
-        header->mipMapCount = static_cast<uint32_t>(metadata.mipLevels);
-
-        if (header->mipMapCount > 1)
-            header->caps |= DDS_SURFACE_FLAGS_MIPMAP;
-    }
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-        if (metadata.width > UINT32_MAX)
-            return E_INVALIDARG;
-
-        header->width = static_cast<uint32_t>(metadata.width);
-        header->height = header->depth = 1;
-        break;
-
-    case TEX_DIMENSION_TEXTURE2D:
-        if (metadata.height > UINT32_MAX
-            || metadata.width > UINT32_MAX)
-            return E_INVALIDARG;
-
-        header->height = static_cast<uint32_t>(metadata.height);
-        header->width = static_cast<uint32_t>(metadata.width);
-        header->depth = 1;
-
-        if (metadata.IsCubemap())
-        {
-            header->caps |= DDS_SURFACE_FLAGS_CUBEMAP;
-            header->caps2 |= DDS_CUBEMAP_ALLFACES;
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        if (metadata.height > UINT32_MAX
-            || metadata.width > UINT32_MAX
-            || metadata.depth > UINT16_MAX)
-            return E_INVALIDARG;
-
-        header->flags |= DDS_HEADER_FLAGS_VOLUME;
-        header->caps2 |= DDS_FLAGS_VOLUME;
-        header->height = static_cast<uint32_t>(metadata.height);
-        header->width = static_cast<uint32_t>(metadata.width);
-        header->depth = static_cast<uint32_t>(metadata.depth);
-        break;
-
-    default:
-        return E_FAIL;
-    }
-
-    size_t rowPitch, slicePitch;
-    HRESULT hr = ComputePitch(metadata.format, metadata.width, metadata.height, rowPitch, slicePitch, CP_FLAGS_NONE);
-    if (FAILED(hr))
-        return hr;
-
-    if (slicePitch > UINT32_MAX
-        || rowPitch > UINT32_MAX)
-        return E_FAIL;
-
-    if (IsCompressed(metadata.format))
-    {
-        header->flags |= DDS_HEADER_FLAGS_LINEARSIZE;
-        header->pitchOrLinearSize = static_cast<uint32_t>(slicePitch);
-    }
-    else
-    {
-        header->flags |= DDS_HEADER_FLAGS_PITCH;
-        header->pitchOrLinearSize = static_cast<uint32_t>(rowPitch);
-    }
-
-    if (ddpf.size == 0)
-    {
-        memcpy(&header->ddspf, &DDSPF_DX10, sizeof(DDS_PIXELFORMAT));
-
-        auto ext = reinterpret_cast<DDS_HEADER_DXT10*>(reinterpret_cast<uint8_t*>(header) + sizeof(DDS_HEADER));
-        assert(ext);
-
-        memset(ext, 0, sizeof(DDS_HEADER_DXT10));
-        ext->dxgiFormat = metadata.format;
-        ext->resourceDimension = metadata.dimension;
-
-        if (metadata.arraySize > UINT16_MAX)
-            return E_INVALIDARG;
-
-        static_assert(static_cast<int>(TEX_MISC_TEXTURECUBE) == static_cast<int>(DDS_RESOURCE_MISC_TEXTURECUBE), "DDS header mismatch");
-
-        ext->miscFlag = metadata.miscFlags & ~static_cast<uint32_t>(TEX_MISC_TEXTURECUBE);
-
-        if (metadata.miscFlags & TEX_MISC_TEXTURECUBE)
-        {
-            ext->miscFlag |= TEX_MISC_TEXTURECUBE;
-            assert((metadata.arraySize % 6) == 0);
-            ext->arraySize = static_cast<UINT>(metadata.arraySize / 6);
-        }
-        else
-        {
-            ext->arraySize = static_cast<UINT>(metadata.arraySize);
-        }
-
-        static_assert(static_cast<int>(TEX_MISC2_ALPHA_MODE_MASK) == static_cast<int>(DDS_MISC_FLAGS2_ALPHA_MODE_MASK), "DDS header mismatch");
-
-        static_assert(static_cast<int>(TEX_ALPHA_MODE_UNKNOWN) == static_cast<int>(DDS_ALPHA_MODE_UNKNOWN), "DDS header mismatch");
-        static_assert(static_cast<int>(TEX_ALPHA_MODE_STRAIGHT) == static_cast<int>(DDS_ALPHA_MODE_STRAIGHT), "DDS header mismatch");
-        static_assert(static_cast<int>(TEX_ALPHA_MODE_PREMULTIPLIED) == static_cast<int>(DDS_ALPHA_MODE_PREMULTIPLIED), "DDS header mismatch");
-        static_assert(static_cast<int>(TEX_ALPHA_MODE_OPAQUE) == static_cast<int>(DDS_ALPHA_MODE_OPAQUE), "DDS header mismatch");
-        static_assert(static_cast<int>(TEX_ALPHA_MODE_CUSTOM) == static_cast<int>(DDS_ALPHA_MODE_CUSTOM), "DDS header mismatch");
-
-        if (flags & DDS_FLAGS_FORCE_DX10_EXT_MISC2)
-        {
-            // This was formerly 'reserved'. D3DX10 and D3DX11 will fail if this value is anything other than 0
-            ext->miscFlags2 = metadata.miscFlags2;
-        }
-    }
-    else
-    {
-        memcpy(&header->ddspf, &ddpf, sizeof(ddpf));
-    }
-
-    return S_OK;
-}
-
-
-namespace
-{
-    //-------------------------------------------------------------------------------------
-    // Converts an image row with optional clearing of alpha value to 1.0
-    // Returns true if supported, false if expansion case not supported
-    //-------------------------------------------------------------------------------------
-    enum TEXP_LEGACY_FORMAT
-    {
-        TEXP_LEGACY_UNKNOWN = 0,
-        TEXP_LEGACY_R8G8B8,
-        TEXP_LEGACY_R3G3B2,
-        TEXP_LEGACY_A8R3G3B2,
-        TEXP_LEGACY_P8,
-        TEXP_LEGACY_A8P8,
-        TEXP_LEGACY_A4L4,
-        TEXP_LEGACY_B4G4R4A4,
-        TEXP_LEGACY_L8,
-        TEXP_LEGACY_L16,
-        TEXP_LEGACY_A8L8
-    };
-
-    constexpr TEXP_LEGACY_FORMAT FindLegacyFormat(uint32_t flags) noexcept
-    {
-        TEXP_LEGACY_FORMAT lformat = TEXP_LEGACY_UNKNOWN;
-
-        if (flags & CONV_FLAGS_PAL8)
-        {
-            lformat = (flags & CONV_FLAGS_A8P8) ? TEXP_LEGACY_A8P8 : TEXP_LEGACY_P8;
-        }
-        else if (flags & CONV_FLAGS_888)
-            lformat = TEXP_LEGACY_R8G8B8;
-        else if (flags & CONV_FLAGS_332)
-            lformat = TEXP_LEGACY_R3G3B2;
-        else if (flags & CONV_FLAGS_8332)
-            lformat = TEXP_LEGACY_A8R3G3B2;
-        else if (flags & CONV_FLAGS_44)
-            lformat = TEXP_LEGACY_A4L4;
-        else if (flags & CONV_FLAGS_4444)
-            lformat = TEXP_LEGACY_B4G4R4A4;
-        else if (flags & CONV_FLAGS_L8)
-            lformat = TEXP_LEGACY_L8;
-        else if (flags & CONV_FLAGS_L16)
-            lformat = TEXP_LEGACY_L16;
-        else if (flags & CONV_FLAGS_A8L8)
-            lformat = TEXP_LEGACY_A8L8;
-
-        return lformat;
-    }
-
-    _Success_(return)
-        bool LegacyExpandScanline(
-            _Out_writes_bytes_(outSize) void* pDestination,
-            size_t outSize,
-            _In_ DXGI_FORMAT outFormat,
-            _In_reads_bytes_(inSize) const void* pSource,
-            size_t inSize,
-            _In_ TEXP_LEGACY_FORMAT inFormat,
-            _In_reads_opt_(256) const uint32_t* pal8,
-            _In_ uint32_t tflags) noexcept
-    {
-        assert(pDestination && outSize > 0);
-        assert(pSource && inSize > 0);
-        assert(IsValid(outFormat) && !IsPlanar(outFormat) && !IsPalettized(outFormat));
-
-        switch (inFormat)
-        {
-        case TEXP_LEGACY_R8G8B8:
-            if (outFormat != DXGI_FORMAT_R8G8B8A8_UNORM)
-                return false;
-
-            // D3DFMT_R8G8B8 -> DXGI_FORMAT_R8G8B8A8_UNORM
-            if (inSize >= 3 && outSize >= 4)
-            {
-                const uint8_t * __restrict sPtr = static_cast<const uint8_t*>(pSource);
-                uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-                for (size_t ocount = 0, icount = 0; ((icount < (inSize - 2)) && (ocount < (outSize - 3))); icount += 3, ocount += 4)
-                {
-                    // 24bpp Direct3D 9 files are actually BGR, so need to swizzle as well
-                    uint32_t t1 = uint32_t(*(sPtr) << 16);
-                    uint32_t t2 = uint32_t(*(sPtr + 1) << 8);
-                    uint32_t t3 = uint32_t(*(sPtr + 2));
-
-                    *(dPtr++) = t1 | t2 | t3 | 0xff000000;
-                    sPtr += 3;
-                }
-                return true;
-            }
-            return false;
-
-        case TEXP_LEGACY_R3G3B2:
-            switch (outFormat)
-            {
-            case DXGI_FORMAT_R8G8B8A8_UNORM:
-                // D3DFMT_R3G3B2 -> DXGI_FORMAT_R8G8B8A8_UNORM
-                if (inSize >= 1 && outSize >= 4)
-                {
-                    const uint8_t* __restrict sPtr = static_cast<const uint8_t*>(pSource);
-                    uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-                    for (size_t ocount = 0, icount = 0; ((icount < inSize) && (ocount < (outSize - 3))); ++icount, ocount += 4)
-                    {
-                        const uint8_t t = *(sPtr++);
-
-                        uint32_t t1 = uint32_t((t & 0xe0) | ((t & 0xe0) >> 3) | ((t & 0xc0) >> 6));
-                        uint32_t t2 = uint32_t(((t & 0x1c) << 11) | ((t & 0x1c) << 8) | ((t & 0x18) << 5));
-                        uint32_t t3 = uint32_t(((t & 0x03) << 22) | ((t & 0x03) << 20) | ((t & 0x03) << 18) | ((t & 0x03) << 16));
-
-                        *(dPtr++) = t1 | t2 | t3 | 0xff000000;
-                    }
-                    return true;
-                }
-                return false;
-
-            case DXGI_FORMAT_B5G6R5_UNORM:
-                // D3DFMT_R3G3B2 -> DXGI_FORMAT_B5G6R5_UNORM
-                if (inSize >= 1 && outSize >= 2)
-                {
-                    const uint8_t* __restrict sPtr = static_cast<const uint8_t*>(pSource);
-                    uint16_t * __restrict dPtr = static_cast<uint16_t*>(pDestination);
-
-                    for (size_t ocount = 0, icount = 0; ((icount < inSize) && (ocount < (outSize - 1))); ++icount, ocount += 2)
-                    {
-                        const unsigned t = *(sPtr++);
-
-                        unsigned t1 = ((t & 0xe0u) << 8) | ((t & 0xc0u) << 5);
-                        unsigned t2 = ((t & 0x1cu) << 6) | ((t & 0x1cu) << 3);
-                        unsigned t3 = ((t & 0x03u) << 3) | ((t & 0x03u) << 1) | ((t & 0x02) >> 1);
-
-                        *(dPtr++) = static_cast<uint16_t>(t1 | t2 | t3);
-                    }
-                    return true;
-                }
-                return false;
-
-            default:
-                return false;
-            }
-
-        case TEXP_LEGACY_A8R3G3B2:
-            if (outFormat != DXGI_FORMAT_R8G8B8A8_UNORM)
-                return false;
-
-            // D3DFMT_A8R3G3B2 -> DXGI_FORMAT_R8G8B8A8_UNORM
-            if (inSize >= 2 && outSize >= 4)
-            {
-                const uint16_t* __restrict sPtr = static_cast<const uint16_t*>(pSource);
-                uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-                for (size_t ocount = 0, icount = 0; ((icount < (inSize - 1)) && (ocount < (outSize - 3))); icount += 2, ocount += 4)
-                {
-                    const uint16_t t = *(sPtr++);
-
-                    uint32_t t1 = uint32_t((t & 0x00e0) | ((t & 0x00e0) >> 3) | ((t & 0x00c0) >> 6));
-                    uint32_t t2 = uint32_t(((t & 0x001c) << 11) | ((t & 0x001c) << 8) | ((t & 0x0018) << 5));
-                    uint32_t t3 = uint32_t(((t & 0x0003) << 22) | ((t & 0x0003) << 20) | ((t & 0x0003) << 18) | ((t & 0x0003) << 16));
-                    uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xff000000 : uint32_t((t & 0xff00) << 16);
-
-                    *(dPtr++) = t1 | t2 | t3 | ta;
-                }
-                return true;
-            }
-            return false;
-
-        case TEXP_LEGACY_P8:
-            if ((outFormat != DXGI_FORMAT_R8G8B8A8_UNORM) || !pal8)
-                return false;
-
-            // D3DFMT_P8 -> DXGI_FORMAT_R8G8B8A8_UNORM
-            if (inSize >= 1 && outSize >= 4)
-            {
-                const uint8_t* __restrict sPtr = static_cast<const uint8_t*>(pSource);
-                uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-                for (size_t ocount = 0, icount = 0; ((icount < inSize) && (ocount < (outSize - 3))); ++icount, ocount += 4)
-                {
-                    uint8_t t = *(sPtr++);
-
-                    *(dPtr++) = pal8[t];
-                }
-                return true;
-            }
-            return false;
-
-        case TEXP_LEGACY_A8P8:
-            if ((outFormat != DXGI_FORMAT_R8G8B8A8_UNORM) || !pal8)
-                return false;
-
-            // D3DFMT_A8P8 -> DXGI_FORMAT_R8G8B8A8_UNORM
-            if (inSize >= 2 && outSize >= 4)
-            {
-                const uint16_t* __restrict sPtr = static_cast<const uint16_t*>(pSource);
-                uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-                for (size_t ocount = 0, icount = 0; ((icount < (inSize - 1)) && (ocount < (outSize - 3))); icount += 2, ocount += 4)
-                {
-                    const uint16_t t = *(sPtr++);
-
-                    uint32_t t1 = pal8[t & 0xff];
-                    uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xff000000 : uint32_t((t & 0xff00) << 16);
-
-                    *(dPtr++) = t1 | ta;
-                }
-                return true;
-            }
-            return false;
-
-        case TEXP_LEGACY_A4L4:
-            switch (outFormat)
-            {
-            case DXGI_FORMAT_B4G4R4A4_UNORM:
-                // D3DFMT_A4L4 -> DXGI_FORMAT_B4G4R4A4_UNORM
-                if (inSize >= 1 && outSize >= 2)
-                {
-                    const uint8_t * __restrict sPtr = static_cast<const uint8_t*>(pSource);
-                    uint16_t * __restrict dPtr = static_cast<uint16_t*>(pDestination);
-
-                    for (size_t ocount = 0, icount = 0; ((icount < inSize) && (ocount < (outSize - 1))); ++icount, ocount += 2)
-                    {
-                        const unsigned t = *(sPtr++);
-
-                        unsigned t1 = (t & 0x0fu);
-                        unsigned ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xf000u : ((t & 0xf0u) << 8);
-
-                        *(dPtr++) = static_cast<uint16_t>(t1 | (t1 << 4) | (t1 << 8) | ta);
-                    }
-                    return true;
-                }
-                return false;
-
-            case DXGI_FORMAT_R8G8B8A8_UNORM:
-                // D3DFMT_A4L4 -> DXGI_FORMAT_R8G8B8A8_UNORM
-                if (inSize >= 1 && outSize >= 4)
-                {
-                    const uint8_t * __restrict sPtr = static_cast<const uint8_t*>(pSource);
-                    uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-                    for (size_t ocount = 0, icount = 0; ((icount < inSize) && (ocount < (outSize - 3))); ++icount, ocount += 4)
-                    {
-                        const uint8_t t = *(sPtr++);
-
-                        uint32_t t1 = uint32_t(((t & 0x0f) << 4) | (t & 0x0f));
-                        uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xff000000 : uint32_t(((t & 0xf0) << 24) | ((t & 0xf0) << 20));
-
-                        *(dPtr++) = t1 | (t1 << 8) | (t1 << 16) | ta;
-                    }
-                    return true;
-                }
-                return false;
-
-            default:
-                return false;
-            }
-
-        case TEXP_LEGACY_B4G4R4A4:
-            if (outFormat != DXGI_FORMAT_R8G8B8A8_UNORM)
-                return false;
-
-            // D3DFMT_A4R4G4B4 -> DXGI_FORMAT_R8G8B8A8_UNORM
-            if (inSize >= 2 && outSize >= 4)
-            {
-                const uint16_t * __restrict sPtr = static_cast<const uint16_t*>(pSource);
-                uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-                for (size_t ocount = 0, icount = 0; ((icount < (inSize - 1)) && (ocount < (outSize - 3))); icount += 2, ocount += 4)
-                {
-                    const uint32_t t = *(sPtr++);
-
-                    uint32_t t1 = uint32_t((t & 0x0f00) >> 4) | ((t & 0x0f00) >> 8);
-                    uint32_t t2 = uint32_t((t & 0x00f0) << 8) | ((t & 0x00f0) << 4);
-                    uint32_t t3 = uint32_t((t & 0x000f) << 20) | ((t & 0x000f) << 16);
-                    uint32_t ta = uint32_t((tflags & TEXP_SCANLINE_SETALPHA) ? 0xff000000 : (((t & 0xf000) << 16) | ((t & 0xf000) << 12)));
-
-                    *(dPtr++) = t1 | t2 | t3 | ta;
-                }
-                return true;
-            }
-            return false;
-
-        case TEXP_LEGACY_L8:
-            if (outFormat != DXGI_FORMAT_R8G8B8A8_UNORM)
-                return false;
-
-            // D3DFMT_L8 -> DXGI_FORMAT_R8G8B8A8_UNORM
-            if (inSize >= 1 && outSize >= 4)
-            {
-                const uint8_t * __restrict sPtr = static_cast<const uint8_t*>(pSource);
-                uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-                for (size_t ocount = 0, icount = 0; ((icount < inSize) && (ocount < (outSize - 3))); ++icount, ocount += 4)
-                {
-                    uint32_t t1 = *(sPtr++);
-                    uint32_t t2 = (t1 << 8);
-                    uint32_t t3 = (t1 << 16);
-
-                    *(dPtr++) = t1 | t2 | t3 | 0xff000000;
-                }
-                return true;
-            }
-            return false;
-
-        case TEXP_LEGACY_L16:
-            if (outFormat != DXGI_FORMAT_R16G16B16A16_UNORM)
-                return false;
-
-            // D3DFMT_L16 -> DXGI_FORMAT_R16G16B16A16_UNORM
-            if (inSize >= 2 && outSize >= 8)
-            {
-                const uint16_t* __restrict sPtr = static_cast<const uint16_t*>(pSource);
-                uint64_t * __restrict dPtr = static_cast<uint64_t*>(pDestination);
-
-                for (size_t ocount = 0, icount = 0; ((icount < (inSize - 1)) && (ocount < (outSize - 7))); icount += 2, ocount += 8)
-                {
-                    const uint16_t t = *(sPtr++);
-
-                    uint64_t t1 = t;
-                    uint64_t t2 = (t1 << 16);
-                    uint64_t t3 = (t1 << 32);
-
-                    *(dPtr++) = t1 | t2 | t3 | 0xffff000000000000;
-                }
-                return true;
-            }
-            return false;
-
-        case TEXP_LEGACY_A8L8:
-            if (outFormat != DXGI_FORMAT_R8G8B8A8_UNORM)
-                return false;
-
-            // D3DFMT_A8L8 -> DXGI_FORMAT_R8G8B8A8_UNORM
-            if (inSize >= 2 && outSize >= 4)
-            {
-                const uint16_t* __restrict sPtr = static_cast<const uint16_t*>(pSource);
-                uint32_t * __restrict dPtr = static_cast<uint32_t*>(pDestination);
-
-                for (size_t ocount = 0, icount = 0; ((icount < (inSize - 1)) && (ocount < (outSize - 3))); icount += 2, ocount += 4)
-                {
-                    const uint16_t t = *(sPtr++);
-
-                    uint32_t t1 = uint32_t(t & 0xff);
-                    uint32_t t2 = uint32_t(t1 << 8);
-                    uint32_t t3 = uint32_t(t1 << 16);
-                    uint32_t ta = (tflags & TEXP_SCANLINE_SETALPHA) ? 0xff000000 : uint32_t((t & 0xff00) << 16);
-
-                    *(dPtr++) = t1 | t2 | t3 | ta;
-                }
-                return true;
-            }
-            return false;
-
-        default:
-            return false;
-        }
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Converts or copies image data from pPixels into scratch image data
-    //-------------------------------------------------------------------------------------
-    HRESULT CopyImage(
-        _In_reads_bytes_(size) const void* pPixels,
-        _In_ size_t size,
-        _In_ const TexMetadata& metadata,
-        _In_ CP_FLAGS cpFlags,
-        _In_ uint32_t convFlags,
-        _In_reads_opt_(256) const uint32_t *pal8,
-        _In_ const ScratchImage& image) noexcept
-    {
-        assert(pPixels);
-        assert(image.GetPixels());
-
-        if (!size)
-            return E_FAIL;
-
-        if (convFlags & CONV_FLAGS_EXPAND)
-        {
-            if (convFlags & CONV_FLAGS_888)
-                cpFlags |= CP_FLAGS_24BPP;
-            else if (convFlags & (CONV_FLAGS_565 | CONV_FLAGS_5551 | CONV_FLAGS_4444 | CONV_FLAGS_8332 | CONV_FLAGS_A8P8 | CONV_FLAGS_L16 | CONV_FLAGS_A8L8))
-                cpFlags |= CP_FLAGS_16BPP;
-            else if (convFlags & (CONV_FLAGS_44 | CONV_FLAGS_332 | CONV_FLAGS_PAL8 | CONV_FLAGS_L8))
-                cpFlags |= CP_FLAGS_8BPP;
-        }
-
-        size_t pixelSize, nimages;
-        if (!DetermineImageArray(metadata, cpFlags, nimages, pixelSize))
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-        if ((nimages == 0) || (nimages != image.GetImageCount()))
-        {
-            return E_FAIL;
-        }
-
-        if (pixelSize > size)
-        {
-            return HRESULT_E_HANDLE_EOF;
-        }
-
-        std::unique_ptr<Image[]> timages(new (std::nothrow) Image[nimages]);
-        if (!timages)
-        {
-            return E_OUTOFMEMORY;
-        }
-
-        if (!SetupImageArray(
-            const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(pPixels)),
-            pixelSize,
-            metadata,
-            cpFlags,
-            timages.get(),
-            nimages))
-        {
-            return E_FAIL;
-        }
-
-        if (nimages != image.GetImageCount())
-        {
-            return E_FAIL;
-        }
-
-        const Image* images = image.GetImages();
-        if (!images)
-        {
-            return E_FAIL;
-        }
-
-        uint32_t tflags = (convFlags & CONV_FLAGS_NOALPHA) ? TEXP_SCANLINE_SETALPHA : 0u;
-        if (convFlags & CONV_FLAGS_SWIZZLE)
-            tflags |= TEXP_SCANLINE_LEGACY;
-
-        switch (metadata.dimension)
-        {
-        case TEX_DIMENSION_TEXTURE1D:
-        case TEX_DIMENSION_TEXTURE2D:
-            {
-                size_t index = 0;
-                for (size_t item = 0; item < metadata.arraySize; ++item)
-                {
-                    size_t lastgood = 0;
-                    for (size_t level = 0; level < metadata.mipLevels; ++level, ++index)
-                    {
-                        if (index >= nimages)
-                            return E_FAIL;
-
-                        if (images[index].height != timages[index].height)
-                            return E_FAIL;
-
-                        size_t dpitch = images[index].rowPitch;
-                        const size_t spitch = timages[index].rowPitch;
-
-                        const uint8_t *pSrc = timages[index].pixels;
-                        if (!pSrc)
-                            return E_POINTER;
-
-                        uint8_t *pDest = images[index].pixels;
-                        if (!pDest)
-                            return E_POINTER;
-
-                        if (IsCompressed(metadata.format))
-                        {
-                            size_t csize = std::min<size_t>(images[index].slicePitch, timages[index].slicePitch);
-                            memcpy(pDest, pSrc, csize);
-
-                            if (cpFlags & CP_FLAGS_BAD_DXTN_TAILS)
-                            {
-                                if (images[index].width < 4 || images[index].height < 4)
-                                {
-                                    csize = std::min<size_t>(images[index].slicePitch, timages[lastgood].slicePitch);
-                                    memcpy(pDest, timages[lastgood].pixels, csize);
-                                }
-                                else
-                                {
-                                    lastgood = index;
-                                }
-                            }
-                        }
-                        else if (IsPlanar(metadata.format))
-                        {
-                            const size_t count = ComputeScanlines(metadata.format, images[index].height);
-                            if (!count)
-                                return E_UNEXPECTED;
-
-                            const size_t csize = std::min<size_t>(dpitch, spitch);
-                            for (size_t h = 0; h < count; ++h)
-                            {
-                                memcpy(pDest, pSrc, csize);
-                                pSrc += spitch;
-                                pDest += dpitch;
-                            }
-                        }
-                        else
-                        {
-                            for (size_t h = 0; h < images[index].height; ++h)
-                            {
-                                if (convFlags & CONV_FLAGS_EXPAND)
-                                {
-                                    if (convFlags & (CONV_FLAGS_565 | CONV_FLAGS_5551 | CONV_FLAGS_4444))
-                                    {
-                                        if (!ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM,
-                                            pSrc, spitch,
-                                            (convFlags & CONV_FLAGS_565) ? DXGI_FORMAT_B5G6R5_UNORM : DXGI_FORMAT_B5G5R5A1_UNORM,
-                                            tflags))
-                                            return E_FAIL;
-                                    }
-                                    else
-                                    {
-                                        const TEXP_LEGACY_FORMAT lformat = FindLegacyFormat(convFlags);
-                                        if (!LegacyExpandScanline(pDest, dpitch, metadata.format,
-                                            pSrc, spitch, lformat, pal8,
-                                            tflags))
-                                            return E_FAIL;
-                                    }
-                                }
-                                else if (convFlags & CONV_FLAGS_SWIZZLE)
-                                {
-                                    SwizzleScanline(pDest, dpitch, pSrc, spitch,
-                                        metadata.format, tflags);
-                                }
-                                else
-                                {
-                                    CopyScanline(pDest, dpitch, pSrc, spitch,
-                                        metadata.format, tflags);
-                                }
-
-                                pSrc += spitch;
-                                pDest += dpitch;
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-
-        case TEX_DIMENSION_TEXTURE3D:
-            {
-                size_t index = 0;
-                size_t d = metadata.depth;
-
-                size_t lastgood = 0;
-                for (size_t level = 0; level < metadata.mipLevels; ++level)
-                {
-                    for (size_t slice = 0; slice < d; ++slice, ++index)
-                    {
-                        if (index >= nimages)
-                            return E_FAIL;
-
-                        if (images[index].height != timages[index].height)
-                            return E_FAIL;
-
-                        size_t dpitch = images[index].rowPitch;
-                        const size_t spitch = timages[index].rowPitch;
-
-                        const uint8_t *pSrc = timages[index].pixels;
-                        if (!pSrc)
-                            return E_POINTER;
-
-                        uint8_t *pDest = images[index].pixels;
-                        if (!pDest)
-                            return E_POINTER;
-
-                        if (IsCompressed(metadata.format))
-                        {
-                            size_t csize = std::min<size_t>(images[index].slicePitch, timages[index].slicePitch);
-                            memcpy(pDest, pSrc, csize);
-
-                            if (cpFlags & CP_FLAGS_BAD_DXTN_TAILS)
-                            {
-                                if (images[index].width < 4 || images[index].height < 4)
-                                {
-                                    csize = std::min<size_t>(images[index].slicePitch, timages[lastgood + slice].slicePitch);
-                                    memcpy(pDest, timages[lastgood + slice].pixels, csize);
-                                }
-                                else if (!slice)
-                                {
-                                    lastgood = index;
-                                }
-                            }
-                        }
-                        else if (IsPlanar(metadata.format))
-                        {
-                            // Direct3D does not support any planar formats for Texture3D
-                            return HRESULT_E_NOT_SUPPORTED;
-                        }
-                        else
-                        {
-                            for (size_t h = 0; h < images[index].height; ++h)
-                            {
-                                if (convFlags & CONV_FLAGS_EXPAND)
-                                {
-                                    if (convFlags & (CONV_FLAGS_565 | CONV_FLAGS_5551 | CONV_FLAGS_4444))
-                                    {
-                                        if (!ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM,
-                                            pSrc, spitch,
-                                            (convFlags & CONV_FLAGS_565) ? DXGI_FORMAT_B5G6R5_UNORM : DXGI_FORMAT_B5G5R5A1_UNORM,
-                                            tflags))
-                                            return E_FAIL;
-                                    }
-                                    else
-                                    {
-                                        const TEXP_LEGACY_FORMAT lformat = FindLegacyFormat(convFlags);
-                                        if (!LegacyExpandScanline(pDest, dpitch, metadata.format,
-                                            pSrc, spitch, lformat, pal8,
-                                            tflags))
-                                            return E_FAIL;
-                                    }
-                                }
-                                else if (convFlags & CONV_FLAGS_SWIZZLE)
-                                {
-                                    SwizzleScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags);
-                                }
-                                else
-                                {
-                                    CopyScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags);
-                                }
-
-                                pSrc += spitch;
-                                pDest += dpitch;
-                            }
-                        }
-                    }
-
-                    if (d > 1)
-                        d >>= 1;
-                }
-            }
-            break;
-
-        default:
-            return E_FAIL;
-        }
-
-        return S_OK;
-    }
-
-    HRESULT CopyImageInPlace(uint32_t convFlags, _In_ const ScratchImage& image) noexcept
-    {
-        if (!image.GetPixels())
-            return E_FAIL;
-
-        const Image* images = image.GetImages();
-        if (!images)
-            return E_FAIL;
-
-        const TexMetadata& metadata = image.GetMetadata();
-
-        if (IsPlanar(metadata.format))
-            return HRESULT_E_NOT_SUPPORTED;
-
-        uint32_t tflags = (convFlags & CONV_FLAGS_NOALPHA) ? TEXP_SCANLINE_SETALPHA : 0u;
-        if (convFlags & CONV_FLAGS_SWIZZLE)
-            tflags |= TEXP_SCANLINE_LEGACY;
-
-        for (size_t i = 0; i < image.GetImageCount(); ++i)
-        {
-            const Image* img = &images[i];
-            uint8_t *pPixels = img->pixels;
-            if (!pPixels)
-                return E_POINTER;
-
-            size_t rowPitch = img->rowPitch;
-
-            for (size_t h = 0; h < img->height; ++h)
-            {
-                if (convFlags & CONV_FLAGS_SWIZZLE)
-                {
-                    SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags);
-                }
-                else
-                {
-                    CopyScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags);
-                }
-
-                pPixels += rowPitch;
-            }
-        }
-
-        return S_OK;
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Obtain metadata from DDS file in memory/on disk
-//-------------------------------------------------------------------------------------
-
-_Use_decl_annotations_
-HRESULT DirectX::GetMetadataFromDDSMemory(
-    const void* pSource,
-    size_t size,
-    DDS_FLAGS flags,
-    TexMetadata& metadata) noexcept
-{
-    if (!pSource || size == 0)
-        return E_INVALIDARG;
-
-    uint32_t convFlags = 0;
-    return DecodeDDSHeader(pSource, size, flags, metadata, convFlags);
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::GetMetadataFromDDSFile(
-    const wchar_t* szFile,
-    DDS_FLAGS flags,
-    TexMetadata& metadata) noexcept
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-#ifdef _WIN32
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
-    ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
-#else
-    ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
-        FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
-#endif
-    if (!hFile)
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // Get the file size
-    FILE_STANDARD_INFO fileInfo;
-    if (!GetFileInformationByHandleEx(hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo)))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // File is too big for 32-bit allocation, so reject read (4 GB should be plenty large enough for a valid DDS file)
-    if (fileInfo.EndOfFile.HighPart > 0)
-    {
-        return HRESULT_E_FILE_TOO_LARGE;
-    }
-
-    const size_t len = fileInfo.EndOfFile.LowPart;
-#else // !WIN32
-    std::ifstream inFile(std::filesystem::path(szFile), std::ios::in | std::ios::binary | std::ios::ate);
-    if (!inFile)
-        return E_FAIL;
-
-    std::streampos fileLen = inFile.tellg();
-    if (!inFile)
-        return E_FAIL;
-
-    if (fileLen > UINT32_MAX)
-        return HRESULT_E_FILE_TOO_LARGE;
-
-    inFile.seekg(0, std::ios::beg);
-    if (!inFile)
-        return E_FAIL;
-
-    const size_t len = fileLen;
-#endif
-
-    // Need at least enough data to fill the standard header and magic number to be a valid DDS
-    if (len < (sizeof(DDS_HEADER) + sizeof(uint32_t)))
-    {
-        return E_FAIL;
-    }
-
-    // Read the header in (including extended header if present)
-    uint8_t header[MAX_HEADER_SIZE] = {};
-
-#ifdef _WIN32
-    DWORD bytesRead = 0;
-    if (!ReadFile(hFile.get(), header, MAX_HEADER_SIZE, &bytesRead, nullptr))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    auto const headerLen = static_cast<size_t>(bytesRead);
-#else
-    auto const headerLen = std::min<size_t>(len, MAX_HEADER_SIZE);
-
-    inFile.read(reinterpret_cast<char*>(header), headerLen);
-    if (!inFile)
-        return E_FAIL;
-#endif
-
-    uint32_t convFlags = 0;
-    return DecodeDDSHeader(header, headerLen, flags, metadata, convFlags);
-}
-
-
-//-------------------------------------------------------------------------------------
-// Load a DDS file in memory
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::LoadFromDDSMemory(
-    const void* pSource,
-    size_t size,
-    DDS_FLAGS flags,
-    TexMetadata* metadata,
-    ScratchImage& image) noexcept
-{
-    if (!pSource || size == 0)
-        return E_INVALIDARG;
-
-    image.Release();
-
-    uint32_t convFlags = 0;
-    TexMetadata mdata;
-    HRESULT hr = DecodeDDSHeader(pSource, size, flags, mdata, convFlags);
-    if (FAILED(hr))
-        return hr;
-
-    size_t offset = sizeof(uint32_t) + sizeof(DDS_HEADER);
-    if (convFlags & CONV_FLAGS_DX10)
-        offset += sizeof(DDS_HEADER_DXT10);
-
-    assert(offset <= size);
-
-    const uint32_t *pal8 = nullptr;
-    if (convFlags & CONV_FLAGS_PAL8)
-    {
-        pal8 = reinterpret_cast<const uint32_t*>(static_cast<const uint8_t*>(pSource) + offset);
-        assert(pal8);
-        offset += (256 * sizeof(uint32_t));
-        if (size < offset)
-            return E_FAIL;
-    }
-
-    hr = image.Initialize(mdata);
-    if (FAILED(hr))
-        return hr;
-
-    CP_FLAGS cflags = CP_FLAGS_NONE;
-    if (flags & DDS_FLAGS_LEGACY_DWORD)
-    {
-        cflags |= CP_FLAGS_LEGACY_DWORD;
-    }
-    if (flags & DDS_FLAGS_BAD_DXTN_TAILS)
-    {
-        cflags |= CP_FLAGS_BAD_DXTN_TAILS;
-    }
-
-    const void* pPixels = static_cast<const uint8_t*>(pSource) + offset;
-    assert(pPixels);
-    hr = CopyImage(pPixels,
-        size - offset,
-        mdata,
-        cflags,
-        convFlags,
-        pal8,
-        image);
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-    if (metadata)
-        memcpy(metadata, &mdata, sizeof(TexMetadata));
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Load a DDS file from disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::LoadFromDDSFile(
-    const wchar_t* szFile,
-    DDS_FLAGS flags,
-    TexMetadata* metadata,
-    ScratchImage& image) noexcept
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-    image.Release();
-
-#ifdef _WIN32
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
-    ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
-#else
-    ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
-        FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
-#endif
-    if (!hFile)
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // Get the file size
-    FILE_STANDARD_INFO fileInfo;
-    if (!GetFileInformationByHandleEx(hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo)))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // File is too big for 32-bit allocation, so reject read (4 GB should be plenty large enough for a valid DDS file)
-    if (fileInfo.EndOfFile.HighPart > 0)
-        return HRESULT_E_FILE_TOO_LARGE;
-
-    const size_t len = fileInfo.EndOfFile.LowPart;
-#else // !WIN32
-    std::ifstream inFile(std::filesystem::path(szFile), std::ios::in | std::ios::binary | std::ios::ate);
-    if (!inFile)
-        return E_FAIL;
-
-    std::streampos fileLen = inFile.tellg();
-    if (!inFile)
-        return E_FAIL;
-
-    if (fileLen > UINT32_MAX)
-        return HRESULT_E_FILE_TOO_LARGE;
-
-    inFile.seekg(0, std::ios::beg);
-    if (!inFile)
-        return E_FAIL;
-
-    const size_t len = fileLen;
-#endif
-
-    // Need at least enough data to fill the standard header and magic number to be a valid DDS
-    if (len < (sizeof(DDS_HEADER) + sizeof(uint32_t)))
-    {
-        return E_FAIL;
-    }
-
-    // Read the header in (including extended header if present)
-    uint8_t header[MAX_HEADER_SIZE] = {};
-
-#ifdef _WIN32
-    DWORD bytesRead = 0;
-    if (!ReadFile(hFile.get(), header, MAX_HEADER_SIZE, &bytesRead, nullptr))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    auto const headerLen = static_cast<size_t>(bytesRead);
-#else
-    auto const headerLen = std::min<size_t>(len, MAX_HEADER_SIZE);
-
-    inFile.read(reinterpret_cast<char*>(header), headerLen);
-    if (!inFile)
-        return E_FAIL;
-#endif
-
-    uint32_t convFlags = 0;
-    TexMetadata mdata;
-    HRESULT hr = DecodeDDSHeader(header, headerLen, flags, mdata, convFlags);
-    if (FAILED(hr))
-        return hr;
-
-    size_t offset = MAX_HEADER_SIZE;
-
-    if (!(convFlags & CONV_FLAGS_DX10))
-    {
-    #ifdef _WIN32
-            // Must reset file position since we read more than the standard header above
-        const LARGE_INTEGER filePos = { { sizeof(uint32_t) + sizeof(DDS_HEADER), 0 } };
-        if (!SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN))
-        {
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-    #else
-        inFile.seekg(sizeof(uint32_t) + sizeof(DDS_HEADER), std::ios::beg);
-        if (!inFile)
-            return E_FAIL;
-    #endif
-
-        offset = sizeof(uint32_t) + sizeof(DDS_HEADER);
-    }
-
-    std::unique_ptr<uint32_t[]> pal8;
-    if (convFlags & CONV_FLAGS_PAL8)
-    {
-        pal8.reset(new (std::nothrow) uint32_t[256]);
-        if (!pal8)
-        {
-            return E_OUTOFMEMORY;
-        }
-
-    #ifdef _WIN32
-        if (!ReadFile(hFile.get(), pal8.get(), 256 * sizeof(uint32_t), &bytesRead, nullptr))
-        {
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesRead != (256 * sizeof(uint32_t)))
-        {
-            return E_FAIL;
-        }
-    #else
-        inFile.read(reinterpret_cast<char*>(pal8.get()), 256 * sizeof(uint32_t));
-        if (!inFile)
-            return E_FAIL;
-    #endif
-
-        offset += (256 * sizeof(uint32_t));
-    }
-
-    const size_t remaining = len - offset;
-    if (remaining == 0)
-        return E_FAIL;
-
-    hr = image.Initialize(mdata);
-    if (FAILED(hr))
-        return hr;
-
-    if ((convFlags & CONV_FLAGS_EXPAND) || (flags & (DDS_FLAGS_LEGACY_DWORD | DDS_FLAGS_BAD_DXTN_TAILS)))
-    {
-        std::unique_ptr<uint8_t[]> temp(new (std::nothrow) uint8_t[remaining]);
-        if (!temp)
-        {
-            image.Release();
-            return E_OUTOFMEMORY;
-        }
-
-    #ifdef _WIN32
-        if (!ReadFile(hFile.get(), temp.get(), static_cast<DWORD>(remaining), &bytesRead, nullptr))
-        {
-            image.Release();
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesRead != remaining)
-        {
-            image.Release();
-            return E_FAIL;
-        }
-    #else
-        inFile.read(reinterpret_cast<char*>(temp.get()), remaining);
-        if (!inFile)
-        {
-            image.Release();
-            return E_FAIL;
-        }
-    #endif
-
-        CP_FLAGS cflags = CP_FLAGS_NONE;
-        if (flags & DDS_FLAGS_LEGACY_DWORD)
-        {
-            cflags |= CP_FLAGS_LEGACY_DWORD;
-        }
-        if (flags & DDS_FLAGS_BAD_DXTN_TAILS)
-        {
-            cflags |= CP_FLAGS_BAD_DXTN_TAILS;
-        }
-
-        hr = CopyImage(temp.get(),
-            remaining,
-            mdata,
-            cflags,
-            convFlags,
-            pal8.get(),
-            image);
-        if (FAILED(hr))
-        {
-            image.Release();
-            return hr;
-        }
-    }
-    else
-    {
-        if (remaining < image.GetPixelsSize())
-        {
-            image.Release();
-            return HRESULT_E_HANDLE_EOF;
-        }
-
-        if (image.GetPixelsSize() > UINT32_MAX)
-        {
-            image.Release();
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-        }
-
-    #ifdef _WIN32
-        auto const pixelBytes = static_cast<DWORD>(image.GetPixelsSize());
-        if (!ReadFile(hFile.get(), image.GetPixels(), pixelBytes, &bytesRead, nullptr))
-        {
-            image.Release();
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesRead != pixelBytes)
-        {
-            image.Release();
-            return E_FAIL;
-        }
-    #else
-        inFile.read(reinterpret_cast<char*>(image.GetPixels()), image.GetPixelsSize());
-        if (!inFile)
-        {
-            image.Release();
-            return E_FAIL;
-        }
-    #endif
-
-        if (convFlags & (CONV_FLAGS_SWIZZLE | CONV_FLAGS_NOALPHA))
-        {
-            // Swizzle/copy image in place
-            hr = CopyImageInPlace(convFlags, image);
-            if (FAILED(hr))
-            {
-                image.Release();
-                return hr;
-            }
-        }
-    }
-
-    if (metadata)
-        memcpy(metadata, &mdata, sizeof(TexMetadata));
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a DDS file to memory
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::SaveToDDSMemory(
-    const Image* images,
-    size_t nimages,
-    const TexMetadata& metadata,
-    DDS_FLAGS flags,
-    Blob& blob) noexcept
-{
-    if (!images || (nimages == 0))
-        return E_INVALIDARG;
-
-    // Determine memory required
-    size_t required = 0;
-    HRESULT hr = EncodeDDSHeader(metadata, flags, nullptr, 0, required);
-    if (FAILED(hr))
-        return hr;
-
-    bool fastpath = true;
-
-    for (size_t i = 0; i < nimages; ++i)
-    {
-        if (!images[i].pixels)
-            return E_POINTER;
-
-        if (images[i].format != metadata.format)
-            return E_FAIL;
-
-        size_t ddsRowPitch, ddsSlicePitch;
-        hr = ComputePitch(metadata.format, images[i].width, images[i].height, ddsRowPitch, ddsSlicePitch, CP_FLAGS_NONE);
-        if (FAILED(hr))
-            return hr;
-
-        assert(images[i].rowPitch > 0);
-        assert(images[i].slicePitch > 0);
-
-        if ((images[i].rowPitch != ddsRowPitch) || (images[i].slicePitch != ddsSlicePitch))
-        {
-            fastpath = false;
-        }
-
-        required += ddsSlicePitch;
-    }
-
-    assert(required > 0);
-
-    blob.Release();
-
-    hr = blob.Initialize(required);
-    if (FAILED(hr))
-        return hr;
-
-    auto pDestination = static_cast<uint8_t*>(blob.GetBufferPointer());
-    assert(pDestination);
-
-    hr = EncodeDDSHeader(metadata, flags, pDestination, blob.GetBufferSize(), required);
-    if (FAILED(hr))
-    {
-        blob.Release();
-        return hr;
-    }
-
-    size_t remaining = blob.GetBufferSize() - required;
-    pDestination += required;
-
-    if (!remaining)
-    {
-        blob.Release();
-        return E_FAIL;
-    }
-
-    switch (static_cast<DDS_RESOURCE_DIMENSION>(metadata.dimension))
-    {
-    case DDS_DIMENSION_TEXTURE1D:
-    case DDS_DIMENSION_TEXTURE2D:
-        {
-            size_t index = 0;
-            for (size_t item = 0; item < metadata.arraySize; ++item)
-            {
-                for (size_t level = 0; level < metadata.mipLevels; ++level)
-                {
-                    if (index >= nimages)
-                    {
-                        blob.Release();
-                        return E_FAIL;
-                    }
-
-                    if (fastpath)
-                    {
-                        size_t pixsize = images[index].slicePitch;
-                        memcpy(pDestination, images[index].pixels, pixsize);
-
-                        pDestination += pixsize;
-                        remaining -= pixsize;
-                    }
-                    else
-                    {
-                        size_t ddsRowPitch, ddsSlicePitch;
-                        hr = ComputePitch(metadata.format, images[index].width, images[index].height, ddsRowPitch, ddsSlicePitch, CP_FLAGS_NONE);
-                        if (FAILED(hr))
-                        {
-                            blob.Release();
-                            return hr;
-                        }
-
-                        const size_t rowPitch = images[index].rowPitch;
-
-                        const uint8_t * __restrict sPtr = images[index].pixels;
-                        uint8_t * __restrict dPtr = pDestination;
-
-                        const size_t lines = ComputeScanlines(metadata.format, images[index].height);
-                        const size_t csize = std::min<size_t>(rowPitch, ddsRowPitch);
-                        size_t tremaining = remaining;
-                        for (size_t j = 0; j < lines; ++j)
-                        {
-                            if (tremaining < csize)
-                            {
-                                blob.Release();
-                                return E_FAIL;
-                            }
-
-                            memcpy(dPtr, sPtr, csize);
-
-                            sPtr += rowPitch;
-                            dPtr += ddsRowPitch;
-                            tremaining -= ddsRowPitch;
-                        }
-
-                        pDestination += ddsSlicePitch;
-                        remaining -= ddsSlicePitch;
-                    }
-
-                    ++index;
-                }
-            }
-        }
-        break;
-
-    case DDS_DIMENSION_TEXTURE3D:
-        {
-            if (metadata.arraySize != 1)
-            {
-                blob.Release();
-                return E_FAIL;
-            }
-
-            size_t d = metadata.depth;
-
-            size_t index = 0;
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                for (size_t slice = 0; slice < d; ++slice)
-                {
-                    if (index >= nimages)
-                    {
-                        blob.Release();
-                        return E_FAIL;
-                    }
-
-                    if (fastpath)
-                    {
-                        size_t pixsize = images[index].slicePitch;
-                        memcpy(pDestination, images[index].pixels, pixsize);
-
-                        pDestination += pixsize;
-                        remaining -= pixsize;
-                    }
-                    else
-                    {
-                        size_t ddsRowPitch, ddsSlicePitch;
-                        hr = ComputePitch(metadata.format, images[index].width, images[index].height, ddsRowPitch, ddsSlicePitch, CP_FLAGS_NONE);
-                        if (FAILED(hr))
-                        {
-                            blob.Release();
-                            return hr;
-                        }
-
-                        const size_t rowPitch = images[index].rowPitch;
-
-                        const uint8_t * __restrict sPtr = images[index].pixels;
-                        uint8_t * __restrict dPtr = pDestination;
-
-                        const size_t lines = ComputeScanlines(metadata.format, images[index].height);
-                        const size_t csize = std::min<size_t>(rowPitch, ddsRowPitch);
-                        size_t tremaining = remaining;
-                        for (size_t j = 0; j < lines; ++j)
-                        {
-                            if (tremaining < csize)
-                            {
-                                blob.Release();
-                                return E_FAIL;
-                            }
-
-                            memcpy(dPtr, sPtr, csize);
-
-                            sPtr += rowPitch;
-                            dPtr += ddsRowPitch;
-                            tremaining -= ddsRowPitch;
-                        }
-
-                        pDestination += ddsSlicePitch;
-                        remaining -= ddsSlicePitch;
-                    }
-
-                    ++index;
-                }
-
-                if (d > 1)
-                    d >>= 1;
-            }
-        }
-        break;
-
-    default:
-        blob.Release();
-        return E_FAIL;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a DDS file to disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::SaveToDDSFile(
-    const Image* images,
-    size_t nimages,
-    const TexMetadata& metadata,
-    DDS_FLAGS flags,
-    const wchar_t* szFile) noexcept
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-    // Create DDS Header
-    uint8_t header[MAX_HEADER_SIZE];
-    size_t required;
-    HRESULT hr = EncodeDDSHeader(metadata, flags, header, MAX_HEADER_SIZE, required);
-    if (FAILED(hr))
-        return hr;
-
-    // Create file and write header
-#ifdef _WIN32
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
-    ScopedHandle hFile(safe_handle(CreateFile2(szFile,
-        GENERIC_WRITE | DELETE, 0, CREATE_ALWAYS, nullptr)));
-#else
-    ScopedHandle hFile(safe_handle(CreateFileW(szFile,
-        GENERIC_WRITE | DELETE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr)));
-#endif
-    if (!hFile)
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    auto_delete_file delonfail(hFile.get());
-
-    DWORD bytesWritten;
-    if (!WriteFile(hFile.get(), header, static_cast<DWORD>(required), &bytesWritten, nullptr))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    if (bytesWritten != required)
-    {
-        return E_FAIL;
-    }
-#else // !WIN32
-    std::ofstream outFile(std::filesystem::path(szFile), std::ios::out | std::ios::binary | std::ios::trunc);
-    if (!outFile)
-        return E_FAIL;
-
-    outFile.write(reinterpret_cast<char*>(header), static_cast<std::streamsize>(required));
-    if (!outFile)
-        return E_FAIL;
-#endif
-
-    // Write images
-    switch (static_cast<DDS_RESOURCE_DIMENSION>(metadata.dimension))
-    {
-    case DDS_DIMENSION_TEXTURE1D:
-    case DDS_DIMENSION_TEXTURE2D:
-        {
-            size_t index = 0;
-            for (size_t item = 0; item < metadata.arraySize; ++item)
-            {
-                for (size_t level = 0; level < metadata.mipLevels; ++level, ++index)
-                {
-                    if (index >= nimages)
-                        return E_FAIL;
-
-                    if (!images[index].pixels)
-                        return E_POINTER;
-
-                    assert(images[index].rowPitch > 0);
-                    assert(images[index].slicePitch > 0);
-
-                    size_t ddsRowPitch, ddsSlicePitch;
-                    hr = ComputePitch(metadata.format, images[index].width, images[index].height, ddsRowPitch, ddsSlicePitch, CP_FLAGS_NONE);
-                    if (FAILED(hr))
-                        return hr;
-
-                    if ((images[index].slicePitch == ddsSlicePitch) && (ddsSlicePitch <= UINT32_MAX))
-                    {
-                    #ifdef _WIN32
-                        if (!WriteFile(hFile.get(), images[index].pixels, static_cast<DWORD>(ddsSlicePitch), &bytesWritten, nullptr))
-                        {
-                            return HRESULT_FROM_WIN32(GetLastError());
-                        }
-
-                        if (bytesWritten != ddsSlicePitch)
-                        {
-                            return E_FAIL;
-                        }
-                    #else
-                        outFile.write(reinterpret_cast<char*>(images[index].pixels), static_cast<std::streamsize>(ddsSlicePitch));
-                        if (!outFile)
-                            return E_FAIL;
-                    #endif
-                    }
-                    else
-                    {
-                        const size_t rowPitch = images[index].rowPitch;
-                        if (rowPitch < ddsRowPitch)
-                        {
-                            // DDS uses 1-byte alignment, so if this is happening then the input pitch isn't actually a full line of data
-                            return E_FAIL;
-                        }
-
-                        if (ddsRowPitch > UINT32_MAX)
-                            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-                        const uint8_t * __restrict sPtr = images[index].pixels;
-
-                        const size_t lines = ComputeScanlines(metadata.format, images[index].height);
-                        for (size_t j = 0; j < lines; ++j)
-                        {
-                        #ifdef _WIN32
-                            if (!WriteFile(hFile.get(), sPtr, static_cast<DWORD>(ddsRowPitch), &bytesWritten, nullptr))
-                            {
-                                return HRESULT_FROM_WIN32(GetLastError());
-                            }
-
-                            if (bytesWritten != ddsRowPitch)
-                            {
-                                return E_FAIL;
-                            }
-                        #else
-                            outFile.write(reinterpret_cast<const char*>(sPtr), static_cast<std::streamsize>(ddsRowPitch));
-                            if (!outFile)
-                                return E_FAIL;
-                        #endif
-
-                            sPtr += rowPitch;
-                        }
-                    }
-                }
-            }
-        }
-        break;
-
-    case DDS_DIMENSION_TEXTURE3D:
-        {
-            if (metadata.arraySize != 1)
-                return E_FAIL;
-
-            size_t d = metadata.depth;
-
-            size_t index = 0;
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                for (size_t slice = 0; slice < d; ++slice, ++index)
-                {
-                    if (index >= nimages)
-                        return E_FAIL;
-
-                    if (!images[index].pixels)
-                        return E_POINTER;
-
-                    assert(images[index].rowPitch > 0);
-                    assert(images[index].slicePitch > 0);
-
-                    size_t ddsRowPitch, ddsSlicePitch;
-                    hr = ComputePitch(metadata.format, images[index].width, images[index].height, ddsRowPitch, ddsSlicePitch, CP_FLAGS_NONE);
-                    if (FAILED(hr))
-                        return hr;
-
-                    if ((images[index].slicePitch == ddsSlicePitch) && (ddsSlicePitch <= UINT32_MAX))
-                    {
-                    #ifdef _WIN32
-                        if (!WriteFile(hFile.get(), images[index].pixels, static_cast<DWORD>(ddsSlicePitch), &bytesWritten, nullptr))
-                        {
-                            return HRESULT_FROM_WIN32(GetLastError());
-                        }
-
-                        if (bytesWritten != ddsSlicePitch)
-                        {
-                            return E_FAIL;
-                        }
-                    #else
-                        outFile.write(reinterpret_cast<char*>(images[index].pixels), static_cast<std::streamsize>(ddsSlicePitch));
-                        if (!outFile)
-                            return E_FAIL;
-                    #endif
-                    }
-                    else
-                    {
-                        const size_t rowPitch = images[index].rowPitch;
-                        if (rowPitch < ddsRowPitch)
-                        {
-                            // DDS uses 1-byte alignment, so if this is happening then the input pitch isn't actually a full line of data
-                            return E_FAIL;
-                        }
-
-                        if (ddsRowPitch > UINT32_MAX)
-                            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-                        const uint8_t * __restrict sPtr = images[index].pixels;
-
-                        const size_t lines = ComputeScanlines(metadata.format, images[index].height);
-                        for (size_t j = 0; j < lines; ++j)
-                        {
-                        #ifdef _WIN32
-                            if (!WriteFile(hFile.get(), sPtr, static_cast<DWORD>(ddsRowPitch), &bytesWritten, nullptr))
-                            {
-                                return HRESULT_FROM_WIN32(GetLastError());
-                            }
-
-                            if (bytesWritten != ddsRowPitch)
-                            {
-                                return E_FAIL;
-                            }
-                        #else
-                            outFile.write(reinterpret_cast<const char*>(sPtr), static_cast<std::streamsize>(ddsRowPitch));
-                            if (!outFile)
-                                return E_FAIL;
-                        #endif
-                            sPtr += rowPitch;
-                        }
-                    }
-                }
-
-                if (d > 1)
-                    d >>= 1;
-            }
-        }
-        break;
-
-    default:
-        return E_FAIL;
-    }
-
-#ifdef _WIN32
-    delonfail.clear();
-#endif
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexFlipRotate.cpp b/thirdparty/directxtex/DirectXTexFlipRotate.cpp
deleted file mode 100644
index 1b26e68..0000000
--- a/thirdparty/directxtex/DirectXTexFlipRotate.cpp
+++ /dev/null
@@ -1,411 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexFlipRotate.cpp
-//
-// DirectX Texture Library - Image flip/rotate operations
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-using Microsoft::WRL::ComPtr;
-
-namespace
-{
-    //-------------------------------------------------------------------------------------
-    // Do flip/rotate operation using WIC
-    //-------------------------------------------------------------------------------------
-    HRESULT PerformFlipRotateUsingWIC(
-        const Image& srcImage,
-        TEX_FR_FLAGS flags,
-        const WICPixelFormatGUID& pfGUID,
-        const Image& destImage) noexcept
-    {
-        if (!srcImage.pixels || !destImage.pixels)
-            return E_POINTER;
-
-        assert(srcImage.format == destImage.format);
-
-        bool iswic2 = false;
-        auto pWIC = GetWICFactory(iswic2);
-        if (!pWIC)
-            return E_NOINTERFACE;
-
-        if (srcImage.rowPitch > UINT32_MAX || srcImage.slicePitch > UINT32_MAX
-            || destImage.rowPitch > UINT32_MAX || destImage.slicePitch > UINT32_MAX)
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-        ComPtr<IWICBitmap> source;
-        HRESULT hr = pWIC->CreateBitmapFromMemory(static_cast<UINT>(srcImage.width), static_cast<UINT>(srcImage.height), pfGUID,
-            static_cast<UINT>(srcImage.rowPitch), static_cast<UINT>(srcImage.slicePitch),
-            srcImage.pixels, source.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        ComPtr<IWICBitmapFlipRotator> FR;
-        hr = pWIC->CreateBitmapFlipRotator(FR.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        hr = FR->Initialize(source.Get(), static_cast<WICBitmapTransformOptions>(flags));
-        if (FAILED(hr))
-            return hr;
-
-        WICPixelFormatGUID pfFR;
-        hr = FR->GetPixelFormat(&pfFR);
-        if (FAILED(hr))
-            return hr;
-
-        if (memcmp(&pfFR, &pfGUID, sizeof(GUID)) != 0)
-        {
-            // Flip/rotate should return the same format as the source...
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        UINT nwidth, nheight;
-        hr = FR->GetSize(&nwidth, &nheight);
-        if (FAILED(hr))
-            return hr;
-
-        if (destImage.width != nwidth || destImage.height != nheight)
-            return E_FAIL;
-
-        hr = FR->CopyPixels(nullptr, static_cast<UINT>(destImage.rowPitch), static_cast<UINT>(destImage.slicePitch), destImage.pixels);
-        if (FAILED(hr))
-            return hr;
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Do conversion, flip/rotate using WIC, conversion cycle
-    //
-    // For large images we have to use F16 instead of F32 to avoid exceeding the 32-bit
-    // memory limitations of WIC.
-    //-------------------------------------------------------------------------------------
-    HRESULT PerformFlipRotateViaF16(
-        const Image& srcImage,
-        TEX_FR_FLAGS flags,
-        const Image& destImage) noexcept
-    {
-        if (!srcImage.pixels || !destImage.pixels)
-            return E_POINTER;
-
-        assert(srcImage.format != DXGI_FORMAT_R16G16B16A16_FLOAT);
-        assert(srcImage.format == destImage.format);
-
-        ScratchImage temp;
-        HRESULT hr = ConvertToR16G16B16A16(srcImage, temp);
-        if (FAILED(hr))
-            return hr;
-
-        const Image *tsrc = temp.GetImage(0, 0, 0);
-        if (!tsrc)
-            return E_POINTER;
-
-        ScratchImage rtemp;
-        hr = rtemp.Initialize2D(DXGI_FORMAT_R16G16B16A16_FLOAT, destImage.width, destImage.height, 1, 1);
-        if (FAILED(hr))
-            return hr;
-
-        const Image *tdest = rtemp.GetImage(0, 0, 0);
-        if (!tdest)
-            return E_POINTER;
-
-        hr = PerformFlipRotateUsingWIC(*tsrc, flags, GUID_WICPixelFormat64bppRGBAHalf, *tdest);
-        if (FAILED(hr))
-            return hr;
-
-        temp.Release();
-
-        hr = ConvertFromR16G16B16A16(*tdest, destImage);
-        if (FAILED(hr))
-            return hr;
-
-        return S_OK;
-    }
-
-    HRESULT PerformFlipRotateViaF32(
-        const Image& srcImage,
-        TEX_FR_FLAGS flags,
-        const Image& destImage) noexcept
-    {
-        if (!srcImage.pixels || !destImage.pixels)
-            return E_POINTER;
-
-        assert(srcImage.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
-        assert(srcImage.format == destImage.format);
-
-        ScratchImage temp;
-        HRESULT hr = ConvertToR32G32B32A32(srcImage, temp);
-        if (FAILED(hr))
-            return hr;
-
-        const Image *tsrc = temp.GetImage(0, 0, 0);
-        if (!tsrc)
-            return E_POINTER;
-
-        ScratchImage rtemp;
-        hr = rtemp.Initialize2D(DXGI_FORMAT_R32G32B32A32_FLOAT, destImage.width, destImage.height, 1, 1);
-        if (FAILED(hr))
-            return hr;
-
-        const Image *tdest = rtemp.GetImage(0, 0, 0);
-        if (!tdest)
-            return E_POINTER;
-
-        hr = PerformFlipRotateUsingWIC(*tsrc, flags, GUID_WICPixelFormat128bppRGBAFloat, *tdest);
-        if (FAILED(hr))
-            return hr;
-
-        temp.Release();
-
-        hr = ConvertFromR32G32B32A32(*tdest, destImage);
-        if (FAILED(hr))
-            return hr;
-
-        return S_OK;
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Flip/rotate image
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::FlipRotate(
-    const Image& srcImage,
-    TEX_FR_FLAGS flags,
-    ScratchImage& image) noexcept
-{
-    if (!srcImage.pixels)
-        return E_POINTER;
-
-    if (!flags)
-        return E_INVALIDARG;
-
-    if ((srcImage.width > UINT32_MAX) || (srcImage.height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    if (IsCompressed(srcImage.format))
-    {
-        // We don't support flip/rotate operations on compressed images
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    static_assert(static_cast<int>(TEX_FR_ROTATE0) == static_cast<int>(WICBitmapTransformRotate0), "TEX_FR_ROTATE0 no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_ROTATE90) == static_cast<int>(WICBitmapTransformRotate90), "TEX_FR_ROTATE90 no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_ROTATE180) == static_cast<int>(WICBitmapTransformRotate180), "TEX_FR_ROTATE180 no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_ROTATE270) == static_cast<int>(WICBitmapTransformRotate270), "TEX_FR_ROTATE270 no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_FLIP_HORIZONTAL) == static_cast<int>(WICBitmapTransformFlipHorizontal), "TEX_FR_FLIP_HORIZONTAL no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_FLIP_VERTICAL) == static_cast<int>(WICBitmapTransformFlipVertical), "TEX_FR_FLIP_VERTICAL no longer matches WIC");
-
-    // Only supports 90, 180, 270, or no rotation flags... not a combination of rotation flags
-    const int rotateMode = static_cast<int>(flags & (TEX_FR_ROTATE0 | TEX_FR_ROTATE90 | TEX_FR_ROTATE180 | TEX_FR_ROTATE270));
-
-    switch (rotateMode)
-    {
-    case 0:
-    case TEX_FR_ROTATE90:
-    case TEX_FR_ROTATE180:
-    case TEX_FR_ROTATE270:
-        break;
-
-    default:
-        return E_INVALIDARG;
-    }
-
-    size_t nwidth = srcImage.width;
-    size_t nheight = srcImage.height;
-
-    if ((rotateMode == TEX_FR_ROTATE90) || (rotateMode == TEX_FR_ROTATE270))
-    {
-        nwidth = srcImage.height;
-        nheight = srcImage.width;
-    }
-
-    HRESULT hr = image.Initialize2D(srcImage.format, nwidth, nheight, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *rimage = image.GetImage(0, 0, 0);
-    if (!rimage)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    WICPixelFormatGUID pfGUID;
-    if (DXGIToWIC(srcImage.format, pfGUID))
-    {
-        // Case 1: Source format is supported by Windows Imaging Component
-        hr = PerformFlipRotateUsingWIC(srcImage, flags, pfGUID, *rimage);
-    }
-    else
-    {
-        // Case 2: Source format is not supported by WIC, so we have to convert, flip/rotate, and convert back
-        const uint64_t expandedSize = uint64_t(srcImage.width) * uint64_t(srcImage.height) * sizeof(float) * 4;
-        if (expandedSize > UINT32_MAX)
-        {
-            // Image is too large for float32, so have to use float16 instead
-            hr = PerformFlipRotateViaF16(srcImage, flags, *rimage);
-        }
-        else
-        {
-            hr = PerformFlipRotateViaF32(srcImage, flags, *rimage);
-        }
-    }
-
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Flip/rotate image (complex)
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::FlipRotate(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    TEX_FR_FLAGS flags,
-    ScratchImage& result) noexcept
-{
-    if (!srcImages || !nimages)
-        return E_INVALIDARG;
-
-    if (IsCompressed(metadata.format))
-    {
-        // We don't support flip/rotate operations on compressed images
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    static_assert(static_cast<int>(TEX_FR_ROTATE0) == static_cast<int>(WICBitmapTransformRotate0), "TEX_FR_ROTATE0 no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_ROTATE90) == static_cast<int>(WICBitmapTransformRotate90), "TEX_FR_ROTATE90 no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_ROTATE180) == static_cast<int>(WICBitmapTransformRotate180), "TEX_FR_ROTATE180 no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_ROTATE270) == static_cast<int>(WICBitmapTransformRotate270), "TEX_FR_ROTATE270 no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_FLIP_HORIZONTAL) == static_cast<int>(WICBitmapTransformFlipHorizontal), "TEX_FR_FLIP_HORIZONTAL no longer matches WIC");
-    static_assert(static_cast<int>(TEX_FR_FLIP_VERTICAL) == static_cast<int>(WICBitmapTransformFlipVertical), "TEX_FR_FLIP_VERTICAL no longer matches WIC");
-
-    // Only supports 90, 180, 270, or no rotation flags... not a combination of rotation flags
-    const int rotateMode = static_cast<int>(flags & (TEX_FR_ROTATE0 | TEX_FR_ROTATE90 | TEX_FR_ROTATE180 | TEX_FR_ROTATE270));
-
-    switch (rotateMode)
-    {
-    case 0:
-    case TEX_FR_ROTATE90:
-    case TEX_FR_ROTATE180:
-    case TEX_FR_ROTATE270:
-        break;
-
-    default:
-        return E_INVALIDARG;
-    }
-
-    TexMetadata mdata2 = metadata;
-
-    bool flipwh = false;
-    if ((rotateMode == TEX_FR_ROTATE90) || (rotateMode == TEX_FR_ROTATE270))
-    {
-        flipwh = true;
-        mdata2.width = metadata.height;
-        mdata2.height = metadata.width;
-    }
-
-    HRESULT hr = result.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != result.GetImageCount())
-    {
-        result.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = result.GetImages();
-    if (!dest)
-    {
-        result.Release();
-        return E_POINTER;
-    }
-
-    WICPixelFormatGUID pfGUID;
-    const bool wicpf = DXGIToWIC(metadata.format, pfGUID);
-
-    for (size_t index = 0; index < nimages; ++index)
-    {
-        const Image& src = srcImages[index];
-        if (src.format != metadata.format)
-        {
-            result.Release();
-            return E_FAIL;
-        }
-
-        if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
-            return E_FAIL;
-
-        const Image& dst = dest[index];
-        assert(dst.format == metadata.format);
-
-        if (flipwh)
-        {
-            if (src.width != dst.height || src.height != dst.width)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-        }
-        else
-        {
-            if (src.width != dst.width || src.height != dst.height)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-        }
-
-        if (wicpf)
-        {
-            // Case 1: Source format is supported by Windows Imaging Component
-            hr = PerformFlipRotateUsingWIC(src, flags, pfGUID, dst);
-        }
-        else
-        {
-            // Case 2: Source format is not supported by WIC, so we have to convert, flip/rotate, and convert back
-            const uint64_t expandedSize = uint64_t(src.width) * uint64_t(src.height) * sizeof(float) * 4;
-            if (expandedSize > UINT32_MAX)
-            {
-                // Image is too large for float32, so have to use float16 instead
-                hr = PerformFlipRotateViaF16(src, flags, dst);
-            }
-            else
-            {
-                hr = PerformFlipRotateViaF32(src, flags, dst);
-            }
-        }
-
-        if (FAILED(hr))
-        {
-            result.Release();
-            return hr;
-        }
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexHDR.cpp b/thirdparty/directxtex/DirectXTexHDR.cpp
deleted file mode 100644
index d0a41a7..0000000
--- a/thirdparty/directxtex/DirectXTexHDR.cpp
+++ /dev/null
@@ -1,1300 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexHDR.cpp
-//
-// DirectX Texture Library - Radiance HDR (RGBE) file format reader/writer
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-//
-// In theory HDR (RGBE) Radiance files can have any of the following data orientations
-//
-//      +X width +Y height
-//      +X width -Y height
-//      -X width +Y height
-//      -X width -Y height
-//      +Y height +X width
-//      -Y height +X width
-//      +Y height -X width
-//      -Y height -X width
-//
-// All HDR files we've encountered are always written as "-Y height +X width", so
-// we support only that one as that's what other Radiance parsing code does as well.
-//
-
-//Uncomment to disable the use of adapative RLE encoding when writing an HDR. Used for testing only.
-//#define DISABLE_COMPRESS
-
-//Uncomment to use "old colors" standard RLE encoding when writing an HDR. Used for testing only.
-//#define WRITE_OLD_COLORS
-
-using namespace DirectX;
-
-#ifndef _WIN32
-#include <cstdarg>
-
-#define strncpy_s strncpy
-#define sscanf_s sscanf
-#endif
-
-namespace
-{
-    const char g_Signature[] = "#?RADIANCE";
-        // This is the official header signature for the .HDR (RGBE) file format.
-
-    const char g_AltSignature[] = "#?RGBE";
-        // This is a common variant header signature that is otherwise exactly the same format.
-
-    const char g_Format[] = "FORMAT=";
-    const char g_Exposure[] = "EXPOSURE=";
-
-    const char g_sRGBE[] = "32-bit_rle_rgbe";
-    const char g_sXYZE[] = "32-bit_rle_xyze";
-
-    const char g_Header[] =
-        "#?RADIANCE\n"\
-        "FORMAT=32-bit_rle_rgbe\n"\
-        "\n"\
-        "-Y %u +X %u\n";
-
-    inline size_t FindEOL(const char* str, size_t maxlen) noexcept
-    {
-        size_t pos = 0;
-
-        while (pos < maxlen)
-        {
-            if (str[pos] == '\n')
-                return pos;
-            else if (str[pos] == '\0')
-                return size_t(-1);
-            ++pos;
-        }
-
-        return 0;
-    }
-
-#ifndef _WIN32
-    template<size_t sizeOfBuffer>
-    inline int sprintf_s(char(&buffer)[sizeOfBuffer], const char* format, ...)
-    {
-        // This is adapter code. It is not a full implementation of sprintf_s!
-        va_list ap;
-        va_start(ap, format);
-        int result = vsprintf(buffer, format, ap);
-        va_end(ap);
-        return result;
-    }
-#endif
-
-    //-------------------------------------------------------------------------------------
-    // Decodes HDR header
-    //-------------------------------------------------------------------------------------
-    HRESULT DecodeHDRHeader(
-        _In_reads_bytes_(size) const void* pSource,
-        size_t size,
-        _Out_ TexMetadata& metadata,
-        size_t& offset,
-        float& exposure) noexcept
-    {
-        if (!pSource)
-            return E_INVALIDARG;
-
-        memset(&metadata, 0, sizeof(TexMetadata));
-
-        exposure = 1.f;
-
-        if (size < sizeof(g_Signature))
-        {
-            return HRESULT_E_INVALID_DATA;
-        }
-
-        // Verify magic signature
-        if (memcmp(pSource, g_Signature, sizeof(g_Signature) - 1) != 0
-            && memcmp(pSource, g_AltSignature, sizeof(g_AltSignature) - 1) != 0)
-        {
-            return E_FAIL;
-        }
-
-        // Process first part of header
-        bool formatFound = false;
-        auto info = static_cast<const char*>(pSource);
-        while (size > 0)
-        {
-            if (*info == '\n')
-            {
-                ++info;
-                --size;
-                break;
-            }
-
-            constexpr size_t formatLen = sizeof(g_Format) - 1;
-            constexpr size_t exposureLen = sizeof(g_Exposure) - 1;
-            if ((size > formatLen) && memcmp(info, g_Format, formatLen) == 0)
-            {
-                info += formatLen;
-                size -= formatLen;
-
-                // Trim whitespace
-                while (*info == ' ' || *info == '\t')
-                {
-                    if (--size == 0)
-                        return E_FAIL;
-                    ++info;
-                }
-
-                static_assert(sizeof(g_sRGBE) == sizeof(g_sXYZE), "Format strings length mismatch");
-
-                constexpr size_t encodingLen = sizeof(g_sRGBE) - 1;
-
-                if (size < encodingLen)
-                {
-                    return E_FAIL;
-                }
-
-                if (memcmp(info, g_sRGBE, encodingLen) != 0 && memcmp(info, g_sXYZE, encodingLen) != 0)
-                {
-                    return HRESULT_E_NOT_SUPPORTED;
-                }
-
-                formatFound = true;
-
-                const size_t len = FindEOL(info, size);
-                if (len == size_t(-1))
-                {
-                    return E_FAIL;
-                }
-
-                info += len + 1;
-                size -= len + 1;
-            }
-            else if ((size > exposureLen) && memcmp(info, g_Exposure, exposureLen) == 0)
-            {
-                info += exposureLen;
-                size -= exposureLen;
-
-                // Trim whitespace
-                while (*info == ' ' || *info == '\t')
-                {
-                    if (--size == 0)
-                        return E_FAIL;
-                    ++info;
-                }
-
-                const size_t len = FindEOL(info, size);
-                if (len == size_t(-1)
-                    || len < 1)
-                {
-                    return E_FAIL;
-                }
-
-                char buff[32] = {};
-                strncpy_s(buff, info, std::min<size_t>(31, len));
-
-                auto newExposure = static_cast<float>(atof(buff));
-                if ((newExposure >= 1e-12f) && (newExposure <= 1e12f))
-                {
-                    // Note that we ignore strange exposure values (like EXPOSURE=0)
-                    exposure *= newExposure;
-                }
-
-                info += len + 1;
-                size -= len + 1;
-            }
-            else
-            {
-                const size_t len = FindEOL(info, size);
-                if (len == size_t(-1))
-                {
-                    return E_FAIL;
-                }
-
-                info += len + 1;
-                size -= len + 1;
-            }
-        }
-
-        if (!formatFound)
-        {
-            return E_FAIL;
-        }
-
-        // Get orientation
-        char orientation[256] = {};
-
-        const size_t len = FindEOL(info, std::min<size_t>(sizeof(orientation), size - 1));
-        if (len == size_t(-1)
-            || len <= 2)
-        {
-            return E_FAIL;
-        }
-
-        strncpy_s(orientation, info, len);
-
-        if (orientation[0] != '-' && orientation[1] != 'Y')
-        {
-            // We only support the -Y +X orientation (see top of file)
-            return (static_cast<unsigned long>(((orientation[0] == '+' || orientation[0] == '-') && (orientation[1] == 'X' || orientation[1] == 'Y'))))
-                ? HRESULT_E_NOT_SUPPORTED : HRESULT_E_INVALID_DATA;
-        }
-
-        uint32_t height = 0;
-        if (sscanf_s(orientation + 2, "%u", &height) != 1)
-        {
-            return E_FAIL;
-        }
-
-        const char* ptr = orientation + 2;
-        while (*ptr != 0 && *ptr != '-' && *ptr != '+')
-            ++ptr;
-
-        if (*ptr == 0)
-        {
-            return E_FAIL;
-        }
-        else if (*ptr != '+')
-        {
-            // We only support the -Y +X orientation (see top of file)
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        ++ptr;
-        if (*ptr == 0 || (*ptr != 'X' && *ptr != 'Y'))
-        {
-            return E_FAIL;
-        }
-        else if (*ptr != 'X')
-        {
-            // We only support the -Y +X orientation (see top of file)
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        ++ptr;
-        uint32_t width;
-        if (sscanf_s(ptr, "%u", &width) != 1)
-        {
-            return E_FAIL;
-        }
-
-        info += len + 1;
-        size -= len + 1;
-
-        if (!width || !height)
-        {
-            return HRESULT_E_INVALID_DATA;
-        }
-
-        if (size == 0)
-        {
-            return E_FAIL;
-        }
-
-        offset = size_t(info - static_cast<const char*>(pSource));
-
-        metadata.width = width;
-        metadata.height = height;
-        metadata.depth = metadata.arraySize = metadata.mipLevels = 1;
-        metadata.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
-        metadata.dimension = TEX_DIMENSION_TEXTURE2D;
-        metadata.SetAlphaMode(TEX_ALPHA_MODE_OPAQUE);
-
-        return S_OK;
-    }
-
-    //-------------------------------------------------------------------------------------
-    // FloatToRGBE
-    //-------------------------------------------------------------------------------------
-    inline void FloatToRGBE(_Out_writes_(width*4) uint8_t* pDestination, _In_reads_(width*fpp) const float* pSource, size_t width, _In_range_(3, 4) int fpp) noexcept
-    {
-        auto ePtr = pSource + width * size_t(fpp);
-
-        for (size_t j = 0; j < width; ++j)
-        {
-            if (pSource + 2 >= ePtr) break;
-            const float r = pSource[0] >= 0.f ? pSource[0] : 0.f;
-            const float g = pSource[1] >= 0.f ? pSource[1] : 0.f;
-            const float b = pSource[2] >= 0.f ? pSource[2] : 0.f;
-            pSource += fpp;
-
-            const float max_xy = (r > g) ? r : g;
-            float max_xyz = (max_xy > b) ? max_xy : b;
-
-            if (max_xyz > 1e-32f)
-            {
-                int e;
-                max_xyz = frexpf(max_xyz, &e) * 256.f / max_xyz;
-                e += 128;
-
-                const uint8_t red = uint8_t(r * max_xyz);
-                const uint8_t green = uint8_t(g * max_xyz);
-                const uint8_t blue = uint8_t(b * max_xyz);
-
-                pDestination[0] = red;
-                pDestination[1] = green;
-                pDestination[2] = blue;
-                pDestination[3] = (red || green || blue) ? uint8_t(e & 0xff) : 0u;
-            }
-            else
-            {
-                pDestination[0] = pDestination[1] = pDestination[2] = pDestination[3] = 0;
-            }
-
-            pDestination += 4;
-        }
-    }
-
-    //-------------------------------------------------------------------------------------
-    // HalfToRGBE
-    //-------------------------------------------------------------------------------------
-    inline void HalfToRGBE(_Out_writes_(width * 4) uint8_t* pDestination, _In_reads_(width* fpp) const uint16_t* pSource, size_t width, _In_range_(3, 4) int fpp) noexcept
-    {
-        auto ePtr = pSource + width * size_t(fpp);
-
-        for (size_t j = 0; j < width; ++j)
-        {
-            if (pSource + 2 >= ePtr) break;
-            float r = PackedVector::XMConvertHalfToFloat(pSource[0]); r = (r >= 0.f) ? r : 0.f;
-            float g = PackedVector::XMConvertHalfToFloat(pSource[1]); g = (g >= 0.f) ? g : 0.f;
-            float b = PackedVector::XMConvertHalfToFloat(pSource[2]); b = (b >= 0.f) ? b : 0.f;
-            pSource += fpp;
-
-            const float max_xy = (r > g) ? r : g;
-            float max_xyz = (max_xy > b) ? max_xy : b;
-
-            if (max_xyz > 1e-32f)
-            {
-                int e;
-                max_xyz = frexpf(max_xyz, &e) * 256.f / max_xyz;
-                e += 128;
-
-                const uint8_t red = uint8_t(r * max_xyz);
-                const uint8_t green = uint8_t(g * max_xyz);
-                const uint8_t blue = uint8_t(b * max_xyz);
-
-                pDestination[0] = red;
-                pDestination[1] = green;
-                pDestination[2] = blue;
-                pDestination[3] = (red || green || blue) ? uint8_t(e & 0xff) : 0u;
-            }
-            else
-            {
-                pDestination[0] = pDestination[1] = pDestination[2] = pDestination[3] = 0;
-            }
-
-            pDestination += 4;
-        }
-    }
-
-    //-------------------------------------------------------------------------------------
-    // Encode using Adapative RLE
-    //-------------------------------------------------------------------------------------
-    _Success_(return > 0)
-        size_t EncodeRLE(_Out_writes_(width * 4) uint8_t* enc, _In_reads_(width * 4) const uint8_t* rgbe, size_t rowPitch, size_t width) noexcept
-    {
-        if (width < 8 || width > INT16_MAX)
-        {
-            // Don't try to compress too narrow or too wide scan-lines
-            return 0;
-        }
-
-    #ifdef WRITE_OLD_COLORS
-        size_t encSize = 0;
-
-        const uint8_t* scanPtr = rgbe;
-        for (size_t pixelCount = 0; pixelCount < width;)
-        {
-            size_t spanLen = 1;
-            auto spanPtr = reinterpret_cast<const uint32_t*>(scanPtr);
-            while (pixelCount + spanLen < width && spanLen < INT16_MAX)
-            {
-                if (spanPtr[spanLen] == *spanPtr)
-                {
-                    ++spanLen;
-                }
-                else
-                    break;
-            }
-
-            if (spanLen > 2)
-            {
-                if (scanPtr[0] == 1 && scanPtr[1] == 1 && scanPtr[2] == 1)
-                {
-                    return 0;
-                }
-
-                if (encSize + 8 > rowPitch)
-                    return 0;
-
-                auto rleLen = static_cast<uint8_t>(std::min<size_t>(spanLen - 1, 255));
-
-                enc[0] = scanPtr[0];
-                enc[1] = scanPtr[1];
-                enc[2] = scanPtr[2];
-                enc[3] = scanPtr[3];
-                enc[4] = 1;
-                enc[5] = 1;
-                enc[6] = 1;
-                enc[7] = rleLen;
-                enc += 8;
-                encSize += 8;
-
-                size_t remaining = spanLen - 1 - rleLen;
-
-                if (remaining > 0)
-                {
-                    rleLen = static_cast<uint8_t>(remaining >> 8);
-
-                    if (rleLen > 0)
-                    {
-                        if (encSize + 4 > rowPitch)
-                            return 0;
-
-                        enc[0] = 1;
-                        enc[1] = 1;
-                        enc[2] = 1;
-                        enc[3] = rleLen;
-                        enc += 4;
-                        encSize += 4;
-
-                        remaining -= (rleLen << 8);
-                    }
-
-                    while (remaining > 0)
-                    {
-                        if (encSize + 4 > rowPitch)
-                            return 0;
-
-                        enc[0] = scanPtr[0];
-                        enc[1] = scanPtr[1];
-                        enc[2] = scanPtr[2];
-                        enc[3] = scanPtr[3];
-                        enc += 4;
-                        encSize += 4;
-
-                        --remaining;
-                    }
-                }
-
-                scanPtr += spanLen * 4;
-                pixelCount += spanLen;
-            }
-            else if (scanPtr[0] == 1 && scanPtr[1] == 1 && scanPtr[2] == 1)
-            {
-                return 0;
-            }
-            else
-            {
-                if (encSize + 4 > rowPitch)
-                    return 0;
-
-                enc[0] = scanPtr[0];
-                enc[1] = scanPtr[1];
-                enc[2] = scanPtr[2];
-                enc[3] = scanPtr[3];
-                enc += 4;
-                encSize += 4;
-                ++pixelCount;
-                scanPtr += 4;
-            }
-        }
-
-        return encSize;
-    #else
-        enc[0] = 2;
-        enc[1] = 2;
-        enc[2] = uint8_t(width >> 8);
-        enc[3] = uint8_t(width & 0xff);
-        enc += 4;
-        size_t encSize = 4;
-
-        uint8_t scan[128] = {};
-
-        for (int channel = 0; channel < 4; ++channel)
-        {
-            const uint8_t* spanPtr = rgbe + channel;
-            for (size_t pixelCount = 0; pixelCount < width;)
-            {
-                uint8_t spanLen = 1;
-                while (pixelCount + spanLen < width && spanLen < 127)
-                {
-                    if (spanPtr[spanLen * 4] == *spanPtr)
-                    {
-                        ++spanLen;
-                    }
-                    else
-                        break;
-                }
-
-                if (spanLen > 1)
-                {
-                    if (encSize + 2 > rowPitch)
-                        return 0;
-
-                    enc[0] = 128u + spanLen;
-                    enc[1] = *spanPtr;
-                    enc += 2;
-                    encSize += 2;
-                    spanPtr += size_t(spanLen) * 4;
-                    pixelCount += spanLen;
-                }
-                else
-                {
-                    uint8_t runLen = 1;
-                    scan[0] = *spanPtr;
-                    while (pixelCount + runLen < width && runLen < 127)
-                    {
-                        if (spanPtr[(runLen - 1) * 4] != spanPtr[runLen * 4])
-                        {
-                            scan[runLen] = spanPtr[runLen * 4];
-                            runLen++;
-                        }
-                        else
-                            break;
-                    }
-
-                    if (encSize + runLen + 1 > rowPitch)
-                        return 0;
-
-                    *enc++ = runLen;
-                    memcpy(enc, scan, runLen);
-                    enc += runLen;
-                    encSize += size_t(runLen) + 1;
-                    spanPtr += size_t(runLen) * 4;
-                    pixelCount += runLen;
-                }
-            }
-        }
-
-        return encSize;
-    #endif
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Obtain metadata from HDR file in memory/on disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::GetMetadataFromHDRMemory(const void* pSource, size_t size, TexMetadata& metadata) noexcept
-{
-    if (!pSource || size == 0)
-        return E_INVALIDARG;
-
-    size_t offset;
-    float exposure;
-    return DecodeHDRHeader(pSource, size, metadata, offset, exposure);
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::GetMetadataFromHDRFile(const wchar_t* szFile, TexMetadata& metadata) noexcept
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-#ifdef _WIN32
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
-    ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
-#else
-    ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
-        FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
-#endif
-    if (!hFile)
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // Get the file size
-    FILE_STANDARD_INFO fileInfo;
-    if (!GetFileInformationByHandleEx(hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo)))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // File is too big for 32-bit allocation, so reject read (4 GB should be plenty large enough for a valid HDR file)
-    if (fileInfo.EndOfFile.HighPart > 0)
-    {
-        return HRESULT_E_FILE_TOO_LARGE;
-    }
-
-    const size_t len = fileInfo.EndOfFile.LowPart;
-#else // !WIN32
-    std::ifstream inFile(std::filesystem::path(szFile), std::ios::in | std::ios::binary | std::ios::ate);
-    if (!inFile)
-        return E_FAIL;
-
-    std::streampos fileLen = inFile.tellg();
-    if (!inFile)
-        return E_FAIL;
-
-    if (fileLen > UINT32_MAX)
-        return HRESULT_E_FILE_TOO_LARGE;
-
-    inFile.seekg(0, std::ios::beg);
-    if (!inFile)
-        return E_FAIL;
-
-    const size_t len = fileLen;
-#endif
-
-    // Need at least enough data to fill the standard header to be a valid HDR
-    if (len < sizeof(g_Signature))
-    {
-        return E_FAIL;
-    }
-
-    // Read the first part of the file to find the header
-    uint8_t header[8192] = {};
-
-#ifdef _WIN32
-    DWORD bytesRead = 0;
-    if (!ReadFile(hFile.get(), header, std::min<DWORD>(sizeof(header), fileInfo.EndOfFile.LowPart), &bytesRead, nullptr))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    auto const headerLen = static_cast<size_t>(bytesRead);
-#else
-    auto const headerLen = std::min<size_t>(sizeof(header), len);
-
-    inFile.read(reinterpret_cast<char*>(header), headerLen);
-    if (!inFile)
-        return E_FAIL;
-#endif
-
-    size_t offset;
-    float exposure;
-    return DecodeHDRHeader(header, headerLen, metadata, offset, exposure);
-}
-
-
-//-------------------------------------------------------------------------------------
-// Load a HDR file in memory
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::LoadFromHDRMemory(const void* pSource, size_t size, TexMetadata* metadata, ScratchImage& image) noexcept
-{
-    if (!pSource || size == 0)
-        return E_INVALIDARG;
-
-    image.Release();
-
-    size_t offset;
-    float exposure;
-    TexMetadata mdata;
-    HRESULT hr = DecodeHDRHeader(pSource, size, mdata, offset, exposure);
-    if (FAILED(hr))
-        return hr;
-
-    if (offset > size)
-        return E_FAIL;
-
-    const size_t remaining = size - offset;
-    if (remaining == 0)
-        return E_FAIL;
-
-    hr = image.Initialize2D(mdata.format, mdata.width, mdata.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    // Copy pixels
-    auto sourcePtr = static_cast<const uint8_t*>(pSource) + offset;
-
-    size_t pixelLen = remaining;
-
-    const Image* img = image.GetImage(0, 0, 0);
-    if (!img)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    auto destPtr = img->pixels;
-
-#ifdef _DEBUG
-    memset(img->pixels, 0xFF, img->rowPitch * img->height);
-#endif
-
-    for (size_t scan = 0; scan < mdata.height; ++scan)
-    {
-        if (pixelLen < 4)
-        {
-            image.Release();
-            return E_FAIL;
-        }
-
-        uint8_t inColor[4];
-        memcpy(inColor, sourcePtr, 4);
-        sourcePtr += 4;
-        pixelLen -= 4;
-
-        auto scanLine = reinterpret_cast<float*>(destPtr);
-
-        if (inColor[0] == 2 && inColor[1] == 2 && inColor[2] < 128)
-        {
-            // Adaptive Run Length Encoding (RLE)
-            if (size_t((size_t(inColor[2]) << 8) + inColor[3]) != mdata.width)
-            {
-                image.Release();
-                return E_FAIL;
-            }
-
-            for (int channel = 0; channel < 4; ++channel)
-            {
-                auto pixelLoc = scanLine + channel;
-                for (size_t pixelCount = 0; pixelCount < mdata.width;)
-                {
-                    if (pixelLen < 2)
-                    {
-                        image.Release();
-                        return E_FAIL;
-                    }
-
-                    assert(sourcePtr < (reinterpret_cast<const uint8_t*>(pSource) + size));
-
-                    uint8_t runLen = *sourcePtr;
-                    if (runLen > 128)
-                    {
-                        runLen &= 127;
-                        if (pixelCount + runLen > mdata.width)
-                        {
-                            image.Release();
-                            return E_FAIL;
-                        }
-
-                        auto val = static_cast<float>(sourcePtr[1]);
-                        for (uint8_t j = 0; j < runLen; ++j)
-                        {
-                            *pixelLoc = val;
-                            pixelLoc += 4;
-                        }
-                        pixelCount += runLen;
-                        sourcePtr += 2;
-                        pixelLen -= 2;
-                    }
-                    else if ((size < size_t(runLen) + 1) || ((pixelCount + size_t(runLen)) > mdata.width))
-                    {
-                        image.Release();
-                        return E_FAIL;
-                    }
-                    else
-                    {
-                        ++sourcePtr;
-                        for (uint8_t j = 0; j < runLen; ++j)
-                        {
-                            auto val = static_cast<float>(*sourcePtr++);
-                            *pixelLoc = val;
-                            pixelLoc += 4;
-                        }
-                        pixelCount += runLen;
-                        pixelLen -= size_t(runLen) + 1;
-                    }
-                }
-            }
-        }
-        else
-        {
-            auto pixelLoc = scanLine;
-
-            float prevColor[4];
-            prevColor[0] = inColor[0];
-            prevColor[1] = inColor[1];
-            prevColor[2] = inColor[2];
-            prevColor[3] = inColor[3];
-
-            int bitShift = 0;
-            for (size_t pixelCount = 0; pixelCount < mdata.width;)
-            {
-                if (inColor[0] == 1 && inColor[1] == 1 && inColor[2] == 1)
-                {
-                    if (bitShift > 24)
-                    {
-                        image.Release();
-                        return E_FAIL;
-                    }
-
-                    // "Standard" Run Length Encoding
-                    const size_t spanLen = size_t(inColor[3]) << bitShift;
-                    if (spanLen + pixelCount > mdata.width)
-                    {
-                        image.Release();
-                        return E_FAIL;
-                    }
-
-                    for (size_t j = 0; j < spanLen; ++j)
-                    {
-                        pixelLoc[0] = prevColor[0];
-                        pixelLoc[1] = prevColor[1];
-                        pixelLoc[2] = prevColor[2];
-                        pixelLoc[3] = prevColor[3];
-                        pixelLoc += 4;
-                    }
-                    pixelCount += spanLen;
-                    bitShift += 8;
-                }
-                else
-                {
-                    // Uncompressed
-                    pixelLoc[0] = prevColor[0] = inColor[0];
-                    pixelLoc[1] = prevColor[1] = inColor[1];
-                    pixelLoc[2] = prevColor[2] = inColor[2];
-                    pixelLoc[3] = prevColor[3] = inColor[3];
-                    bitShift = 0;
-                    ++pixelCount;
-                    pixelLoc += 4;
-                }
-
-                if (pixelCount >= mdata.width)
-                    break;
-
-                if (pixelLen < 4)
-                {
-                    image.Release();
-                    return E_FAIL;
-                }
-
-                memcpy(inColor, sourcePtr, 4);
-                sourcePtr += 4;
-                pixelLen -= 4;
-            }
-        }
-
-        destPtr += img->rowPitch;
-    }
-
-    // Transform values
-    {
-        auto fdata = reinterpret_cast<float*>(image.GetPixels());
-
-        for (size_t j = 0; j < image.GetPixelsSize(); j += 16)
-        {
-            auto const exponent = static_cast<int>(fdata[3]);
-            fdata[0] = 1.0f / exposure*ldexpf((fdata[0] + 0.5f), exponent - (128 + 8));
-            fdata[1] = 1.0f / exposure*ldexpf((fdata[1] + 0.5f), exponent - (128 + 8));
-            fdata[2] = 1.0f / exposure*ldexpf((fdata[2] + 0.5f), exponent - (128 + 8));
-            fdata[3] = 1.f;
-
-            fdata += 4;
-        }
-    }
-
-    if (metadata)
-        memcpy(metadata, &mdata, sizeof(TexMetadata));
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Load a HDR file from disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::LoadFromHDRFile(const wchar_t* szFile, TexMetadata* metadata, ScratchImage& image) noexcept
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-    image.Release();
-
-#ifdef _WIN32
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
-    ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
-#else
-    ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
-        FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
-#endif
-    if (!hFile)
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // Get the file size
-    FILE_STANDARD_INFO fileInfo;
-    if (!GetFileInformationByHandleEx(hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo)))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // File is too big for 32-bit allocation, so reject read (4 GB should be plenty large enough for a valid HDR file)
-    if (fileInfo.EndOfFile.HighPart > 0)
-    {
-        return HRESULT_E_FILE_TOO_LARGE;
-    }
-
-    const size_t len = fileInfo.EndOfFile.LowPart;
-#else // !WIN32
-    std::ifstream inFile(std::filesystem::path(szFile), std::ios::in | std::ios::binary | std::ios::ate);
-    if (!inFile)
-        return E_FAIL;
-
-    std::streampos fileLen = inFile.tellg();
-    if (!inFile)
-        return E_FAIL;
-
-    if (fileLen > UINT32_MAX)
-        return HRESULT_E_FILE_TOO_LARGE;
-
-    inFile.seekg(0, std::ios::beg);
-    if (!inFile)
-        return E_FAIL;
-
-    const size_t len = fileLen;
-#endif
-
-    // Need at least enough data to fill the header to be a valid HDR
-    if (len < sizeof(g_Signature))
-    {
-        return E_FAIL;
-    }
-
-    // Read file
-    std::unique_ptr<uint8_t[]> temp(new (std::nothrow) uint8_t[len]);
-    if (!temp)
-    {
-        return E_OUTOFMEMORY;
-    }
-
-#ifdef _WIN32
-    DWORD bytesRead = 0;
-    if (!ReadFile(hFile.get(), temp.get(), fileInfo.EndOfFile.LowPart, &bytesRead, nullptr))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    if (bytesRead != fileInfo.EndOfFile.LowPart)
-    {
-        return E_FAIL;
-    }
-#else
-    inFile.read(reinterpret_cast<char*>(temp.get()), len);
-    if (!inFile)
-        return E_FAIL;
-#endif
-
-    return LoadFromHDRMemory(temp.get(), len, metadata, image);
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a HDR file to memory
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::SaveToHDRMemory(const Image& image, Blob& blob) noexcept
-{
-    if (!image.pixels)
-        return E_POINTER;
-
-    if (image.width > INT16_MAX || image.height > INT16_MAX)
-    {
-        // Images larger than this can't be RLE encoded. They are technically allowed as
-        // uncompresssed, but we just don't support them.
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    int fpp;
-    switch (image.format)
-    {
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-        fpp = 4;
-        break;
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-        fpp = 3;
-        break;
-
-    default:
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    blob.Release();
-
-    char header[256] = {};
-    sprintf_s(header, g_Header, image.height, image.width);
-
-    auto headerLen = static_cast<DWORD>(strlen(header));
-
-    size_t rowPitch = image.width * 4;
-    const size_t slicePitch = image.height * rowPitch;
-
-    HRESULT hr = blob.Initialize(headerLen + slicePitch);
-    if (FAILED(hr))
-        return hr;
-
-    // Copy header
-    auto dPtr = static_cast<uint8_t*>(blob.GetBufferPointer());
-    assert(dPtr != nullptr);
-    memcpy(dPtr, header, headerLen);
-    dPtr += headerLen;
-
-#ifdef DISABLE_COMPRESS
-    // Uncompressed write
-    auto sPtr = reinterpret_cast<const uint8_t*>(image.pixels);
-    for (size_t scan = 0; scan < image.height; ++scan)
-    {
-        FloatToRGBE(dPtr, reinterpret_cast<const float*>(sPtr), image.width, fpp);
-        dPtr += rowPitch;
-        sPtr += image.rowPitch;
-    }
-#else
-    std::unique_ptr<uint8_t[]> temp(new (std::nothrow) uint8_t[rowPitch * 2]);
-    if (!temp)
-    {
-        blob.Release();
-        return E_OUTOFMEMORY;
-    }
-
-    auto rgbe = temp.get();
-    auto enc = temp.get() + rowPitch;
-
-    const uint8_t* sPtr = image.pixels;
-    for (size_t scan = 0; scan < image.height; ++scan)
-    {
-        if (image.format == DXGI_FORMAT_R32G32B32A32_FLOAT || image.format == DXGI_FORMAT_R32G32B32_FLOAT)
-        {
-            FloatToRGBE(rgbe, reinterpret_cast<const float*>(sPtr), image.width, fpp);
-        }
-        else if (image.format == DXGI_FORMAT_R16G16B16A16_FLOAT)
-        {
-            HalfToRGBE(rgbe, reinterpret_cast<const uint16_t*>(sPtr), image.width, fpp);
-        }
-        sPtr += image.rowPitch;
-
-        size_t encSize = EncodeRLE(enc, rgbe, rowPitch, image.width);
-        if (encSize > 0)
-        {
-            memcpy(dPtr, enc, encSize);
-            dPtr += encSize;
-        }
-        else
-        {
-            memcpy(dPtr, rgbe, rowPitch);
-            dPtr += rowPitch;
-        }
-    }
-#endif
-
-    hr = blob.Trim(size_t(dPtr - static_cast<uint8_t*>(blob.GetBufferPointer())));
-    if (FAILED(hr))
-    {
-        blob.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a HDR file to disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexcept
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-    if (!image.pixels)
-        return E_POINTER;
-
-    if (image.width > INT16_MAX || image.height > INT16_MAX)
-    {
-        // Images larger than this can't be RLE encoded. They are technically allowed as
-        // uncompresssed, but we just don't support them.
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    int fpp;
-    switch (image.format)
-    {
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-        fpp = 4;
-        break;
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-        fpp = 3;
-        break;
-
-    default:
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    // Create file and write header
-#ifdef _WIN32
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
-    ScopedHandle hFile(safe_handle(CreateFile2(szFile,
-        GENERIC_WRITE, 0, CREATE_ALWAYS, nullptr)));
-#else
-    ScopedHandle hFile(safe_handle(CreateFileW(szFile,
-        GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr)));
-#endif
-    if (!hFile)
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    auto_delete_file delonfail(hFile.get());
-#else // !WIN32
-    std::ofstream outFile(std::filesystem::path(szFile), std::ios::out | std::ios::binary | std::ios::trunc);
-    if (!outFile)
-        return E_FAIL;
-#endif
-
-    const uint64_t pitch = uint64_t(image.width) * 4u;
-    const uint64_t slicePitch = uint64_t(image.height) * pitch;
-
-    if (pitch > UINT32_MAX)
-        return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-    size_t rowPitch = static_cast<size_t>(pitch);
-
-    if (slicePitch < 65535)
-    {
-        // For small images, it is better to create an in-memory file and write it out
-        Blob blob;
-
-        HRESULT hr = SaveToHDRMemory(image, blob);
-        if (FAILED(hr))
-            return hr;
-
-        // Write blob
-    #ifdef _WIN32
-        auto const bytesToWrite = static_cast<const DWORD>(blob.GetBufferSize());
-        DWORD bytesWritten;
-        if (!WriteFile(hFile.get(), blob.GetBufferPointer(), bytesToWrite, &bytesWritten, nullptr))
-        {
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesWritten != bytesToWrite)
-        {
-            return E_FAIL;
-        }
-    #else
-        outFile.write(reinterpret_cast<char*>(blob.GetBufferPointer()),
-            static_cast<std::streamsize>(blob.GetBufferSize()));
-
-        if (!outFile)
-            return E_FAIL;
-    #endif
-    }
-    else
-    {
-        // Otherwise, write the image one scanline at a time...
-        std::unique_ptr<uint8_t[]> temp(new (std::nothrow) uint8_t[rowPitch * 2]);
-        if (!temp)
-            return E_OUTOFMEMORY;
-
-        auto rgbe = temp.get();
-
-        // Write header
-        char header[256] = {};
-        sprintf_s(header, g_Header, image.height, image.width);
-
-    #ifdef _WIN32
-        auto const headerLen = static_cast<DWORD>(strlen(header));
-
-        DWORD bytesWritten;
-        if (!WriteFile(hFile.get(), header, headerLen, &bytesWritten, nullptr))
-        {
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesWritten != headerLen)
-            return E_FAIL;
-    #else
-        outFile.write(reinterpret_cast<char*>(header), static_cast<std::streamsize>(strlen(header)));
-        if (!outFile)
-            return E_FAIL;
-    #endif
-
-    #ifdef DISABLE_COMPRESS
-            // Uncompressed write
-        auto sPtr = reinterpret_cast<const uint8_t*>(image.pixels);
-        for (size_t scan = 0; scan < image.height; ++scan)
-        {
-            FloatToRGBE(rgbe, reinterpret_cast<const float*>(sPtr), image.width, fpp);
-            sPtr += image.rowPitch;
-
-        #ifdef _WIN32
-            if (!WriteFile(hFile.get(), rgbe, static_cast<DWORD>(rowPitch), &bytesWritten, nullptr))
-            {
-                return HRESULT_FROM_WIN32(GetLastError());
-            }
-
-            if (bytesWritten != rowPitch)
-                return E_FAIL;
-        #else
-            outFile.write(reinterpret_cast<char*>(rgbe), static_cast<std::streamsize>(rowPitch));
-            if (!outFile)
-                return E_FAIL;
-        #endif
-
-        }
-    #else
-        auto enc = temp.get() + rowPitch;
-
-        const uint8_t* sPtr = image.pixels;
-        for (size_t scan = 0; scan < image.height; ++scan)
-        {
-            if (image.format == DXGI_FORMAT_R32G32B32A32_FLOAT || image.format == DXGI_FORMAT_R32G32B32_FLOAT)
-            {
-                FloatToRGBE(rgbe, reinterpret_cast<const float*>(sPtr), image.width, fpp);
-            }
-            else if (image.format == DXGI_FORMAT_R16G16B16A16_FLOAT)
-            {
-                HalfToRGBE(rgbe, reinterpret_cast<const uint16_t*>(sPtr), image.width, fpp);
-            }
-            sPtr += image.rowPitch;
-
-            const size_t encSize = EncodeRLE(enc, rgbe, rowPitch, image.width);
-            if (encSize > 0)
-            {
-                if (encSize > UINT32_MAX)
-                    return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-            #ifdef _WIN32
-                if (!WriteFile(hFile.get(), enc, static_cast<DWORD>(encSize), &bytesWritten, nullptr))
-                {
-                    return HRESULT_FROM_WIN32(GetLastError());
-                }
-
-                if (bytesWritten != encSize)
-                    return E_FAIL;
-            #else
-                outFile.write(reinterpret_cast<char*>(enc), static_cast<std::streamsize>(encSize));
-                if (!outFile)
-                    return E_FAIL;
-            #endif
-            }
-            else
-            {
-            #ifdef _WIN32
-                if (!WriteFile(hFile.get(), rgbe, static_cast<DWORD>(rowPitch), &bytesWritten, nullptr))
-                {
-                    return HRESULT_FROM_WIN32(GetLastError());
-                }
-
-                if (bytesWritten != rowPitch)
-                    return E_FAIL;
-            #else
-                outFile.write(reinterpret_cast<char*>(rgbe), static_cast<std::streamsize>(rowPitch));
-                if (!outFile)
-                    return E_FAIL;
-            #endif
-            }
-        }
-    #endif
-    }
-
-#ifdef _WIN32
-    delonfail.clear();
-#endif
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexImage.cpp b/thirdparty/directxtex/DirectXTexImage.cpp
deleted file mode 100644
index 4083a2c..0000000
--- a/thirdparty/directxtex/DirectXTexImage.cpp
+++ /dev/null
@@ -1,830 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexImage.cpp
-//
-// DirectX Texture Library - Image container
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-
-#ifndef _WIN32
-namespace
-{
-    inline void * _aligned_malloc(size_t size, size_t alignment)
-    {
-        size = (size + alignment - 1) & ~(alignment - 1);
-        return std::aligned_alloc(alignment, size);
-    }
-
-#define _aligned_free free
-}
-#endif
-
-//-------------------------------------------------------------------------------------
-// Determines number of image array entries and pixel size
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::Internal::DetermineImageArray(
-    const TexMetadata& metadata,
-    CP_FLAGS cpFlags,
-    size_t& nImages,
-    size_t& pixelSize) noexcept
-{
-    assert(metadata.width > 0 && metadata.height > 0 && metadata.depth > 0);
-    assert(metadata.arraySize > 0);
-    assert(metadata.mipLevels > 0);
-
-    uint64_t totalPixelSize = 0;
-    size_t nimages = 0;
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-    case TEX_DIMENSION_TEXTURE2D:
-        for (size_t item = 0; item < metadata.arraySize; ++item)
-        {
-            size_t w = metadata.width;
-            size_t h = metadata.height;
-
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                size_t rowPitch, slicePitch;
-                if (FAILED(ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags)))
-                {
-                    nImages = pixelSize = 0;
-                    return false;
-                }
-
-                totalPixelSize += uint64_t(slicePitch);
-                ++nimages;
-
-                if (h > 1)
-                    h >>= 1;
-
-                if (w > 1)
-                    w >>= 1;
-            }
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        {
-            size_t w = metadata.width;
-            size_t h = metadata.height;
-            size_t d = metadata.depth;
-
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                size_t rowPitch, slicePitch;
-                if (FAILED(ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags)))
-                {
-                    nImages = pixelSize = 0;
-                    return false;
-                }
-
-                for (size_t slice = 0; slice < d; ++slice)
-                {
-                    totalPixelSize += uint64_t(slicePitch);
-                    ++nimages;
-                }
-
-                if (h > 1)
-                    h >>= 1;
-
-                if (w > 1)
-                    w >>= 1;
-
-                if (d > 1)
-                    d >>= 1;
-            }
-        }
-        break;
-
-    default:
-        nImages = pixelSize = 0;
-        return false;
-    }
-
-#if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
-    static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!");
-    if (totalPixelSize > UINT32_MAX)
-    {
-        nImages = pixelSize = 0;
-        return false;
-    }
-#else
-    static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
-#endif
-
-    nImages = nimages;
-    pixelSize = static_cast<size_t>(totalPixelSize);
-
-    return true;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Fills in the image array entries
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::Internal::SetupImageArray(
-    uint8_t *pMemory,
-    size_t pixelSize,
-    const TexMetadata& metadata,
-    CP_FLAGS cpFlags,
-    Image* images,
-    size_t nImages) noexcept
-{
-    assert(pMemory);
-    assert(pixelSize > 0);
-    assert(nImages > 0);
-
-    if (!images)
-        return false;
-
-    size_t index = 0;
-    uint8_t* pixels = pMemory;
-    const uint8_t* pEndBits = pMemory + pixelSize;
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-    case TEX_DIMENSION_TEXTURE2D:
-        if (metadata.arraySize == 0 || metadata.mipLevels == 0)
-        {
-            return false;
-        }
-
-        for (size_t item = 0; item < metadata.arraySize; ++item)
-        {
-            size_t w = metadata.width;
-            size_t h = metadata.height;
-
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                if (index >= nImages)
-                {
-                    return false;
-                }
-
-                size_t rowPitch, slicePitch;
-                if (FAILED(ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags)))
-                    return false;
-
-                images[index].width = w;
-                images[index].height = h;
-                images[index].format = metadata.format;
-                images[index].rowPitch = rowPitch;
-                images[index].slicePitch = slicePitch;
-                images[index].pixels = pixels;
-                ++index;
-
-                pixels += slicePitch;
-                if (pixels > pEndBits)
-                {
-                    return false;
-                }
-
-                if (h > 1)
-                    h >>= 1;
-
-                if (w > 1)
-                    w >>= 1;
-            }
-        }
-        return true;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        {
-            if (metadata.mipLevels == 0 || metadata.depth == 0)
-            {
-                return false;
-            }
-
-            size_t w = metadata.width;
-            size_t h = metadata.height;
-            size_t d = metadata.depth;
-
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                size_t rowPitch, slicePitch;
-                if (FAILED(ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags)))
-                    return false;
-
-                for (size_t slice = 0; slice < d; ++slice)
-                {
-                    if (index >= nImages)
-                    {
-                        return false;
-                    }
-
-                    // We use the same memory organization that Direct3D 11 needs for D3D11_SUBRESOURCE_DATA
-                    // with all slices of a given miplevel being continuous in memory
-                    images[index].width = w;
-                    images[index].height = h;
-                    images[index].format = metadata.format;
-                    images[index].rowPitch = rowPitch;
-                    images[index].slicePitch = slicePitch;
-                    images[index].pixels = pixels;
-                    ++index;
-
-                    pixels += slicePitch;
-                    if (pixels > pEndBits)
-                    {
-                        return false;
-                    }
-                }
-
-                if (h > 1)
-                    h >>= 1;
-
-                if (w > 1)
-                    w >>= 1;
-
-                if (d > 1)
-                    d >>= 1;
-            }
-        }
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-
-//=====================================================================================
-// ScratchImage - Bitmap image container
-//=====================================================================================
-
-ScratchImage& ScratchImage::operator= (ScratchImage&& moveFrom) noexcept
-{
-    if (this != &moveFrom)
-    {
-        Release();
-
-        m_nimages = moveFrom.m_nimages;
-        m_size = moveFrom.m_size;
-        m_metadata = moveFrom.m_metadata;
-        m_image = moveFrom.m_image;
-        m_memory = moveFrom.m_memory;
-
-        moveFrom.m_nimages = 0;
-        moveFrom.m_size = 0;
-        moveFrom.m_image = nullptr;
-        moveFrom.m_memory = nullptr;
-    }
-    return *this;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Methods
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexcept
-{
-    if (!IsValid(mdata.format))
-        return E_INVALIDARG;
-
-    if (IsPalettized(mdata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    size_t mipLevels = mdata.mipLevels;
-
-    switch (mdata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-        if (!mdata.width || mdata.height != 1 || mdata.depth != 1 || !mdata.arraySize)
-            return E_INVALIDARG;
-
-        if (!CalculateMipLevels(mdata.width, 1, mipLevels))
-            return E_INVALIDARG;
-        break;
-
-    case TEX_DIMENSION_TEXTURE2D:
-        if (!mdata.width || !mdata.height || mdata.depth != 1 || !mdata.arraySize)
-            return E_INVALIDARG;
-
-        if (mdata.IsCubemap())
-        {
-            if ((mdata.arraySize % 6) != 0)
-                return E_INVALIDARG;
-        }
-
-        if (!CalculateMipLevels(mdata.width, mdata.height, mipLevels))
-            return E_INVALIDARG;
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        if (!mdata.width || !mdata.height || !mdata.depth || mdata.arraySize != 1)
-            return E_INVALIDARG;
-
-        if (!CalculateMipLevels3D(mdata.width, mdata.height, mdata.depth, mipLevels))
-            return E_INVALIDARG;
-        break;
-
-    default:
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    Release();
-
-    m_metadata.width = mdata.width;
-    m_metadata.height = mdata.height;
-    m_metadata.depth = mdata.depth;
-    m_metadata.arraySize = mdata.arraySize;
-    m_metadata.mipLevels = mipLevels;
-    m_metadata.miscFlags = mdata.miscFlags;
-    m_metadata.miscFlags2 = mdata.miscFlags2;
-    m_metadata.format = mdata.format;
-    m_metadata.dimension = mdata.dimension;
-
-    size_t pixelSize, nimages;
-    if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
-        return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-    m_image = new (std::nothrow) Image[nimages];
-    if (!m_image)
-        return E_OUTOFMEMORY;
-
-    m_nimages = nimages;
-    memset(m_image, 0, sizeof(Image) * nimages);
-
-    m_memory = static_cast<uint8_t*>(_aligned_malloc(pixelSize, 16));
-    if (!m_memory)
-    {
-        Release();
-        return E_OUTOFMEMORY;
-    }
-    m_size = pixelSize;
-    if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
-    {
-        Release();
-        return E_FAIL;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT ScratchImage::Initialize1D(DXGI_FORMAT fmt, size_t length, size_t arraySize, size_t mipLevels, CP_FLAGS flags) noexcept
-{
-    if (!length || !arraySize)
-        return E_INVALIDARG;
-
-    // 1D is a special case of the 2D case
-    HRESULT hr = Initialize2D(fmt, length, 1, arraySize, mipLevels, flags);
-    if (FAILED(hr))
-        return hr;
-
-    m_metadata.dimension = TEX_DIMENSION_TEXTURE1D;
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT ScratchImage::Initialize2D(DXGI_FORMAT fmt, size_t width, size_t height, size_t arraySize, size_t mipLevels, CP_FLAGS flags) noexcept
-{
-    if (!IsValid(fmt) || !width || !height || !arraySize)
-        return E_INVALIDARG;
-
-    if (IsPalettized(fmt))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (!CalculateMipLevels(width, height, mipLevels))
-        return E_INVALIDARG;
-
-    Release();
-
-    m_metadata.width = width;
-    m_metadata.height = height;
-    m_metadata.depth = 1;
-    m_metadata.arraySize = arraySize;
-    m_metadata.mipLevels = mipLevels;
-    m_metadata.miscFlags = 0;
-    m_metadata.miscFlags2 = 0;
-    m_metadata.format = fmt;
-    m_metadata.dimension = TEX_DIMENSION_TEXTURE2D;
-
-    size_t pixelSize, nimages;
-    if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
-        return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-    m_image = new (std::nothrow) Image[nimages];
-    if (!m_image)
-        return E_OUTOFMEMORY;
-
-    m_nimages = nimages;
-    memset(m_image, 0, sizeof(Image) * nimages);
-
-    m_memory = static_cast<uint8_t*>(_aligned_malloc(pixelSize, 16));
-    if (!m_memory)
-    {
-        Release();
-        return E_OUTOFMEMORY;
-    }
-    m_size = pixelSize;
-    if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
-    {
-        Release();
-        return E_FAIL;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT ScratchImage::Initialize3D(DXGI_FORMAT fmt, size_t width, size_t height, size_t depth, size_t mipLevels, CP_FLAGS flags) noexcept
-{
-    if (!IsValid(fmt) || !width || !height || !depth)
-        return E_INVALIDARG;
-
-    if (IsPalettized(fmt))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (!CalculateMipLevels3D(width, height, depth, mipLevels))
-        return E_INVALIDARG;
-
-    Release();
-
-    m_metadata.width = width;
-    m_metadata.height = height;
-    m_metadata.depth = depth;
-    m_metadata.arraySize = 1;    // Direct3D 10.x/11 does not support arrays of 3D textures
-    m_metadata.mipLevels = mipLevels;
-    m_metadata.miscFlags = 0;
-    m_metadata.miscFlags2 = 0;
-    m_metadata.format = fmt;
-    m_metadata.dimension = TEX_DIMENSION_TEXTURE3D;
-
-    size_t pixelSize, nimages;
-    if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
-        return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-    m_image = new (std::nothrow) Image[nimages];
-    if (!m_image)
-    {
-        Release();
-        return E_OUTOFMEMORY;
-    }
-    m_nimages = nimages;
-    memset(m_image, 0, sizeof(Image) * nimages);
-
-    m_memory = static_cast<uint8_t*>(_aligned_malloc(pixelSize, 16));
-    if (!m_memory)
-    {
-        Release();
-        return E_OUTOFMEMORY;
-    }
-    m_size = pixelSize;
-
-    if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
-    {
-        Release();
-        return E_FAIL;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT ScratchImage::InitializeCube(DXGI_FORMAT fmt, size_t width, size_t height, size_t nCubes, size_t mipLevels, CP_FLAGS flags) noexcept
-{
-    if (!width || !height || !nCubes)
-        return E_INVALIDARG;
-
-    // A DirectX11 cubemap is just a 2D texture array that is a multiple of 6 for each cube
-    HRESULT hr = Initialize2D(fmt, width, height, nCubes * 6, mipLevels, flags);
-    if (FAILED(hr))
-        return hr;
-
-    m_metadata.miscFlags |= TEX_MISC_TEXTURECUBE;
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT ScratchImage::InitializeFromImage(const Image& srcImage, bool allow1D, CP_FLAGS flags) noexcept
-{
-    HRESULT hr = (srcImage.height > 1 || !allow1D)
-        ? Initialize2D(srcImage.format, srcImage.width, srcImage.height, 1, 1, flags)
-        : Initialize1D(srcImage.format, srcImage.width, 1, 1, flags);
-
-    if (FAILED(hr))
-        return hr;
-
-    const size_t rowCount = ComputeScanlines(srcImage.format, srcImage.height);
-    if (!rowCount)
-        return E_UNEXPECTED;
-
-    const uint8_t* sptr = srcImage.pixels;
-    if (!sptr)
-        return E_POINTER;
-
-    uint8_t* dptr = m_image[0].pixels;
-    if (!dptr)
-        return E_POINTER;
-
-    const size_t spitch = srcImage.rowPitch;
-    const size_t dpitch = m_image[0].rowPitch;
-
-    const size_t size = std::min<size_t>(dpitch, spitch);
-
-    for (size_t y = 0; y < rowCount; ++y)
-    {
-        memcpy(dptr, sptr, size);
-        sptr += spitch;
-        dptr += dpitch;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT ScratchImage::InitializeArrayFromImages(const Image* images, size_t nImages, bool allow1D, CP_FLAGS flags) noexcept
-{
-    if (!images || !nImages)
-        return E_INVALIDARG;
-
-    const DXGI_FORMAT format = images[0].format;
-    const size_t width = images[0].width;
-    const size_t height = images[0].height;
-
-    for (size_t index = 0; index < nImages; ++index)
-    {
-        if (!images[index].pixels)
-            return E_POINTER;
-
-        if (images[index].format != format || images[index].width != width || images[index].height != height)
-        {
-            // All images must be the same format, width, and height
-            return E_FAIL;
-        }
-    }
-
-    HRESULT hr = (height > 1 || !allow1D)
-        ? Initialize2D(format, width, height, nImages, 1, flags)
-        : Initialize1D(format, width, nImages, 1, flags);
-
-    if (FAILED(hr))
-        return hr;
-
-    const size_t rowCount = ComputeScanlines(format, height);
-    if (!rowCount)
-        return E_UNEXPECTED;
-
-    for (size_t index = 0; index < nImages; ++index)
-    {
-        const uint8_t* sptr = images[index].pixels;
-        if (!sptr)
-            return E_POINTER;
-
-        assert(index < m_nimages);
-        uint8_t* dptr = m_image[index].pixels;
-        if (!dptr)
-            return E_POINTER;
-
-        const size_t spitch = images[index].rowPitch;
-        const size_t dpitch = m_image[index].rowPitch;
-
-        const size_t size = std::min<size_t>(dpitch, spitch);
-
-        for (size_t y = 0; y < rowCount; ++y)
-        {
-            memcpy(dptr, sptr, size);
-            sptr += spitch;
-            dptr += dpitch;
-        }
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT ScratchImage::InitializeCubeFromImages(const Image* images, size_t nImages, CP_FLAGS flags) noexcept
-{
-    if (!images || !nImages)
-        return E_INVALIDARG;
-
-    // A DirectX11 cubemap is just a 2D texture array that is a multiple of 6 for each cube
-    if ((nImages % 6) != 0)
-        return E_INVALIDARG;
-
-    HRESULT hr = InitializeArrayFromImages(images, nImages, false, flags);
-    if (FAILED(hr))
-        return hr;
-
-    m_metadata.miscFlags |= TEX_MISC_TEXTURECUBE;
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT ScratchImage::Initialize3DFromImages(const Image* images, size_t depth, CP_FLAGS flags) noexcept
-{
-    if (!images || !depth)
-        return E_INVALIDARG;
-
-    const DXGI_FORMAT format = images[0].format;
-    const size_t width = images[0].width;
-    const size_t height = images[0].height;
-
-    for (size_t slice = 0; slice < depth; ++slice)
-    {
-        if (!images[slice].pixels)
-            return E_POINTER;
-
-        if (images[slice].format != format || images[slice].width != width || images[slice].height != height)
-        {
-            // All images must be the same format, width, and height
-            return E_FAIL;
-        }
-    }
-
-    HRESULT hr = Initialize3D(format, width, height, depth, 1, flags);
-    if (FAILED(hr))
-        return hr;
-
-    const size_t rowCount = ComputeScanlines(format, height);
-    if (!rowCount)
-        return E_UNEXPECTED;
-
-    for (size_t slice = 0; slice < depth; ++slice)
-    {
-        const uint8_t* sptr = images[slice].pixels;
-        if (!sptr)
-            return E_POINTER;
-
-        assert(slice < m_nimages);
-        uint8_t* dptr = m_image[slice].pixels;
-        if (!dptr)
-            return E_POINTER;
-
-        const size_t spitch = images[slice].rowPitch;
-        const size_t dpitch = m_image[slice].rowPitch;
-
-        const size_t size = std::min<size_t>(dpitch, spitch);
-
-        for (size_t y = 0; y < rowCount; ++y)
-        {
-            memcpy(dptr, sptr, size);
-            sptr += spitch;
-            dptr += dpitch;
-        }
-    }
-
-    return S_OK;
-}
-
-void ScratchImage::Release() noexcept
-{
-    m_nimages = 0;
-    m_size = 0;
-
-    if (m_image)
-    {
-        delete[] m_image;
-        m_image = nullptr;
-    }
-
-    if (m_memory)
-    {
-        _aligned_free(m_memory);
-        m_memory = nullptr;
-    }
-
-    memset(&m_metadata, 0, sizeof(m_metadata));
-}
-
-_Use_decl_annotations_
-bool ScratchImage::OverrideFormat(DXGI_FORMAT f) noexcept
-{
-    if (!m_image)
-        return false;
-
-    if (!IsValid(f) || IsPlanar(f) || IsPalettized(f))
-        return false;
-
-    for (size_t index = 0; index < m_nimages; ++index)
-    {
-        m_image[index].format = f;
-    }
-
-    m_metadata.format = f;
-
-    return true;
-}
-
-_Use_decl_annotations_
-const Image* ScratchImage::GetImage(size_t mip, size_t item, size_t slice) const noexcept
-{
-    if (mip >= m_metadata.mipLevels)
-        return nullptr;
-
-    size_t index = 0;
-
-    switch (m_metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-    case TEX_DIMENSION_TEXTURE2D:
-        if (slice > 0)
-            return nullptr;
-
-        if (item >= m_metadata.arraySize)
-            return nullptr;
-
-        index = item*(m_metadata.mipLevels) + mip;
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        if (item > 0)
-        {
-            // No support for arrays of volumes
-            return nullptr;
-        }
-        else
-        {
-            size_t d = m_metadata.depth;
-
-            for (size_t level = 0; level < mip; ++level)
-            {
-                index += d;
-                if (d > 1)
-                    d >>= 1;
-            }
-
-            if (slice >= d)
-                return nullptr;
-
-            index += slice;
-        }
-        break;
-
-    default:
-        return nullptr;
-    }
-
-    return &m_image[index];
-}
-
-bool ScratchImage::IsAlphaAllOpaque() const noexcept
-{
-    if (!m_image)
-        return false;
-
-    if (!HasAlpha(m_metadata.format))
-        return true;
-
-    if (IsCompressed(m_metadata.format))
-    {
-        for (size_t index = 0; index < m_nimages; ++index)
-        {
-            if (!IsAlphaAllOpaqueBC(m_image[index]))
-                return false;
-        }
-    }
-    else
-    {
-        auto scanline = make_AlignedArrayXMVECTOR(m_metadata.width);
-        if (!scanline)
-            return false;
-
-        static const XMVECTORF32 threshold = { { { 0.997f, 0.997f, 0.997f, 0.997f } } };
-
-        for (size_t index = 0; index < m_nimages; ++index)
-        {
-        #pragma warning( suppress : 6011 )
-            const Image& img = m_image[index];
-
-            const uint8_t *pPixels = img.pixels;
-            assert(pPixels);
-
-            for (size_t h = 0; h < img.height; ++h)
-            {
-                if (!LoadScanline(scanline.get(), img.width, pPixels, img.rowPitch, img.format))
-                    return false;
-
-                const XMVECTOR* ptr = scanline.get();
-                for (size_t w = 0; w < img.width; ++w)
-                {
-                    const XMVECTOR alpha = XMVectorSplatW(*ptr);
-                    if (XMVector4Less(alpha, threshold))
-                        return false;
-                    ++ptr;
-                }
-
-                pPixels += img.rowPitch;
-            }
-        }
-    }
-
-    return true;
-}
diff --git a/thirdparty/directxtex/DirectXTexMipmaps.cpp b/thirdparty/directxtex/DirectXTexMipmaps.cpp
deleted file mode 100644
index da9df6e..0000000
--- a/thirdparty/directxtex/DirectXTexMipmaps.cpp
+++ /dev/null
@@ -1,3529 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexMipMaps.cpp
-//
-// DirectX Texture Library - Mip-map generation
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#include "filters.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-using Microsoft::WRL::ComPtr;
-
-namespace
-{
-    constexpr bool ispow2(_In_ size_t x) noexcept
-    {
-        return ((x != 0) && !(x & (x - 1)));
-    }
-
-
-    size_t CountMips(_In_ size_t width, _In_ size_t height) noexcept
-    {
-        size_t mipLevels = 1;
-
-        while (height > 1 || width > 1)
-        {
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-
-            ++mipLevels;
-        }
-
-        return mipLevels;
-    }
-
-
-    size_t CountMips3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth) noexcept
-    {
-        size_t mipLevels = 1;
-
-        while (height > 1 || width > 1 || depth > 1)
-        {
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-
-            if (depth > 1)
-                depth >>= 1;
-
-            ++mipLevels;
-        }
-
-        return mipLevels;
-    }
-
-#ifdef _WIN32
-    HRESULT EnsureWicBitmapPixelFormat(
-        _In_ IWICImagingFactory* pWIC,
-        _In_ IWICBitmap* src,
-        _In_ TEX_FILTER_FLAGS filter,
-        _In_ const WICPixelFormatGUID& desiredPixelFormat,
-        _Deref_out_ IWICBitmap** dest) noexcept
-    {
-        if (!pWIC || !src || !dest)
-            return E_POINTER;
-
-        *dest = nullptr;
-
-        WICPixelFormatGUID actualPixelFormat;
-        HRESULT hr = src->GetPixelFormat(&actualPixelFormat);
-
-        if (SUCCEEDED(hr))
-        {
-            if (memcmp(&actualPixelFormat, &desiredPixelFormat, sizeof(WICPixelFormatGUID)) == 0)
-            {
-                src->AddRef();
-                *dest = src;
-            }
-            else
-            {
-                ComPtr<IWICFormatConverter> converter;
-                hr = pWIC->CreateFormatConverter(converter.GetAddressOf());
-
-                if (SUCCEEDED(hr))
-                {
-                    BOOL canConvert = FALSE;
-                    hr = converter->CanConvert(actualPixelFormat, desiredPixelFormat, &canConvert);
-                    if (FAILED(hr) || !canConvert)
-                    {
-                        return E_UNEXPECTED;
-                    }
-                }
-
-                if (SUCCEEDED(hr))
-                {
-                    hr = converter->Initialize(src, desiredPixelFormat, GetWICDither(filter), nullptr,
-                        0, WICBitmapPaletteTypeMedianCut);
-                }
-
-                if (SUCCEEDED(hr))
-                {
-                    hr = pWIC->CreateBitmapFromSource(converter.Get(), WICBitmapCacheOnDemand, dest);
-                }
-            }
-        }
-
-        return hr;
-    }
-#endif // WIN32
-
-
-#if DIRECTX_MATH_VERSION >= 310
-#define VectorSum XMVectorSum
-#else
-    inline XMVECTOR XM_CALLCONV VectorSum
-    (
-        FXMVECTOR V
-    )
-    {
-        XMVECTOR vTemp = XMVectorSwizzle<2, 3, 0, 1>(V);
-        XMVECTOR vTemp2 = XMVectorAdd(V, vTemp);
-        vTemp = XMVectorSwizzle<1, 0, 3, 2>(vTemp2);
-        return XMVectorAdd(vTemp, vTemp2);
-    }
-#endif
-
-
-    HRESULT ScaleAlpha(
-        const Image& srcImage,
-        float alphaScale,
-        const Image& destImage) noexcept
-    {
-        assert(srcImage.width == destImage.width);
-        assert(srcImage.height == destImage.height);
-
-        auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
-        if (!scanline)
-        {
-            return E_OUTOFMEMORY;
-        }
-
-        const uint8_t* pSrc = srcImage.pixels;
-        uint8_t* pDest = destImage.pixels;
-        if (!pSrc || !pDest)
-        {
-            return E_POINTER;
-        }
-
-        const XMVECTOR vscale = XMVectorReplicate(alphaScale);
-
-        for (size_t h = 0; h < srcImage.height; ++h)
-        {
-            if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
-            {
-                return E_FAIL;
-            }
-
-            XMVECTOR* ptr = scanline.get();
-            for (size_t w = 0; w < srcImage.width; ++w)
-            {
-                const XMVECTOR v = *ptr;
-                const XMVECTOR alpha = XMVectorMultiply(XMVectorSplatW(v), vscale);
-                *(ptr++) = XMVectorSelect(alpha, v, g_XMSelect1110);
-            }
-
-            if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
-            {
-                return E_FAIL;
-            }
-
-            pSrc += srcImage.rowPitch;
-            pDest += destImage.rowPitch;
-        }
-
-        return S_OK;
-    }
-
-
-    void GenerateAlphaCoverageConvolutionVectors(
-        _In_ size_t N,
-        _Out_writes_(N*N) XMVECTOR* vectors) noexcept
-    {
-        for (size_t sy = 0; sy < N; ++sy)
-        {
-            const float fy = (float(sy) + 0.5f) / float(N);
-            const float ify = 1.0f - fy;
-
-            for (size_t sx = 0; sx < N; ++sx)
-            {
-                const float fx = (float(sx) + 0.5f) / float(N);
-                const float ifx = 1.0f - fx;
-
-                // [0]=(x+0, y+0), [1]=(x+0, y+1), [2]=(x+1, y+0), [3]=(x+1, y+1)
-                vectors[sy * N + sx] = XMVectorSet(ifx * ify, ifx * fy, fx * ify, fx * fy);
-            }
-        }
-    }
-
-
-    HRESULT CalculateAlphaCoverage(
-        const Image& srcImage,
-        float alphaReference,
-        float alphaScale,
-        float& coverage) noexcept
-    {
-        coverage = 0.0f;
-
-        auto row0 = make_AlignedArrayXMVECTOR(srcImage.width);
-        if (!row0)
-        {
-            return E_OUTOFMEMORY;
-        }
-
-        auto row1 = make_AlignedArrayXMVECTOR(srcImage.width);
-        if (!row1)
-        {
-            return E_OUTOFMEMORY;
-        }
-
-        const XMVECTOR scale = XMVectorReplicate(alphaScale);
-
-        const uint8_t *pSrcRow0 = srcImage.pixels;
-        if (!pSrcRow0)
-        {
-            return E_POINTER;
-        }
-
-        constexpr size_t N = 8;
-        XMVECTOR convolution[N * N];
-        GenerateAlphaCoverageConvolutionVectors(N, convolution);
-
-        size_t coverageCount = 0;
-        for (size_t y = 0; y < srcImage.height - 1; ++y)
-        {
-            if (!LoadScanlineLinear(row0.get(), srcImage.width, pSrcRow0, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT))
-            {
-                return E_FAIL;
-            }
-
-            const uint8_t *pSrcRow1 = pSrcRow0 + srcImage.rowPitch;
-            if (!LoadScanlineLinear(row1.get(), srcImage.width, pSrcRow1, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT))
-            {
-                return E_FAIL;
-            }
-
-            const XMVECTOR* pRow0 = row0.get();
-            const XMVECTOR* pRow1 = row1.get();
-            for (size_t x = 0; x < srcImage.width - 1; ++x)
-            {
-                // [0]=(x+0, y+0), [1]=(x+0, y+1), [2]=(x+1, y+0), [3]=(x+1, y+1)
-                XMVECTOR r0 = XMVectorSplatW(*pRow0);
-                XMVECTOR r1 = XMVectorSplatW(*pRow1);
-
-                XMVECTOR v1 = XMVectorSaturate(XMVectorMultiply(r0, scale));
-                const XMVECTOR v2 = XMVectorSaturate(XMVectorMultiply(r1, scale));
-
-                r0 = XMVectorSplatW(*(++pRow0));
-                r1 = XMVectorSplatW(*(++pRow1));
-
-                XMVECTOR v3 = XMVectorSaturate(XMVectorMultiply(XMVectorSplatW(r0), scale));
-                const XMVECTOR v4 = XMVectorSaturate(XMVectorMultiply(XMVectorSplatW(r1), scale));
-
-                v1 = XMVectorMergeXY(v1, v2); // [v1.x v2.x --- ---]
-                v3 = XMVectorMergeXY(v3, v4); // [v3.x v4.x --- ---]
-
-                XMVECTOR v = XMVectorPermute<0, 1, 4, 5>(v1, v3); // [v1.x v2.x v3.x v4.x]
-
-                for (size_t sy = 0; sy < N; ++sy)
-                {
-                    const size_t ry = sy * N;
-                    for (size_t sx = 0; sx < N; ++sx)
-                    {
-                        v = VectorSum(XMVectorMultiply(v, convolution[ry + sx]));
-                        if (XMVectorGetX(v) > alphaReference)
-                        {
-                            ++coverageCount;
-                        }
-                    }
-                }
-            }
-
-            pSrcRow0 = pSrcRow1;
-        }
-
-        float cscale = static_cast<float>((srcImage.width - 1) * (srcImage.height - 1) * N * N);
-        if (cscale > 0.f)
-        {
-            coverage = static_cast<float>(coverageCount) / cscale;
-        }
-
-        return S_OK;
-    }
-
-
-    HRESULT EstimateAlphaScaleForCoverage(
-        const Image& srcImage,
-        float alphaReference,
-        float targetCoverage,
-        float& alphaScale) noexcept
-    {
-        float minAlphaScale = 0.0f;
-        float maxAlphaScale = 4.0f;
-        float bestError = FLT_MAX;
-
-        // Determine desired scale using a binary search. Hardcoded to 10 steps max.
-        alphaScale = 1.0f;
-        constexpr size_t N = 10;
-        for (size_t i = 0; i < N; ++i)
-        {
-            float currentCoverage = 0.0f;
-            HRESULT hr = CalculateAlphaCoverage(srcImage, alphaReference, alphaScale, currentCoverage);
-            if (FAILED(hr))
-            {
-                return hr;
-            }
-
-            const float error = fabsf(currentCoverage - targetCoverage);
-            if (error < bestError)
-            {
-                bestError = error;
-            }
-
-            if (currentCoverage < targetCoverage)
-            {
-                minAlphaScale = alphaScale;
-            }
-            else if (currentCoverage > targetCoverage)
-            {
-                maxAlphaScale = alphaScale;
-            }
-            else
-            {
-                break;
-            }
-
-            alphaScale = (minAlphaScale + maxAlphaScale) * 0.5f;
-        }
-
-        return S_OK;
-    }
-}
-
-_Use_decl_annotations_
-bool DirectX::Internal::CalculateMipLevels(
-    size_t width,
-    size_t height,
-    size_t& mipLevels) noexcept
-{
-    if (mipLevels > 1)
-    {
-        const size_t maxMips = CountMips(width, height);
-        if (mipLevels > maxMips)
-            return false;
-    }
-    else if (mipLevels == 0)
-    {
-        mipLevels = CountMips(width, height);
-    }
-    else
-    {
-        mipLevels = 1;
-    }
-    return true;
-}
-
-_Use_decl_annotations_
-bool DirectX::Internal::CalculateMipLevels3D(
-    size_t width,
-    size_t height,
-    size_t depth,
-    size_t& mipLevels) noexcept
-{
-    if (mipLevels > 1)
-    {
-        const size_t maxMips = CountMips3D(width, height, depth);
-        if (mipLevels > maxMips)
-            return false;
-    }
-    else if (mipLevels == 0)
-    {
-        mipLevels = CountMips3D(width, height, depth);
-    }
-    else
-    {
-        mipLevels = 1;
-    }
-    return true;
-}
-
-#ifdef _WIN32
-//--- Resizing color and alpha channels separately using WIC ---
-_Use_decl_annotations_
-HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
-    IWICImagingFactory* pWIC,
-    bool iswic2,
-    IWICBitmap* original,
-    size_t newWidth,
-    size_t newHeight,
-    TEX_FILTER_FLAGS filter,
-    const Image* img) noexcept
-{
-    if (!pWIC || !original || !img)
-        return E_POINTER;
-
-    const WICBitmapInterpolationMode interpolationMode = GetWICInterp(filter);
-
-    WICPixelFormatGUID desiredPixelFormat = GUID_WICPixelFormatUndefined;
-    HRESULT hr = original->GetPixelFormat(&desiredPixelFormat);
-
-    size_t colorBytesInPixel = 0;
-    size_t colorBytesPerPixel = 0;
-    size_t colorWithAlphaBytesPerPixel = 0;
-    WICPixelFormatGUID colorPixelFormat = GUID_WICPixelFormatUndefined;
-    WICPixelFormatGUID colorWithAlphaPixelFormat = GUID_WICPixelFormatUndefined;
-
-    if (SUCCEEDED(hr))
-    {
-        ComPtr<IWICComponentInfo> componentInfo;
-        hr = pWIC->CreateComponentInfo(desiredPixelFormat, componentInfo.GetAddressOf());
-
-        ComPtr<IWICPixelFormatInfo> pixelFormatInfo;
-        if (SUCCEEDED(hr))
-        {
-            hr = componentInfo.As(&pixelFormatInfo);
-        }
-
-        UINT bitsPerPixel = 0;
-        if (SUCCEEDED(hr))
-        {
-            hr = pixelFormatInfo->GetBitsPerPixel(&bitsPerPixel);
-        }
-
-        if (SUCCEEDED(hr))
-        {
-            if (bitsPerPixel <= 32)
-            {
-                colorBytesInPixel = colorBytesPerPixel = 3;
-                colorPixelFormat = GUID_WICPixelFormat24bppBGR;
-
-                colorWithAlphaBytesPerPixel = 4;
-                colorWithAlphaPixelFormat = GUID_WICPixelFormat32bppBGRA;
-            }
-            else
-            {
-            #if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
-                if (iswic2)
-                {
-                    colorBytesInPixel = colorBytesPerPixel = 12;
-                    colorPixelFormat = GUID_WICPixelFormat96bppRGBFloat;
-                }
-                else
-                #else
-                UNREFERENCED_PARAMETER(iswic2);
-            #endif
-                {
-                    colorBytesInPixel = 12;
-                    colorBytesPerPixel = 16;
-                    colorPixelFormat = GUID_WICPixelFormat128bppRGBFloat;
-                }
-
-                colorWithAlphaBytesPerPixel = 16;
-                colorWithAlphaPixelFormat = GUID_WICPixelFormat128bppRGBAFloat;
-            }
-        }
-    }
-
-    // Resize color only image (no alpha channel)
-    ComPtr<IWICBitmap> resizedColor;
-    if (SUCCEEDED(hr))
-    {
-        ComPtr<IWICBitmapScaler> colorScaler;
-        hr = pWIC->CreateBitmapScaler(colorScaler.GetAddressOf());
-        if (SUCCEEDED(hr))
-        {
-            ComPtr<IWICBitmap> converted;
-            hr = EnsureWicBitmapPixelFormat(pWIC, original, filter, colorPixelFormat, converted.GetAddressOf());
-            if (SUCCEEDED(hr))
-            {
-                hr = colorScaler->Initialize(converted.Get(), static_cast<UINT>(newWidth), static_cast<UINT>(newHeight), interpolationMode);
-            }
-        }
-
-        if (SUCCEEDED(hr))
-        {
-            ComPtr<IWICBitmap> resized;
-            hr = pWIC->CreateBitmapFromSource(colorScaler.Get(), WICBitmapCacheOnDemand, resized.GetAddressOf());
-            if (SUCCEEDED(hr))
-            {
-                hr = EnsureWicBitmapPixelFormat(pWIC, resized.Get(), filter, colorPixelFormat, resizedColor.GetAddressOf());
-            }
-        }
-    }
-
-    // Resize color+alpha image
-    ComPtr<IWICBitmap> resizedColorWithAlpha;
-    if (SUCCEEDED(hr))
-    {
-        ComPtr<IWICBitmapScaler> colorWithAlphaScaler;
-        hr = pWIC->CreateBitmapScaler(colorWithAlphaScaler.GetAddressOf());
-        if (SUCCEEDED(hr))
-        {
-            ComPtr<IWICBitmap> converted;
-            hr = EnsureWicBitmapPixelFormat(pWIC, original, filter, colorWithAlphaPixelFormat, converted.GetAddressOf());
-            if (SUCCEEDED(hr))
-            {
-                hr = colorWithAlphaScaler->Initialize(converted.Get(), static_cast<UINT>(newWidth), static_cast<UINT>(newHeight), interpolationMode);
-            }
-        }
-
-        if (SUCCEEDED(hr))
-        {
-            ComPtr<IWICBitmap> resized;
-            hr = pWIC->CreateBitmapFromSource(colorWithAlphaScaler.Get(), WICBitmapCacheOnDemand, resized.GetAddressOf());
-            if (SUCCEEDED(hr))
-            {
-                hr = EnsureWicBitmapPixelFormat(pWIC, resized.Get(), filter, colorWithAlphaPixelFormat, resizedColorWithAlpha.GetAddressOf());
-            }
-        }
-    }
-
-    // Merge pixels (copying color channels from color only image to color+alpha image)
-    if (SUCCEEDED(hr))
-    {
-        ComPtr<IWICBitmapLock> colorLock;
-        ComPtr<IWICBitmapLock> colorWithAlphaLock;
-        hr = resizedColor->Lock(nullptr, WICBitmapLockRead, colorLock.GetAddressOf());
-        if (SUCCEEDED(hr))
-        {
-            hr = resizedColorWithAlpha->Lock(nullptr, WICBitmapLockWrite, colorWithAlphaLock.GetAddressOf());
-        }
-
-        if (SUCCEEDED(hr))
-        {
-            BYTE* colorWithAlphaData = nullptr;
-            UINT colorWithAlphaSizeInBytes = 0;
-            UINT colorWithAlphaStride = 0;
-
-            hr = colorWithAlphaLock->GetDataPointer(&colorWithAlphaSizeInBytes, &colorWithAlphaData);
-            if (SUCCEEDED(hr))
-            {
-                if (!colorWithAlphaData)
-                {
-                    hr = E_POINTER;
-                }
-                else
-                {
-                    hr = colorWithAlphaLock->GetStride(&colorWithAlphaStride);
-                }
-            }
-
-            BYTE* colorData = nullptr;
-            UINT colorSizeInBytes = 0;
-            UINT colorStride = 0;
-            if (SUCCEEDED(hr))
-            {
-                hr = colorLock->GetDataPointer(&colorSizeInBytes, &colorData);
-                if (SUCCEEDED(hr))
-                {
-                    if (!colorData)
-                    {
-                        hr = E_POINTER;
-                    }
-                    else
-                    {
-                        hr = colorLock->GetStride(&colorStride);
-                    }
-                }
-            }
-
-            for (size_t j = 0; SUCCEEDED(hr) && j < newHeight; j++)
-            {
-                for (size_t i = 0; SUCCEEDED(hr) && i < newWidth; i++)
-                {
-                    size_t colorWithAlphaIndex = (j * colorWithAlphaStride) + (i * colorWithAlphaBytesPerPixel);
-                    const size_t colorIndex = (j * colorStride) + (i * colorBytesPerPixel);
-
-                    if (((colorWithAlphaIndex + colorBytesInPixel) > colorWithAlphaSizeInBytes)
-                        || ((colorIndex + colorBytesPerPixel) > colorSizeInBytes))
-                    {
-                        hr = E_INVALIDARG;
-                    }
-                    else
-                    {
-                    #pragma warning( suppress : 26014 6386 ) // No overflow possible here
-                        memcpy_s(colorWithAlphaData + colorWithAlphaIndex, colorWithAlphaBytesPerPixel, colorData + colorIndex, colorBytesInPixel);
-                    }
-                }
-            }
-        }
-    }
-
-    if (SUCCEEDED(hr))
-    {
-        if (img->rowPitch > UINT32_MAX || img->slicePitch > UINT32_MAX)
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-        ComPtr<IWICBitmap> wicBitmap;
-        hr = EnsureWicBitmapPixelFormat(pWIC, resizedColorWithAlpha.Get(), filter, desiredPixelFormat, wicBitmap.GetAddressOf());
-        if (SUCCEEDED(hr))
-        {
-            hr = wicBitmap->CopyPixels(nullptr, static_cast<UINT>(img->rowPitch), static_cast<UINT>(img->slicePitch), img->pixels);
-        }
-    }
-
-    return hr;
-}
-#endif // WIN32
-
-namespace
-{
-#ifdef _WIN32
-    //--- determine when to use WIC vs. non-WIC paths ---
-    bool UseWICFiltering(_In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS filter) noexcept
-    {
-        if (filter & TEX_FILTER_FORCE_NON_WIC)
-        {
-            // Explicit flag indicates use of non-WIC code paths
-            return false;
-        }
-
-        if (filter & TEX_FILTER_FORCE_WIC)
-        {
-            // Explicit flag to use WIC code paths, skips all the case checks below
-            return true;
-        }
-
-        if (IsSRGB(format) || (filter & TEX_FILTER_SRGB))
-        {
-            // Use non-WIC code paths for sRGB correct filtering
-            return false;
-        }
-
-    #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
-        if (format == DXGI_FORMAT_R16G16B16A16_FLOAT
-            || format == DXGI_FORMAT_R16_FLOAT)
-        {
-            // Use non-WIC code paths as these conversions are not supported by Xbox version of WIC
-            return false;
-        }
-    #endif
-
-        static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK");
-
-        switch (filter & TEX_FILTER_MODE_MASK)
-        {
-        case TEX_FILTER_LINEAR:
-            if (filter & TEX_FILTER_WRAP)
-            {
-                // WIC only supports 'clamp' semantics (MIRROR is equivalent to clamp for linear)
-                return false;
-            }
-
-            if (BitsPerColor(format) > 8)
-            {
-                // Avoid the WIC bitmap scaler when doing Linear filtering of XR/HDR formats
-                return false;
-            }
-            break;
-
-        case TEX_FILTER_CUBIC:
-            if (filter & (TEX_FILTER_WRAP | TEX_FILTER_MIRROR))
-            {
-                // WIC only supports 'clamp' semantics
-                return false;
-            }
-
-            if (BitsPerColor(format) > 8)
-            {
-                // Avoid the WIC bitmap scaler when doing Cubic filtering of XR/HDR formats
-                return false;
-            }
-            break;
-
-        case TEX_FILTER_TRIANGLE:
-            // WIC does not implement this filter
-            return false;
-
-        default:
-            if (BitsPerColor(format) > 8)
-            {
-                // Avoid the WIC bitmap scaler when doing filtering of XR/HDR formats
-                return false;
-            }
-            break;
-        }
-
-        return true;
-    }
-
-
-    //--- mipmap (1D/2D) generation using WIC image scalar ---
-    HRESULT GenerateMipMapsUsingWIC(
-        _In_ const Image& baseImage,
-        _In_ TEX_FILTER_FLAGS filter,
-        _In_ size_t levels,
-        _In_ const WICPixelFormatGUID& pfGUID,
-        _In_ const ScratchImage& mipChain,
-        _In_ size_t item) noexcept
-    {
-        assert(levels > 1);
-
-        if (!baseImage.pixels || !mipChain.GetPixels())
-            return E_POINTER;
-
-        bool iswic2 = false;
-        auto pWIC = GetWICFactory(iswic2);
-        if (!pWIC)
-            return E_NOINTERFACE;
-
-        size_t width = baseImage.width;
-        size_t height = baseImage.height;
-
-        if (baseImage.rowPitch > UINT32_MAX || baseImage.slicePitch > UINT32_MAX)
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-        ComPtr<IWICBitmap> source;
-        HRESULT hr = pWIC->CreateBitmapFromMemory(static_cast<UINT>(width), static_cast<UINT>(height), pfGUID,
-            static_cast<UINT>(baseImage.rowPitch), static_cast<UINT>(baseImage.slicePitch),
-            baseImage.pixels, source.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        // Copy base image to top miplevel
-        const Image *img0 = mipChain.GetImage(0, item, 0);
-        if (!img0)
-            return E_POINTER;
-
-        uint8_t* pDest = img0->pixels;
-        if (!pDest)
-            return E_POINTER;
-
-        const uint8_t *pSrc = baseImage.pixels;
-        for (size_t h = 0; h < height; ++h)
-        {
-            const size_t msize = std::min<size_t>(img0->rowPitch, baseImage.rowPitch);
-            memcpy_s(pDest, img0->rowPitch, pSrc, msize);
-            pSrc += baseImage.rowPitch;
-            pDest += img0->rowPitch;
-        }
-
-        ComPtr<IWICComponentInfo> componentInfo;
-        hr = pWIC->CreateComponentInfo(pfGUID, componentInfo.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        ComPtr<IWICPixelFormatInfo2> pixelFormatInfo;
-        hr = componentInfo.As(&pixelFormatInfo);
-        if (FAILED(hr))
-            return hr;
-
-        BOOL supportsTransparency = FALSE;
-        hr = pixelFormatInfo->SupportsTransparency(&supportsTransparency);
-        if (FAILED(hr))
-            return hr;
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-            const Image *img = mipChain.GetImage(level, item, 0);
-            if (!img)
-                return E_POINTER;
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-
-            assert(img->width == width && img->height == height && img->format == baseImage.format);
-
-            if ((filter & TEX_FILTER_SEPARATE_ALPHA) && supportsTransparency)
-            {
-                hr = ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), width, height, filter, img);
-                if (FAILED(hr))
-                    return hr;
-            }
-            else
-            {
-                ComPtr<IWICBitmapScaler> scaler;
-                hr = pWIC->CreateBitmapScaler(scaler.GetAddressOf());
-                if (FAILED(hr))
-                    return hr;
-
-                if (img->rowPitch > UINT32_MAX || img->slicePitch > UINT32_MAX)
-                    return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-                hr = scaler->Initialize(source.Get(),
-                    static_cast<UINT>(width), static_cast<UINT>(height),
-                    GetWICInterp(filter));
-                if (FAILED(hr))
-                    return hr;
-
-                WICPixelFormatGUID pfScaler;
-                hr = scaler->GetPixelFormat(&pfScaler);
-                if (FAILED(hr))
-                    return hr;
-
-                if (memcmp(&pfScaler, &pfGUID, sizeof(WICPixelFormatGUID)) == 0)
-                {
-                    hr = scaler->CopyPixels(nullptr, static_cast<UINT>(img->rowPitch), static_cast<UINT>(img->slicePitch), img->pixels);
-                    if (FAILED(hr))
-                        return hr;
-                }
-                else
-                {
-                    // The WIC bitmap scaler is free to return a different pixel format than the source image, so here we
-                    // convert it back
-                    ComPtr<IWICFormatConverter> FC;
-                    hr = pWIC->CreateFormatConverter(FC.GetAddressOf());
-                    if (FAILED(hr))
-                        return hr;
-
-                    BOOL canConvert = FALSE;
-                    hr = FC->CanConvert(pfScaler, pfGUID, &canConvert);
-                    if (FAILED(hr) || !canConvert)
-                    {
-                        return E_UNEXPECTED;
-                    }
-
-                    hr = FC->Initialize(scaler.Get(), pfGUID, GetWICDither(filter), nullptr,
-                        0, WICBitmapPaletteTypeMedianCut);
-                    if (FAILED(hr))
-                        return hr;
-
-                    hr = FC->CopyPixels(nullptr, static_cast<UINT>(img->rowPitch), static_cast<UINT>(img->slicePitch), img->pixels);
-                    if (FAILED(hr))
-                        return hr;
-                }
-            }
-        }
-
-        return S_OK;
-    }
-#endif // WIN32
-
-
-    //-------------------------------------------------------------------------------------
-    // Generate (1D/2D) mip-map helpers (custom filtering)
-    //-------------------------------------------------------------------------------------
-    HRESULT Setup2DMips(
-        _In_reads_(nimages) const Image* baseImages,
-        _In_ size_t nimages,
-        _In_ const TexMetadata& mdata,
-        _Out_ ScratchImage& mipChain) noexcept
-    {
-        if (!baseImages || !nimages)
-            return E_INVALIDARG;
-
-        assert(mdata.mipLevels > 1);
-        assert(mdata.arraySize == nimages);
-        assert(mdata.depth == 1 && mdata.dimension != TEX_DIMENSION_TEXTURE3D);
-        assert(mdata.width == baseImages[0].width);
-        assert(mdata.height == baseImages[0].height);
-        assert(mdata.format == baseImages[0].format);
-
-        HRESULT hr = mipChain.Initialize(mdata);
-        if (FAILED(hr))
-            return hr;
-
-        // Copy base image(s) to top of mip chain
-        for (size_t item = 0; item < nimages; ++item)
-        {
-            const Image& src = baseImages[item];
-
-            const Image *dest = mipChain.GetImage(0, item, 0);
-            if (!dest)
-            {
-                mipChain.Release();
-                return E_POINTER;
-            }
-
-            assert(src.format == dest->format);
-
-            uint8_t* pDest = dest->pixels;
-            if (!pDest)
-            {
-                mipChain.Release();
-                return E_POINTER;
-            }
-
-            const uint8_t *pSrc = src.pixels;
-            const size_t rowPitch = src.rowPitch;
-            for (size_t h = 0; h < mdata.height; ++h)
-            {
-                const size_t msize = std::min<size_t>(dest->rowPitch, rowPitch);
-                memcpy(pDest, pSrc, msize);
-                pSrc += rowPitch;
-                pDest += dest->rowPitch;
-            }
-        }
-
-        return S_OK;
-    }
-
-    //--- 2D Point Filter ---
-    HRESULT Generate2DMipsPointFilter(size_t levels, const ScratchImage& mipChain, size_t item) noexcept
-    {
-        if (!mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base image is already placed into the mipChain at the top level... (see _Setup2DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        // Allocate temporary space (2 scanlines)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 2);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* row = target + width;
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-        #ifdef _DEBUG
-            memset(row, 0xCD, sizeof(XMVECTOR)*width);
-        #endif
-
-            // 2D point filter
-            const Image* src = mipChain.GetImage(level - 1, item, 0);
-            const Image* dest = mipChain.GetImage(level, item, 0);
-
-            if (!src || !dest)
-                return E_POINTER;
-
-            const uint8_t* pSrc = src->pixels;
-            uint8_t* pDest = dest->pixels;
-
-            const size_t rowPitch = src->rowPitch;
-
-            const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-            const size_t nheight = (height > 1) ? (height >> 1) : 1;
-
-            const size_t xinc = (width << 16) / nwidth;
-            const size_t yinc = (height << 16) / nheight;
-
-            size_t lasty = size_t(-1);
-
-            size_t sy = 0;
-            for (size_t y = 0; y < nheight; ++y)
-            {
-                if ((lasty ^ sy) >> 16)
-                {
-                    if (!LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
-                        return E_FAIL;
-                    lasty = sy;
-                }
-
-                size_t sx = 0;
-                for (size_t x = 0; x < nwidth; ++x)
-                {
-                    target[x] = row[sx >> 16];
-                    sx += xinc;
-                }
-
-                if (!StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
-                    return E_FAIL;
-                pDest += dest->rowPitch;
-
-                sy += yinc;
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- 2D Box Filter ---
-    HRESULT Generate2DMipsBoxFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        if (!mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base image is already placed into the mipChain at the top level... (see _Setup2DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        if (!ispow2(width) || !ispow2(height))
-            return E_FAIL;
-
-        // Allocate temporary space (3 scanlines)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 3);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* urow0 = target + width;
-        XMVECTOR* urow1 = target + width * 2;
-
-        const XMVECTOR* urow2 = urow0 + 1;
-        const XMVECTOR* urow3 = urow1 + 1;
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-            if (height <= 1)
-            {
-                urow1 = urow0;
-            }
-
-            if (width <= 1)
-            {
-                urow2 = urow0;
-                urow3 = urow1;
-            }
-
-            // 2D box filter
-            const Image* src = mipChain.GetImage(level - 1, item, 0);
-            const Image* dest = mipChain.GetImage(level, item, 0);
-
-            if (!src || !dest)
-                return E_POINTER;
-
-            const uint8_t* pSrc = src->pixels;
-            uint8_t* pDest = dest->pixels;
-
-            const size_t rowPitch = src->rowPitch;
-
-            const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-            const size_t nheight = (height > 1) ? (height >> 1) : 1;
-
-            for (size_t y = 0; y < nheight; ++y)
-            {
-                if (!LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter))
-                    return E_FAIL;
-                pSrc += rowPitch;
-
-                if (urow0 != urow1)
-                {
-                    if (!LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter))
-                        return E_FAIL;
-                    pSrc += rowPitch;
-                }
-
-                for (size_t x = 0; x < nwidth; ++x)
-                {
-                    const size_t x2 = x << 1;
-
-                    AVERAGE4(target[x], urow0[x2], urow1[x2], urow2[x2], urow3[x2])
-                }
-
-                if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
-                    return E_FAIL;
-                pDest += dest->rowPitch;
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- 2D Linear Filter ---
-    HRESULT Generate2DMipsLinearFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        if (!mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base image is already placed into the mipChain at the top level... (see _Setup2DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        // Allocate temporary space (3 scanlines, plus X and Y filters)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 3);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        std::unique_ptr<LinearFilter[]> lf(new (std::nothrow) LinearFilter[width + height]);
-        if (!lf)
-            return E_OUTOFMEMORY;
-
-        LinearFilter* lfX = lf.get();
-        LinearFilter* lfY = lf.get() + width;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* row0 = target + width;
-        XMVECTOR* row1 = target + width * 2;
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-            // 2D linear filter
-            const Image* src = mipChain.GetImage(level - 1, item, 0);
-            const Image* dest = mipChain.GetImage(level, item, 0);
-
-            if (!src || !dest)
-                return E_POINTER;
-
-            const uint8_t* pSrc = src->pixels;
-            uint8_t* pDest = dest->pixels;
-
-            const size_t rowPitch = src->rowPitch;
-
-            const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-            CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
-
-            const size_t nheight = (height > 1) ? (height >> 1) : 1;
-            CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
-
-        #ifdef _DEBUG
-            memset(row0, 0xCD, sizeof(XMVECTOR)*width);
-            memset(row1, 0xDD, sizeof(XMVECTOR)*width);
-        #endif
-
-            size_t u0 = size_t(-1);
-            size_t u1 = size_t(-1);
-
-            for (size_t y = 0; y < nheight; ++y)
-            {
-                auto const& toY = lfY[y];
-
-                if (toY.u0 != u0)
-                {
-                    if (toY.u0 != u1)
-                    {
-                        u0 = toY.u0;
-
-                        if (!LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
-                            return E_FAIL;
-                    }
-                    else
-                    {
-                        u0 = u1;
-                        u1 = size_t(-1);
-
-                        std::swap(row0, row1);
-                    }
-                }
-
-                if (toY.u1 != u1)
-                {
-                    u1 = toY.u1;
-
-                    if (!LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
-                        return E_FAIL;
-                }
-
-                for (size_t x = 0; x < nwidth; ++x)
-                {
-                    auto const& toX = lfX[x];
-
-                    BILINEAR_INTERPOLATE(target[x], toX, toY, row0, row1)
-                }
-
-                if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
-                    return E_FAIL;
-                pDest += dest->rowPitch;
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-        }
-
-        return S_OK;
-    }
-
-    //--- 2D Cubic Filter ---
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wextra-semi-stmt"
-#endif
-
-    HRESULT Generate2DMipsCubicFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        if (!mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base image is already placed into the mipChain at the top level... (see _Setup2DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        // Allocate temporary space (5 scanlines, plus X and Y filters)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 5);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        std::unique_ptr<CubicFilter[]> cf(new (std::nothrow) CubicFilter[width + height]);
-        if (!cf)
-            return E_OUTOFMEMORY;
-
-        CubicFilter* cfX = cf.get();
-        CubicFilter* cfY = cf.get() + width;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* row0 = target + width;
-        XMVECTOR* row1 = target + width * 2;
-        XMVECTOR* row2 = target + width * 3;
-        XMVECTOR* row3 = target + width * 4;
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-            // 2D cubic filter
-            const Image* src = mipChain.GetImage(level - 1, item, 0);
-            const Image* dest = mipChain.GetImage(level, item, 0);
-
-            if (!src || !dest)
-                return E_POINTER;
-
-            const uint8_t* pSrc = src->pixels;
-            uint8_t* pDest = dest->pixels;
-
-            const size_t rowPitch = src->rowPitch;
-
-            const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-            CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
-
-            const size_t nheight = (height > 1) ? (height >> 1) : 1;
-            CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
-
-        #ifdef _DEBUG
-            memset(row0, 0xCD, sizeof(XMVECTOR)*width);
-            memset(row1, 0xDD, sizeof(XMVECTOR)*width);
-            memset(row2, 0xED, sizeof(XMVECTOR)*width);
-            memset(row3, 0xFD, sizeof(XMVECTOR)*width);
-        #endif
-
-            size_t u0 = size_t(-1);
-            size_t u1 = size_t(-1);
-            size_t u2 = size_t(-1);
-            size_t u3 = size_t(-1);
-
-            for (size_t y = 0; y < nheight; ++y)
-            {
-                auto const& toY = cfY[y];
-
-                // Scanline 1
-                if (toY.u0 != u0)
-                {
-                    if (toY.u0 != u1 && toY.u0 != u2 && toY.u0 != u3)
-                    {
-                        u0 = toY.u0;
-
-                        if (!LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
-                            return E_FAIL;
-                    }
-                    else if (toY.u0 == u1)
-                    {
-                        u0 = u1;
-                        u1 = size_t(-1);
-
-                        std::swap(row0, row1);
-                    }
-                    else if (toY.u0 == u2)
-                    {
-                        u0 = u2;
-                        u2 = size_t(-1);
-
-                        std::swap(row0, row2);
-                    }
-                    else if (toY.u0 == u3)
-                    {
-                        u0 = u3;
-                        u3 = size_t(-1);
-
-                        std::swap(row0, row3);
-                    }
-                }
-
-                // Scanline 2
-                if (toY.u1 != u1)
-                {
-                    if (toY.u1 != u2 && toY.u1 != u3)
-                    {
-                        u1 = toY.u1;
-
-                        if (!LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
-                            return E_FAIL;
-                    }
-                    else if (toY.u1 == u2)
-                    {
-                        u1 = u2;
-                        u2 = size_t(-1);
-
-                        std::swap(row1, row2);
-                    }
-                    else if (toY.u1 == u3)
-                    {
-                        u1 = u3;
-                        u3 = size_t(-1);
-
-                        std::swap(row1, row3);
-                    }
-                }
-
-                // Scanline 3
-                if (toY.u2 != u2)
-                {
-                    if (toY.u2 != u3)
-                    {
-                        u2 = toY.u2;
-
-                        if (!LoadScanlineLinear(row2, width, pSrc + (rowPitch * u2), rowPitch, src->format, filter))
-                            return E_FAIL;
-                    }
-                    else
-                    {
-                        u2 = u3;
-                        u3 = size_t(-1);
-
-                        std::swap(row2, row3);
-                    }
-                }
-
-                // Scanline 4
-                if (toY.u3 != u3)
-                {
-                    u3 = toY.u3;
-
-                    if (!LoadScanlineLinear(row3, width, pSrc + (rowPitch * u3), rowPitch, src->format, filter))
-                        return E_FAIL;
-                }
-
-                for (size_t x = 0; x < nwidth; ++x)
-                {
-                    auto const& toX = cfX[x];
-
-                    XMVECTOR C0, C1, C2, C3;
-
-                    CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3]);
-                    CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3]);
-                    CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3]);
-                    CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3]);
-
-                    CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3);
-                }
-
-                if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
-                    return E_FAIL;
-                pDest += dest->rowPitch;
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- 2D Triangle Filter ---
-    HRESULT Generate2DMipsTriangleFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        if (!mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base image is already placed into the mipChain at the top level... (see _Setup2DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        // Allocate initial temporary space (1 scanline, accumulation rows, plus X and Y filters)
-        auto scanline = make_AlignedArrayXMVECTOR(width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        std::unique_ptr<TriangleRow[]> rowActive(new (std::nothrow) TriangleRow[height]);
-        if (!rowActive)
-            return E_OUTOFMEMORY;
-
-        TriangleRow * rowFree = nullptr;
-
-        std::unique_ptr<Filter> tfX, tfY;
-
-        XMVECTOR* row = scanline.get();
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-            // 2D triangle filter
-            const Image* src = mipChain.GetImage(level - 1, item, 0);
-            const Image* dest = mipChain.GetImage(level, item, 0);
-
-            if (!src || !dest)
-                return E_POINTER;
-
-            const uint8_t* pSrc = src->pixels;
-            const size_t rowPitch = src->rowPitch;
-            const uint8_t* pEndSrc = pSrc + rowPitch * height;
-
-            uint8_t* pDest = dest->pixels;
-
-            const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-            HRESULT hr = CreateTriangleFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
-            if (FAILED(hr))
-                return hr;
-
-            const size_t nheight = (height > 1) ? (height >> 1) : 1;
-            hr = CreateTriangleFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
-            if (FAILED(hr))
-                return hr;
-
-        #ifdef _DEBUG
-            memset(row, 0xCD, sizeof(XMVECTOR)*width);
-        #endif
-
-            auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes);
-            auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes);
-
-            // Count times rows get written (and clear out any leftover accumulation rows from last miplevel)
-            for (FilterFrom* yFrom = tfY->from; yFrom < yFromEnd; )
-            {
-                for (size_t j = 0; j < yFrom->count; ++j)
-                {
-                    const size_t v = yFrom->to[j].u;
-                    assert(v < nheight);
-                    TriangleRow* rowAcc = &rowActive[v];
-
-                    ++rowAcc->remaining;
-
-                    if (rowAcc->scanline)
-                    {
-                        memset(rowAcc->scanline.get(), 0, sizeof(XMVECTOR) * nwidth);
-                    }
-                }
-
-                yFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(yFrom) + yFrom->sizeInBytes);
-            }
-
-            // Filter image
-            for (FilterFrom* yFrom = tfY->from; yFrom < yFromEnd; )
-            {
-                // Create accumulation rows as needed
-                for (size_t j = 0; j < yFrom->count; ++j)
-                {
-                    const size_t v = yFrom->to[j].u;
-                    assert(v < nheight);
-                    TriangleRow* rowAcc = &rowActive[v];
-
-                    if (!rowAcc->scanline)
-                    {
-                        if (rowFree)
-                        {
-                            // Steal and reuse scanline from 'free row' list
-                            // (it will always be at least as wide as nwidth due to loop decending order)
-                            assert(rowFree->scanline != nullptr);
-                            rowAcc->scanline.reset(rowFree->scanline.release());
-                            rowFree = rowFree->next;
-                        }
-                        else
-                        {
-                            auto nscanline = make_AlignedArrayXMVECTOR(nwidth);
-                            if (!nscanline)
-                                return E_OUTOFMEMORY;
-                            rowAcc->scanline.swap(nscanline);
-                        }
-
-                        memset(rowAcc->scanline.get(), 0, sizeof(XMVECTOR) * nwidth);
-                    }
-                }
-
-                // Load source scanline
-                if ((pSrc + rowPitch) > pEndSrc)
-                    return E_FAIL;
-
-                if (!LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter))
-                    return E_FAIL;
-
-                pSrc += rowPitch;
-
-                // Process row
-                size_t x = 0;
-                for (FilterFrom* xFrom = tfX->from; xFrom < xFromEnd; ++x)
-                {
-                    for (size_t j = 0; j < yFrom->count; ++j)
-                    {
-                        const size_t v = yFrom->to[j].u;
-                        assert(v < nheight);
-                        const float yweight = yFrom->to[j].weight;
-
-                        XMVECTOR* accPtr = rowActive[v].scanline.get();
-                        if (!accPtr)
-                            return E_POINTER;
-
-                        for (size_t k = 0; k < xFrom->count; ++k)
-                        {
-                            size_t u = xFrom->to[k].u;
-                            assert(u < nwidth);
-
-                            const XMVECTOR weight = XMVectorReplicate(yweight * xFrom->to[k].weight);
-
-                            assert(x < width);
-                            accPtr[u] = XMVectorMultiplyAdd(row[x], weight, accPtr[u]);
-                        }
-                    }
-
-                    xFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(xFrom) + xFrom->sizeInBytes);
-                }
-
-                // Write completed accumulation rows
-                for (size_t j = 0; j < yFrom->count; ++j)
-                {
-                    size_t v = yFrom->to[j].u;
-                    assert(v < nheight);
-                    TriangleRow* rowAcc = &rowActive[v];
-
-                    assert(rowAcc->remaining > 0);
-                    --rowAcc->remaining;
-
-                    if (!rowAcc->remaining)
-                    {
-                        XMVECTOR* pAccSrc = rowAcc->scanline.get();
-                        if (!pAccSrc)
-                            return E_POINTER;
-
-                        switch (dest->format)
-                        {
-                        case DXGI_FORMAT_R10G10B10A2_UNORM:
-                        case DXGI_FORMAT_R10G10B10A2_UINT:
-                            {
-                                // Need to slightly bias results for floating-point error accumulation which can
-                                // be visible with harshly quantized values
-                                static const XMVECTORF32 Bias = { { { 0.f, 0.f, 0.f, 0.1f } } };
-
-                                XMVECTOR* ptr = pAccSrc;
-                                for (size_t i = 0; i < dest->width; ++i, ++ptr)
-                                {
-                                    *ptr = XMVectorAdd(*ptr, Bias);
-                                }
-                            }
-                            break;
-
-                        default:
-                            break;
-                        }
-
-                        // This performs any required clamping
-                        if (!StoreScanlineLinear(pDest + (dest->rowPitch * v), dest->rowPitch, dest->format, pAccSrc, dest->width, filter))
-                            return E_FAIL;
-
-                        // Put row on freelist to reuse it's allocated scanline
-                        rowAcc->next = rowFree;
-                        rowFree = rowAcc;
-                    }
-                }
-
-                yFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(yFrom) + yFrom->sizeInBytes);
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Generate volume mip-map helpers
-    //-------------------------------------------------------------------------------------
-    HRESULT Setup3DMips(
-        _In_reads_(depth) const Image* baseImages,
-        size_t depth,
-        size_t levels,
-        _Out_ ScratchImage& mipChain) noexcept
-    {
-        if (!baseImages || !depth)
-            return E_INVALIDARG;
-
-        assert(levels > 1);
-
-        const size_t width = baseImages[0].width;
-        const size_t height = baseImages[0].height;
-
-        HRESULT hr = mipChain.Initialize3D(baseImages[0].format, width, height, depth, levels);
-        if (FAILED(hr))
-            return hr;
-
-        // Copy base images to top slice
-        for (size_t slice = 0; slice < depth; ++slice)
-        {
-            const Image& src = baseImages[slice];
-
-            const Image *dest = mipChain.GetImage(0, 0, slice);
-            if (!dest)
-            {
-                mipChain.Release();
-                return E_POINTER;
-            }
-
-            assert(src.format == dest->format);
-
-            uint8_t* pDest = dest->pixels;
-            if (!pDest)
-            {
-                mipChain.Release();
-                return E_POINTER;
-            }
-
-            const uint8_t *pSrc = src.pixels;
-            const size_t rowPitch = src.rowPitch;
-            for (size_t h = 0; h < height; ++h)
-            {
-                const size_t msize = std::min<size_t>(dest->rowPitch, rowPitch);
-                memcpy(pDest, pSrc, msize);
-                pSrc += rowPitch;
-                pDest += dest->rowPitch;
-            }
-        }
-
-        return S_OK;
-    }
-
-
-    //--- 3D Point Filter ---
-    HRESULT Generate3DMipsPointFilter(size_t depth, size_t levels, const ScratchImage& mipChain) noexcept
-    {
-        if (!depth || !mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base images are already placed into the mipChain at the top level... (see _Setup3DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        // Allocate temporary space (2 scanlines)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 2);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* row = target + width;
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-        #ifdef _DEBUG
-            memset(row, 0xCD, sizeof(XMVECTOR)*width);
-        #endif
-
-            if (depth > 1)
-            {
-                // 3D point filter
-                const size_t ndepth = depth >> 1;
-
-                const size_t zinc = (depth << 16) / ndepth;
-
-                size_t sz = 0;
-                for (size_t slice = 0; slice < ndepth; ++slice)
-                {
-                    const Image* src = mipChain.GetImage(level - 1, 0, (sz >> 16));
-                    const Image* dest = mipChain.GetImage(level, 0, slice);
-
-                    if (!src || !dest)
-                        return E_POINTER;
-
-                    const uint8_t* pSrc = src->pixels;
-                    uint8_t* pDest = dest->pixels;
-
-                    const size_t rowPitch = src->rowPitch;
-
-                    const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-                    const size_t nheight = (height > 1) ? (height >> 1) : 1;
-
-                    const size_t xinc = (width << 16) / nwidth;
-                    const size_t yinc = (height << 16) / nheight;
-
-                    size_t lasty = size_t(-1);
-
-                    size_t sy = 0;
-                    for (size_t y = 0; y < nheight; ++y)
-                    {
-                        if ((lasty ^ sy) >> 16)
-                        {
-                            if (!LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
-                                return E_FAIL;
-                            lasty = sy;
-                        }
-
-                        size_t sx = 0;
-                        for (size_t x = 0; x < nwidth; ++x)
-                        {
-                            target[x] = row[sx >> 16];
-                            sx += xinc;
-                        }
-
-                        if (!StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
-                            return E_FAIL;
-                        pDest += dest->rowPitch;
-
-                        sy += yinc;
-                    }
-
-                    sz += zinc;
-                }
-            }
-            else
-            {
-                // 2D point filter
-                const Image* src = mipChain.GetImage(level - 1, 0, 0);
-                const Image* dest = mipChain.GetImage(level, 0, 0);
-
-                if (!src || !dest)
-                    return E_POINTER;
-
-                const uint8_t* pSrc = src->pixels;
-                uint8_t* pDest = dest->pixels;
-
-                const size_t rowPitch = src->rowPitch;
-
-                const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-                const size_t nheight = (height > 1) ? (height >> 1) : 1;
-
-                const size_t xinc = (width << 16) / nwidth;
-                const size_t yinc = (height << 16) / nheight;
-
-                size_t lasty = size_t(-1);
-
-                size_t sy = 0;
-                for (size_t y = 0; y < nheight; ++y)
-                {
-                    if ((lasty ^ sy) >> 16)
-                    {
-                        if (!LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
-                            return E_FAIL;
-                        lasty = sy;
-                    }
-
-                    size_t sx = 0;
-                    for (size_t x = 0; x < nwidth; ++x)
-                    {
-                        target[x] = row[sx >> 16];
-                        sx += xinc;
-                    }
-
-                    if (!StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
-                        return E_FAIL;
-                    pDest += dest->rowPitch;
-
-                    sy += yinc;
-                }
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-
-            if (depth > 1)
-                depth >>= 1;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- 3D Box Filter ---
-    HRESULT Generate3DMipsBoxFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        if (!depth || !mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base images are already placed into the mipChain at the top level... (see _Setup3DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        if (!ispow2(width) || !ispow2(height) || !ispow2(depth))
-            return E_FAIL;
-
-        // Allocate temporary space (5 scanlines)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 5);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* urow0 = target + width;
-        XMVECTOR* urow1 = target + width * 2;
-        XMVECTOR* vrow0 = target + width * 3;
-        XMVECTOR* vrow1 = target + width * 4;
-
-        const XMVECTOR* urow2 = urow0 + 1;
-        const XMVECTOR* urow3 = urow1 + 1;
-        const XMVECTOR* vrow2 = vrow0 + 1;
-        const XMVECTOR* vrow3 = vrow1 + 1;
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-            if (height <= 1)
-            {
-                urow1 = urow0;
-                vrow1 = vrow0;
-            }
-
-            if (width <= 1)
-            {
-                urow2 = urow0;
-                urow3 = urow1;
-                vrow2 = vrow0;
-                vrow3 = vrow1;
-            }
-
-            if (depth > 1)
-            {
-                // 3D box filter
-                const size_t ndepth = depth >> 1;
-
-                for (size_t slice = 0; slice < ndepth; ++slice)
-                {
-                    const size_t slicea = std::min<size_t>(slice * 2, depth - 1);
-                    const size_t sliceb = std::min<size_t>(slicea + 1, depth - 1);
-
-                    const Image* srca = mipChain.GetImage(level - 1, 0, slicea);
-                    const Image* srcb = mipChain.GetImage(level - 1, 0, sliceb);
-                    const Image* dest = mipChain.GetImage(level, 0, slice);
-
-                    if (!srca || !srcb || !dest)
-                        return E_POINTER;
-
-                    const uint8_t* pSrc1 = srca->pixels;
-                    const uint8_t* pSrc2 = srcb->pixels;
-                    uint8_t* pDest = dest->pixels;
-
-                    const size_t aRowPitch = srca->rowPitch;
-                    const size_t bRowPitch = srcb->rowPitch;
-
-                    const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-                    const size_t nheight = (height > 1) ? (height >> 1) : 1;
-
-                    for (size_t y = 0; y < nheight; ++y)
-                    {
-                        if (!LoadScanlineLinear(urow0, width, pSrc1, aRowPitch, srca->format, filter))
-                            return E_FAIL;
-                        pSrc1 += aRowPitch;
-
-                        if (urow0 != urow1)
-                        {
-                            if (!LoadScanlineLinear(urow1, width, pSrc1, aRowPitch, srca->format, filter))
-                                return E_FAIL;
-                            pSrc1 += aRowPitch;
-                        }
-
-                        if (!LoadScanlineLinear(vrow0, width, pSrc2, bRowPitch, srcb->format, filter))
-                            return E_FAIL;
-                        pSrc2 += bRowPitch;
-
-                        if (vrow0 != vrow1)
-                        {
-                            if (!LoadScanlineLinear(vrow1, width, pSrc2, bRowPitch, srcb->format, filter))
-                                return E_FAIL;
-                            pSrc2 += bRowPitch;
-                        }
-
-                        for (size_t x = 0; x < nwidth; ++x)
-                        {
-                            const size_t x2 = x << 1;
-
-                            AVERAGE8(target[x], urow0[x2], urow1[x2], urow2[x2], urow3[x2],
-                                vrow0[x2], vrow1[x2], vrow2[x2], vrow3[x2])
-                        }
-
-                        if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
-                            return E_FAIL;
-                        pDest += dest->rowPitch;
-                    }
-                }
-            }
-            else
-            {
-                // 2D box filter
-                const Image* src = mipChain.GetImage(level - 1, 0, 0);
-                const Image* dest = mipChain.GetImage(level, 0, 0);
-
-                if (!src || !dest)
-                    return E_POINTER;
-
-                const uint8_t* pSrc = src->pixels;
-                uint8_t* pDest = dest->pixels;
-
-                const size_t rowPitch = src->rowPitch;
-
-                const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-                const size_t nheight = (height > 1) ? (height >> 1) : 1;
-
-                for (size_t y = 0; y < nheight; ++y)
-                {
-                    if (!LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter))
-                        return E_FAIL;
-                    pSrc += rowPitch;
-
-                    if (urow0 != urow1)
-                    {
-                        if (!LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter))
-                            return E_FAIL;
-                        pSrc += rowPitch;
-                    }
-
-                    for (size_t x = 0; x < nwidth; ++x)
-                    {
-                        const size_t x2 = x << 1;
-
-                        AVERAGE4(target[x], urow0[x2], urow1[x2], urow2[x2], urow3[x2])
-                    }
-
-                    if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
-                        return E_FAIL;
-                    pDest += dest->rowPitch;
-                }
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-
-            if (depth > 1)
-                depth >>= 1;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- 3D Linear Filter ---
-    HRESULT Generate3DMipsLinearFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        if (!depth || !mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base images are already placed into the mipChain at the top level... (see _Setup3DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        // Allocate temporary space (5 scanlines, plus X/Y/Z filters)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 5);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        std::unique_ptr<LinearFilter[]> lf(new (std::nothrow) LinearFilter[width + height + depth]);
-        if (!lf)
-            return E_OUTOFMEMORY;
-
-        LinearFilter* lfX = lf.get();
-        LinearFilter* lfY = lf.get() + width;
-        LinearFilter* lfZ = lf.get() + width + height;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* urow0 = target + width;
-        XMVECTOR* urow1 = target + width * 2;
-        XMVECTOR* vrow0 = target + width * 3;
-        XMVECTOR* vrow1 = target + width * 4;
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-            const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-            CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
-
-            const size_t nheight = (height > 1) ? (height >> 1) : 1;
-            CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
-
-        #ifdef _DEBUG
-            memset(urow0, 0xCD, sizeof(XMVECTOR)*width);
-            memset(urow1, 0xDD, sizeof(XMVECTOR)*width);
-            memset(vrow0, 0xED, sizeof(XMVECTOR)*width);
-            memset(vrow1, 0xFD, sizeof(XMVECTOR)*width);
-        #endif
-
-            if (depth > 1)
-            {
-                // 3D linear filter
-                const size_t ndepth = depth >> 1;
-                CreateLinearFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, lfZ);
-
-                for (size_t slice = 0; slice < ndepth; ++slice)
-                {
-                    auto const& toZ = lfZ[slice];
-
-                    const Image* srca = mipChain.GetImage(level - 1, 0, toZ.u0);
-                    const Image* srcb = mipChain.GetImage(level - 1, 0, toZ.u1);
-                    if (!srca || !srcb)
-                        return E_POINTER;
-
-                    size_t u0 = size_t(-1);
-                    size_t u1 = size_t(-1);
-
-                    const Image* dest = mipChain.GetImage(level, 0, slice);
-                    if (!dest)
-                        return E_POINTER;
-
-                    uint8_t* pDest = dest->pixels;
-
-                    for (size_t y = 0; y < nheight; ++y)
-                    {
-                        auto const& toY = lfY[y];
-
-                        if (toY.u0 != u0)
-                        {
-                            if (toY.u0 != u1)
-                            {
-                                u0 = toY.u0;
-
-                                if (!LoadScanlineLinear(urow0, width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter)
-                                    || !LoadScanlineLinear(vrow0, width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter))
-                                    return E_FAIL;
-                            }
-                            else
-                            {
-                                u0 = u1;
-                                u1 = size_t(-1);
-
-                                std::swap(urow0, urow1);
-                                std::swap(vrow0, vrow1);
-                            }
-                        }
-
-                        if (toY.u1 != u1)
-                        {
-                            u1 = toY.u1;
-
-                            if (!LoadScanlineLinear(urow1, width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter)
-                                || !LoadScanlineLinear(vrow1, width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter))
-                                return E_FAIL;
-                        }
-
-                        for (size_t x = 0; x < nwidth; ++x)
-                        {
-                            auto const& toX = lfX[x];
-
-                            TRILINEAR_INTERPOLATE(target[x], toX, toY, toZ, urow0, urow1, vrow0, vrow1)
-                        }
-
-                        if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
-                            return E_FAIL;
-                        pDest += dest->rowPitch;
-                    }
-                }
-            }
-            else
-            {
-                // 2D linear filter
-                const Image* src = mipChain.GetImage(level - 1, 0, 0);
-                const Image* dest = mipChain.GetImage(level, 0, 0);
-
-                if (!src || !dest)
-                    return E_POINTER;
-
-                const uint8_t* pSrc = src->pixels;
-                uint8_t* pDest = dest->pixels;
-
-                const size_t rowPitch = src->rowPitch;
-
-                size_t u0 = size_t(-1);
-                size_t u1 = size_t(-1);
-
-                for (size_t y = 0; y < nheight; ++y)
-                {
-                    auto const& toY = lfY[y];
-
-                    if (toY.u0 != u0)
-                    {
-                        if (toY.u0 != u1)
-                        {
-                            u0 = toY.u0;
-
-                            if (!LoadScanlineLinear(urow0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
-                                return E_FAIL;
-                        }
-                        else
-                        {
-                            u0 = u1;
-                            u1 = size_t(-1);
-
-                            std::swap(urow0, urow1);
-                        }
-                    }
-
-                    if (toY.u1 != u1)
-                    {
-                        u1 = toY.u1;
-
-                        if (!LoadScanlineLinear(urow1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
-                            return E_FAIL;
-                    }
-
-                    for (size_t x = 0; x < nwidth; ++x)
-                    {
-                        auto const& toX = lfX[x];
-
-                        BILINEAR_INTERPOLATE(target[x], toX, toY, urow0, urow1)
-                    }
-
-                    if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
-                        return E_FAIL;
-                    pDest += dest->rowPitch;
-                }
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-
-            if (depth > 1)
-                depth >>= 1;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- 3D Cubic Filter ---
-    HRESULT Generate3DMipsCubicFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        if (!depth || !mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base images are already placed into the mipChain at the top level... (see _Setup3DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        // Allocate temporary space (17 scanlines, plus X/Y/Z filters)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 17);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        std::unique_ptr<CubicFilter[]> cf(new (std::nothrow) CubicFilter[width + height + depth]);
-        if (!cf)
-            return E_OUTOFMEMORY;
-
-        CubicFilter* cfX = cf.get();
-        CubicFilter* cfY = cf.get() + width;
-        CubicFilter* cfZ = cf.get() + width + height;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* urow[4];
-        XMVECTOR* vrow[4];
-        XMVECTOR* srow[4];
-        XMVECTOR* trow[4];
-
-        XMVECTOR *ptr = scanline.get() + width;
-        for (size_t j = 0; j < 4; ++j)
-        {
-            urow[j] = ptr;  ptr += width;
-            vrow[j] = ptr;  ptr += width;
-            srow[j] = ptr;  ptr += width;
-            trow[j] = ptr;  ptr += width;
-        }
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-            const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-            CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
-
-            const size_t nheight = (height > 1) ? (height >> 1) : 1;
-            CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
-
-        #ifdef _DEBUG
-            for (size_t j = 0; j < 4; ++j)
-            {
-                memset(urow[j], 0xCD, sizeof(XMVECTOR)*width);
-                memset(vrow[j], 0xDD, sizeof(XMVECTOR)*width);
-                memset(srow[j], 0xED, sizeof(XMVECTOR)*width);
-                memset(trow[j], 0xFD, sizeof(XMVECTOR)*width);
-            }
-        #endif
-
-            if (depth > 1)
-            {
-                // 3D cubic filter
-                const size_t ndepth = depth >> 1;
-                CreateCubicFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, (filter & TEX_FILTER_MIRROR_W) != 0, cfZ);
-
-                for (size_t slice = 0; slice < ndepth; ++slice)
-                {
-                    auto const& toZ = cfZ[slice];
-
-                    const Image* srca = mipChain.GetImage(level - 1, 0, toZ.u0);
-                    const Image* srcb = mipChain.GetImage(level - 1, 0, toZ.u1);
-                    const Image* srcc = mipChain.GetImage(level - 1, 0, toZ.u2);
-                    const Image* srcd = mipChain.GetImage(level - 1, 0, toZ.u3);
-                    if (!srca || !srcb || !srcc || !srcd)
-                        return E_POINTER;
-
-                    size_t u0 = size_t(-1);
-                    size_t u1 = size_t(-1);
-                    size_t u2 = size_t(-1);
-                    size_t u3 = size_t(-1);
-
-                    const Image* dest = mipChain.GetImage(level, 0, slice);
-                    if (!dest)
-                        return E_POINTER;
-
-                    uint8_t* pDest = dest->pixels;
-
-                    for (size_t y = 0; y < nheight; ++y)
-                    {
-                        auto const& toY = cfY[y];
-
-                        // Scanline 1
-                        if (toY.u0 != u0)
-                        {
-                            if (toY.u0 != u1 && toY.u0 != u2 && toY.u0 != u3)
-                            {
-                                u0 = toY.u0;
-
-                                if (!LoadScanlineLinear(urow[0], width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter)
-                                    || !LoadScanlineLinear(urow[1], width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter)
-                                    || !LoadScanlineLinear(urow[2], width, srcc->pixels + (srcc->rowPitch * u0), srcc->rowPitch, srcc->format, filter)
-                                    || !LoadScanlineLinear(urow[3], width, srcd->pixels + (srcd->rowPitch * u0), srcd->rowPitch, srcd->format, filter))
-                                    return E_FAIL;
-                            }
-                            else if (toY.u0 == u1)
-                            {
-                                u0 = u1;
-                                u1 = size_t(-1);
-
-                                std::swap(urow[0], vrow[0]);
-                                std::swap(urow[1], vrow[1]);
-                                std::swap(urow[2], vrow[2]);
-                                std::swap(urow[3], vrow[3]);
-                            }
-                            else if (toY.u0 == u2)
-                            {
-                                u0 = u2;
-                                u2 = size_t(-1);
-
-                                std::swap(urow[0], srow[0]);
-                                std::swap(urow[1], srow[1]);
-                                std::swap(urow[2], srow[2]);
-                                std::swap(urow[3], srow[3]);
-                            }
-                            else if (toY.u0 == u3)
-                            {
-                                u0 = u3;
-                                u3 = size_t(-1);
-
-                                std::swap(urow[0], trow[0]);
-                                std::swap(urow[1], trow[1]);
-                                std::swap(urow[2], trow[2]);
-                                std::swap(urow[3], trow[3]);
-                            }
-                        }
-
-                        // Scanline 2
-                        if (toY.u1 != u1)
-                        {
-                            if (toY.u1 != u2 && toY.u1 != u3)
-                            {
-                                u1 = toY.u1;
-
-                                if (!LoadScanlineLinear(vrow[0], width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter)
-                                    || !LoadScanlineLinear(vrow[1], width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter)
-                                    || !LoadScanlineLinear(vrow[2], width, srcc->pixels + (srcc->rowPitch * u1), srcc->rowPitch, srcc->format, filter)
-                                    || !LoadScanlineLinear(vrow[3], width, srcd->pixels + (srcd->rowPitch * u1), srcd->rowPitch, srcd->format, filter))
-                                    return E_FAIL;
-                            }
-                            else if (toY.u1 == u2)
-                            {
-                                u1 = u2;
-                                u2 = size_t(-1);
-
-                                std::swap(vrow[0], srow[0]);
-                                std::swap(vrow[1], srow[1]);
-                                std::swap(vrow[2], srow[2]);
-                                std::swap(vrow[3], srow[3]);
-                            }
-                            else if (toY.u1 == u3)
-                            {
-                                u1 = u3;
-                                u3 = size_t(-1);
-
-                                std::swap(vrow[0], trow[0]);
-                                std::swap(vrow[1], trow[1]);
-                                std::swap(vrow[2], trow[2]);
-                                std::swap(vrow[3], trow[3]);
-                            }
-                        }
-
-                        // Scanline 3
-                        if (toY.u2 != u2)
-                        {
-                            if (toY.u2 != u3)
-                            {
-                                u2 = toY.u2;
-
-                                if (!LoadScanlineLinear(srow[0], width, srca->pixels + (srca->rowPitch * u2), srca->rowPitch, srca->format, filter)
-                                    || !LoadScanlineLinear(srow[1], width, srcb->pixels + (srcb->rowPitch * u2), srcb->rowPitch, srcb->format, filter)
-                                    || !LoadScanlineLinear(srow[2], width, srcc->pixels + (srcc->rowPitch * u2), srcc->rowPitch, srcc->format, filter)
-                                    || !LoadScanlineLinear(srow[3], width, srcd->pixels + (srcd->rowPitch * u2), srcd->rowPitch, srcd->format, filter))
-                                    return E_FAIL;
-                            }
-                            else
-                            {
-                                u2 = u3;
-                                u3 = size_t(-1);
-
-                                std::swap(srow[0], trow[0]);
-                                std::swap(srow[1], trow[1]);
-                                std::swap(srow[2], trow[2]);
-                                std::swap(srow[3], trow[3]);
-                            }
-                        }
-
-                        // Scanline 4
-                        if (toY.u3 != u3)
-                        {
-                            u3 = toY.u3;
-
-                            if (!LoadScanlineLinear(trow[0], width, srca->pixels + (srca->rowPitch * u3), srca->rowPitch, srca->format, filter)
-                                || !LoadScanlineLinear(trow[1], width, srcb->pixels + (srcb->rowPitch * u3), srcb->rowPitch, srcb->format, filter)
-                                || !LoadScanlineLinear(trow[2], width, srcc->pixels + (srcc->rowPitch * u3), srcc->rowPitch, srcc->format, filter)
-                                || !LoadScanlineLinear(trow[3], width, srcd->pixels + (srcd->rowPitch * u3), srcd->rowPitch, srcd->format, filter))
-                                return E_FAIL;
-                        }
-
-                        for (size_t x = 0; x < nwidth; ++x)
-                        {
-                            auto const& toX = cfX[x];
-
-                            XMVECTOR D[4];
-
-                            for (size_t j = 0; j < 4; ++j)
-                            {
-                                XMVECTOR C0, C1, C2, C3;
-                                CUBIC_INTERPOLATE(C0, toX.x, urow[j][toX.u0], urow[j][toX.u1], urow[j][toX.u2], urow[j][toX.u3]);
-                                CUBIC_INTERPOLATE(C1, toX.x, vrow[j][toX.u0], vrow[j][toX.u1], vrow[j][toX.u2], vrow[j][toX.u3]);
-                                CUBIC_INTERPOLATE(C2, toX.x, srow[j][toX.u0], srow[j][toX.u1], srow[j][toX.u2], srow[j][toX.u3]);
-                                CUBIC_INTERPOLATE(C3, toX.x, trow[j][toX.u0], trow[j][toX.u1], trow[j][toX.u2], trow[j][toX.u3]);
-
-                                CUBIC_INTERPOLATE(D[j], toY.x, C0, C1, C2, C3);
-                            }
-
-                            CUBIC_INTERPOLATE(target[x], toZ.x, D[0], D[1], D[2], D[3]);
-                        }
-
-                        if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
-                            return E_FAIL;
-                        pDest += dest->rowPitch;
-                    }
-                }
-            }
-            else
-            {
-                // 2D cubic filter
-                const Image* src = mipChain.GetImage(level - 1, 0, 0);
-                const Image* dest = mipChain.GetImage(level, 0, 0);
-
-                if (!src || !dest)
-                    return E_POINTER;
-
-                const uint8_t* pSrc = src->pixels;
-                uint8_t* pDest = dest->pixels;
-
-                const size_t rowPitch = src->rowPitch;
-
-                size_t u0 = size_t(-1);
-                size_t u1 = size_t(-1);
-                size_t u2 = size_t(-1);
-                size_t u3 = size_t(-1);
-
-                for (size_t y = 0; y < nheight; ++y)
-                {
-                    auto const& toY = cfY[y];
-
-                    // Scanline 1
-                    if (toY.u0 != u0)
-                    {
-                        if (toY.u0 != u1 && toY.u0 != u2 && toY.u0 != u3)
-                        {
-                            u0 = toY.u0;
-
-                            if (!LoadScanlineLinear(urow[0], width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
-                                return E_FAIL;
-                        }
-                        else if (toY.u0 == u1)
-                        {
-                            u0 = u1;
-                            u1 = size_t(-1);
-
-                            std::swap(urow[0], vrow[0]);
-                        }
-                        else if (toY.u0 == u2)
-                        {
-                            u0 = u2;
-                            u2 = size_t(-1);
-
-                            std::swap(urow[0], srow[0]);
-                        }
-                        else if (toY.u0 == u3)
-                        {
-                            u0 = u3;
-                            u3 = size_t(-1);
-
-                            std::swap(urow[0], trow[0]);
-                        }
-                    }
-
-                    // Scanline 2
-                    if (toY.u1 != u1)
-                    {
-                        if (toY.u1 != u2 && toY.u1 != u3)
-                        {
-                            u1 = toY.u1;
-
-                            if (!LoadScanlineLinear(vrow[0], width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
-                                return E_FAIL;
-                        }
-                        else if (toY.u1 == u2)
-                        {
-                            u1 = u2;
-                            u2 = size_t(-1);
-
-                            std::swap(vrow[0], srow[0]);
-                        }
-                        else if (toY.u1 == u3)
-                        {
-                            u1 = u3;
-                            u3 = size_t(-1);
-
-                            std::swap(vrow[0], trow[0]);
-                        }
-                    }
-
-                    // Scanline 3
-                    if (toY.u2 != u2)
-                    {
-                        if (toY.u2 != u3)
-                        {
-                            u2 = toY.u2;
-
-                            if (!LoadScanlineLinear(srow[0], width, pSrc + (rowPitch * u2), rowPitch, src->format, filter))
-                                return E_FAIL;
-                        }
-                        else
-                        {
-                            u2 = u3;
-                            u3 = size_t(-1);
-
-                            std::swap(srow[0], trow[0]);
-                        }
-                    }
-
-                    // Scanline 4
-                    if (toY.u3 != u3)
-                    {
-                        u3 = toY.u3;
-
-                        if (!LoadScanlineLinear(trow[0], width, pSrc + (rowPitch * u3), rowPitch, src->format, filter))
-                            return E_FAIL;
-                    }
-
-                    for (size_t x = 0; x < nwidth; ++x)
-                    {
-                        auto const& toX = cfX[x];
-
-                        XMVECTOR C0, C1, C2, C3;
-                        CUBIC_INTERPOLATE(C0, toX.x, urow[0][toX.u0], urow[0][toX.u1], urow[0][toX.u2], urow[0][toX.u3]);
-                        CUBIC_INTERPOLATE(C1, toX.x, vrow[0][toX.u0], vrow[0][toX.u1], vrow[0][toX.u2], vrow[0][toX.u3]);
-                        CUBIC_INTERPOLATE(C2, toX.x, srow[0][toX.u0], srow[0][toX.u1], srow[0][toX.u2], srow[0][toX.u3]);
-                        CUBIC_INTERPOLATE(C3, toX.x, trow[0][toX.u0], trow[0][toX.u1], trow[0][toX.u2], trow[0][toX.u3]);
-
-                        CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3);
-                    }
-
-                    if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
-                        return E_FAIL;
-                    pDest += dest->rowPitch;
-                }
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-
-            if (depth > 1)
-                depth >>= 1;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- 3D Triangle Filter ---
-    HRESULT Generate3DMipsTriangleFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        if (!depth || !mipChain.GetImages())
-            return E_INVALIDARG;
-
-        // This assumes that the base images are already placed into the mipChain at the top level... (see _Setup3DMips)
-
-        assert(levels > 1);
-
-        size_t width = mipChain.GetMetadata().width;
-        size_t height = mipChain.GetMetadata().height;
-
-        // Allocate initial temporary space (1 scanline, accumulation rows, plus X/Y/Z filters)
-        auto scanline = make_AlignedArrayXMVECTOR(width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        std::unique_ptr<TriangleRow[]> sliceActive(new (std::nothrow) TriangleRow[depth]);
-        if (!sliceActive)
-            return E_OUTOFMEMORY;
-
-        TriangleRow * sliceFree = nullptr;
-
-        std::unique_ptr<Filter> tfX, tfY, tfZ;
-
-        XMVECTOR* row = scanline.get();
-
-        // Resize base image to each target mip level
-        for (size_t level = 1; level < levels; ++level)
-        {
-            const size_t nwidth = (width > 1) ? (width >> 1) : 1;
-            HRESULT hr = CreateTriangleFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
-            if (FAILED(hr))
-                return hr;
-
-            const size_t nheight = (height > 1) ? (height >> 1) : 1;
-            hr = CreateTriangleFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
-            if (FAILED(hr))
-                return hr;
-
-            const size_t ndepth = (depth > 1) ? (depth >> 1) : 1;
-            hr = CreateTriangleFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, tfZ);
-            if (FAILED(hr))
-                return hr;
-
-        #ifdef _DEBUG
-            memset(row, 0xCD, sizeof(XMVECTOR)*width);
-        #endif
-
-            auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes);
-            auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes);
-            auto zFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfZ.get()) + tfZ->sizeInBytes);
-
-            // Count times slices get written (and clear out any leftover accumulation slices from last miplevel)
-            for (FilterFrom* zFrom = tfZ->from; zFrom < zFromEnd; )
-            {
-                for (size_t j = 0; j < zFrom->count; ++j)
-                {
-                    const size_t w = zFrom->to[j].u;
-                    assert(w < ndepth);
-                    TriangleRow* sliceAcc = &sliceActive[w];
-
-                    ++sliceAcc->remaining;
-
-                    if (sliceAcc->scanline)
-                    {
-                        memset(sliceAcc->scanline.get(), 0, sizeof(XMVECTOR) * nwidth * nheight);
-                    }
-                }
-
-                zFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(zFrom) + zFrom->sizeInBytes);
-            }
-
-            // Filter image
-            size_t z = 0;
-            for (FilterFrom* zFrom = tfZ->from; zFrom < zFromEnd; ++z)
-            {
-                // Create accumulation slices as needed
-                for (size_t j = 0; j < zFrom->count; ++j)
-                {
-                    const size_t w = zFrom->to[j].u;
-                    assert(w < ndepth);
-                    TriangleRow* sliceAcc = &sliceActive[w];
-
-                    if (!sliceAcc->scanline)
-                    {
-                        if (sliceFree)
-                        {
-                            // Steal and reuse scanline from 'free slice' list
-                            // (it will always be at least as large as nwidth*nheight due to loop decending order)
-                            assert(sliceFree->scanline != nullptr);
-                            sliceAcc->scanline.reset(sliceFree->scanline.release());
-                            sliceFree = sliceFree->next;
-                        }
-                        else
-                        {
-                            auto nscanline = make_AlignedArrayXMVECTOR(uint64_t(nwidth) * uint64_t(nheight));
-                            if (!nscanline)
-                                return E_OUTOFMEMORY;
-                            sliceAcc->scanline.swap(nscanline);
-                        }
-
-                        memset(sliceAcc->scanline.get(), 0, sizeof(XMVECTOR) * nwidth * nheight);
-                    }
-                }
-
-                assert(z < depth);
-                const Image* src = mipChain.GetImage(level - 1, 0, z);
-                if (!src)
-                    return E_POINTER;
-
-                const uint8_t* pSrc = src->pixels;
-                const size_t rowPitch = src->rowPitch;
-                const uint8_t* pEndSrc = pSrc + rowPitch * height;
-
-                for (FilterFrom* yFrom = tfY->from; yFrom < yFromEnd; )
-                {
-                    // Load source scanline
-                    if ((pSrc + rowPitch) > pEndSrc)
-                        return E_FAIL;
-
-                    if (!LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter))
-                        return E_FAIL;
-
-                    pSrc += rowPitch;
-
-                    // Process row
-                    size_t x = 0;
-                    for (FilterFrom* xFrom = tfX->from; xFrom < xFromEnd; ++x)
-                    {
-                        for (size_t j = 0; j < zFrom->count; ++j)
-                        {
-                            const size_t w = zFrom->to[j].u;
-                            assert(w < ndepth);
-                            const float zweight = zFrom->to[j].weight;
-
-                            XMVECTOR* accSlice = sliceActive[w].scanline.get();
-                            if (!accSlice)
-                                return E_POINTER;
-
-                            for (size_t k = 0; k < yFrom->count; ++k)
-                            {
-                                size_t v = yFrom->to[k].u;
-                                assert(v < nheight);
-                                const float yweight = yFrom->to[k].weight;
-
-                                XMVECTOR * accPtr = accSlice + v * nwidth;
-
-                                for (size_t l = 0; l < xFrom->count; ++l)
-                                {
-                                    size_t u = xFrom->to[l].u;
-                                    assert(u < nwidth);
-
-                                    const XMVECTOR weight = XMVectorReplicate(zweight * yweight * xFrom->to[l].weight);
-
-                                    assert(x < width);
-                                    accPtr[u] = XMVectorMultiplyAdd(row[x], weight, accPtr[u]);
-                                }
-                            }
-                        }
-
-                        xFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(xFrom) + xFrom->sizeInBytes);
-                    }
-
-                    yFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(yFrom) + yFrom->sizeInBytes);
-                }
-
-                // Write completed accumulation slices
-                for (size_t j = 0; j < zFrom->count; ++j)
-                {
-                    const size_t w = zFrom->to[j].u;
-                    assert(w < ndepth);
-                    TriangleRow* sliceAcc = &sliceActive[w];
-
-                    assert(sliceAcc->remaining > 0);
-                    --sliceAcc->remaining;
-
-                    if (!sliceAcc->remaining)
-                    {
-                        const Image* dest = mipChain.GetImage(level, 0, w);
-                        XMVECTOR* pAccSrc = sliceAcc->scanline.get();
-                        if (!dest || !pAccSrc)
-                            return E_POINTER;
-
-                        uint8_t* pDest = dest->pixels;
-
-                        for (size_t h = 0; h < nheight; ++h)
-                        {
-                            switch (dest->format)
-                            {
-                            case DXGI_FORMAT_R10G10B10A2_UNORM:
-                            case DXGI_FORMAT_R10G10B10A2_UINT:
-                                {
-                                    // Need to slightly bias results for floating-point error accumulation which can
-                                    // be visible with harshly quantized values
-                                    static const XMVECTORF32 Bias = { { { 0.f, 0.f, 0.f, 0.1f } } };
-
-                                    XMVECTOR* ptr = pAccSrc;
-                                    for (size_t i = 0; i < dest->width; ++i, ++ptr)
-                                    {
-                                        *ptr = XMVectorAdd(*ptr, Bias);
-                                    }
-                                }
-                                break;
-
-                            default:
-                                break;
-                            }
-
-                            // This performs any required clamping
-                            if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, pAccSrc, dest->width, filter))
-                                return E_FAIL;
-
-                            pDest += dest->rowPitch;
-                            pAccSrc += nwidth;
-                        }
-
-                        // Put slice on freelist to reuse it's allocated scanline
-                        sliceAcc->next = sliceFree;
-                        sliceFree = sliceAcc;
-                    }
-                }
-
-                zFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(zFrom) + zFrom->sizeInBytes);
-            }
-
-            if (height > 1)
-                height >>= 1;
-
-            if (width > 1)
-                width >>= 1;
-
-            if (depth > 1)
-                depth >>= 1;
-        }
-
-        return S_OK;
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Generate mipmap chain
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::GenerateMipMaps(
-    const Image& baseImage,
-    TEX_FILTER_FLAGS filter,
-    size_t levels,
-    ScratchImage& mipChain,
-    bool allow1D) noexcept
-{
-    if (!IsValid(baseImage.format))
-        return E_INVALIDARG;
-
-    if (!baseImage.pixels)
-        return E_POINTER;
-
-    if (!CalculateMipLevels(baseImage.width, baseImage.height, levels))
-        return E_INVALIDARG;
-
-    if (levels <= 1)
-        return E_INVALIDARG;
-
-    if (IsCompressed(baseImage.format) || IsTypeless(baseImage.format) || IsPlanar(baseImage.format) || IsPalettized(baseImage.format))
-    {
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    HRESULT hr = E_UNEXPECTED;
-
-    static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK");
-
-#ifdef _WIN32
-    bool usewic = UseWICFiltering(baseImage.format, filter);
-
-    WICPixelFormatGUID pfGUID = {};
-    const bool wicpf = (usewic) ? DXGIToWIC(baseImage.format, pfGUID, true) : false;
-
-    if (usewic && !wicpf)
-    {
-        // Check to see if the source and/or result size is too big for WIC
-        const uint64_t expandedSize = uint64_t(std::max<size_t>(1, baseImage.width >> 1)) * uint64_t(std::max<size_t>(1, baseImage.height >> 1)) * sizeof(float) * 4;
-        const uint64_t expandedSize2 = uint64_t(baseImage.width) * uint64_t(baseImage.height) * sizeof(float) * 4;
-        if (expandedSize > UINT32_MAX || expandedSize2 > UINT32_MAX)
-        {
-            if (filter & TEX_FILTER_FORCE_WIC)
-                return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-            usewic = false;
-        }
-    }
-
-    if (usewic)
-    {
-        //--- Use WIC filtering to generate mipmaps -----------------------------------
-        switch (filter & TEX_FILTER_MODE_MASK)
-        {
-        case 0:
-        case TEX_FILTER_POINT:
-        case TEX_FILTER_FANT: // Equivalent to Box filter
-        case TEX_FILTER_LINEAR:
-        case TEX_FILTER_CUBIC:
-            {
-                static_assert(TEX_FILTER_FANT == TEX_FILTER_BOX, "TEX_FILTER_ flag alias mismatch");
-
-                if (wicpf)
-                {
-                    // Case 1: Base image format is supported by Windows Imaging Component
-                    hr = (baseImage.height > 1 || !allow1D)
-                        ? mipChain.Initialize2D(baseImage.format, baseImage.width, baseImage.height, 1, levels)
-                        : mipChain.Initialize1D(baseImage.format, baseImage.width, 1, levels);
-                    if (FAILED(hr))
-                        return hr;
-
-                    return GenerateMipMapsUsingWIC(baseImage, filter, levels, pfGUID, mipChain, 0);
-                }
-                else
-                {
-                    // Case 2: Base image format is not supported by WIC, so we have to convert, generate, and convert back
-                    assert(baseImage.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
-                    ScratchImage temp;
-                    hr = ConvertToR32G32B32A32(baseImage, temp);
-                    if (FAILED(hr))
-                        return hr;
-
-                    const Image *timg = temp.GetImage(0, 0, 0);
-                    if (!timg)
-                        return E_POINTER;
-
-                    ScratchImage tMipChain;
-                    hr = (baseImage.height > 1 || !allow1D)
-                        ? tMipChain.Initialize2D(DXGI_FORMAT_R32G32B32A32_FLOAT, baseImage.width, baseImage.height, 1, levels)
-                        : tMipChain.Initialize1D(DXGI_FORMAT_R32G32B32A32_FLOAT, baseImage.width, 1, levels);
-                    if (FAILED(hr))
-                        return hr;
-
-                    hr = GenerateMipMapsUsingWIC(*timg, filter, levels, GUID_WICPixelFormat128bppRGBAFloat, tMipChain, 0);
-                    if (FAILED(hr))
-                        return hr;
-
-                    temp.Release();
-
-                    return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), baseImage.format, mipChain);
-                }
-            }
-
-        default:
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-    }
-    else
-    #endif // WIN32
-    {
-        //--- Use custom filters to generate mipmaps ----------------------------------
-        TexMetadata mdata = {};
-        mdata.width = baseImage.width;
-        if (baseImage.height > 1 || !allow1D)
-        {
-            mdata.height = baseImage.height;
-            mdata.dimension = TEX_DIMENSION_TEXTURE2D;
-        }
-        else
-        {
-            mdata.height = 1;
-            mdata.dimension = TEX_DIMENSION_TEXTURE1D;
-        }
-        mdata.depth = mdata.arraySize = 1;
-        mdata.mipLevels = levels;
-        mdata.format = baseImage.format;
-
-        unsigned long filter_select = (filter & TEX_FILTER_MODE_MASK);
-        if (!filter_select)
-        {
-            // Default filter choice
-            filter_select = (ispow2(baseImage.width) && ispow2(baseImage.height)) ? TEX_FILTER_BOX : TEX_FILTER_LINEAR;
-        }
-
-        switch (filter_select)
-        {
-        case TEX_FILTER_BOX:
-            hr = Setup2DMips(&baseImage, 1, mdata, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            hr = Generate2DMipsBoxFilter(levels, filter, mipChain, 0);
-            if (FAILED(hr))
-                mipChain.Release();
-            return hr;
-
-        case TEX_FILTER_POINT:
-            hr = Setup2DMips(&baseImage, 1, mdata, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            hr = Generate2DMipsPointFilter(levels, mipChain, 0);
-            if (FAILED(hr))
-                mipChain.Release();
-            return hr;
-
-        case TEX_FILTER_LINEAR:
-            hr = Setup2DMips(&baseImage, 1, mdata, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            hr = Generate2DMipsLinearFilter(levels, filter, mipChain, 0);
-            if (FAILED(hr))
-                mipChain.Release();
-            return hr;
-
-        case TEX_FILTER_CUBIC:
-            hr = Setup2DMips(&baseImage, 1, mdata, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            hr = Generate2DMipsCubicFilter(levels, filter, mipChain, 0);
-            if (FAILED(hr))
-                mipChain.Release();
-            return hr;
-
-        case TEX_FILTER_TRIANGLE:
-            hr = Setup2DMips(&baseImage, 1, mdata, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            hr = Generate2DMipsTriangleFilter(levels, filter, mipChain, 0);
-            if (FAILED(hr))
-                mipChain.Release();
-            return hr;
-
-        default:
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-    }
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::GenerateMipMaps(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    TEX_FILTER_FLAGS filter,
-    size_t levels,
-    ScratchImage& mipChain)
-{
-    if (!srcImages || !nimages || !IsValid(metadata.format))
-        return E_INVALIDARG;
-
-    if (metadata.IsVolumemap()
-        || IsCompressed(metadata.format) || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (!CalculateMipLevels(metadata.width, metadata.height, levels))
-        return E_INVALIDARG;
-
-    if (levels <= 1)
-        return E_INVALIDARG;
-
-    std::vector<Image> baseImages;
-    baseImages.reserve(metadata.arraySize);
-    for (size_t item = 0; item < metadata.arraySize; ++item)
-    {
-        const size_t index = metadata.ComputeIndex(0, item, 0);
-        if (index >= nimages)
-            return E_FAIL;
-
-        const Image& src = srcImages[index];
-        if (!src.pixels)
-            return E_POINTER;
-
-        if (src.format != metadata.format || src.width != metadata.width || src.height != metadata.height)
-        {
-            // All base images must be the same format, width, and height
-            return E_FAIL;
-        }
-
-        baseImages.push_back(src);
-    }
-
-    assert(baseImages.size() == metadata.arraySize);
-
-    HRESULT hr = E_UNEXPECTED;
-
-    if (baseImages.empty())
-        return hr;
-
-    static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK");
-
-#ifdef _WIN32
-    bool usewic = !metadata.IsPMAlpha() && UseWICFiltering(metadata.format, filter);
-
-    WICPixelFormatGUID pfGUID = {};
-    const bool wicpf = (usewic) ? DXGIToWIC(metadata.format, pfGUID, true) : false;
-
-    if (usewic && !wicpf)
-    {
-        // Check to see if the source and/or result size is too big for WIC
-        const uint64_t expandedSize = uint64_t(std::max<size_t>(1, metadata.width >> 1)) * uint64_t(std::max<size_t>(1, metadata.height >> 1)) * sizeof(float) * 4;
-        const uint64_t expandedSize2 = uint64_t(metadata.width) * uint64_t(metadata.height) * sizeof(float) * 4;
-        if (expandedSize > UINT32_MAX || expandedSize2 > UINT32_MAX)
-        {
-            if (filter & TEX_FILTER_FORCE_WIC)
-                return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-            usewic = false;
-        }
-    }
-
-    if (usewic)
-    {
-        //--- Use WIC filtering to generate mipmaps -----------------------------------
-        switch (filter & TEX_FILTER_MODE_MASK)
-        {
-        case 0:
-        case TEX_FILTER_POINT:
-        case TEX_FILTER_FANT: // Equivalent to Box filter
-        case TEX_FILTER_LINEAR:
-        case TEX_FILTER_CUBIC:
-            {
-                static_assert(TEX_FILTER_FANT == TEX_FILTER_BOX, "TEX_FILTER_ flag alias mismatch");
-
-                if (wicpf)
-                {
-                    // Case 1: Base image format is supported by Windows Imaging Component
-                    TexMetadata mdata2 = metadata;
-                    mdata2.mipLevels = levels;
-                    hr = mipChain.Initialize(mdata2);
-                    if (FAILED(hr))
-                        return hr;
-
-                    for (size_t item = 0; item < metadata.arraySize; ++item)
-                    {
-                        hr = GenerateMipMapsUsingWIC(baseImages[item], filter, levels, pfGUID, mipChain, item);
-                        if (FAILED(hr))
-                        {
-                            mipChain.Release();
-                            return hr;
-                        }
-                    }
-
-                    return S_OK;
-                }
-                else
-                {
-                    // Case 2: Base image format is not supported by WIC, so we have to convert, generate, and convert back
-                    assert(metadata.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
-
-                    TexMetadata mdata2 = metadata;
-                    mdata2.mipLevels = levels;
-                    mdata2.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
-                    ScratchImage tMipChain;
-                    hr = tMipChain.Initialize(mdata2);
-                    if (FAILED(hr))
-                        return hr;
-
-                    for (size_t item = 0; item < metadata.arraySize; ++item)
-                    {
-                        ScratchImage temp;
-                        hr = ConvertToR32G32B32A32(baseImages[item], temp);
-                        if (FAILED(hr))
-                            return hr;
-
-                        const Image *timg = temp.GetImage(0, 0, 0);
-                        if (!timg)
-                            return E_POINTER;
-
-                        hr = GenerateMipMapsUsingWIC(*timg, filter, levels, GUID_WICPixelFormat128bppRGBAFloat, tMipChain, item);
-                        if (FAILED(hr))
-                            return hr;
-                    }
-
-                    return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), metadata.format, mipChain);
-                }
-            }
-
-        default:
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-    }
-    else
-    #endif // WIN32
-    {
-        //--- Use custom filters to generate mipmaps ----------------------------------
-        TexMetadata mdata2 = metadata;
-        mdata2.mipLevels = levels;
-
-        unsigned long filter_select = (filter & TEX_FILTER_MODE_MASK);
-        if (!filter_select)
-        {
-            // Default filter choice
-            filter_select = (ispow2(metadata.width) && ispow2(metadata.height)) ? TEX_FILTER_BOX : TEX_FILTER_LINEAR;
-        }
-
-        switch (filter_select)
-        {
-        case TEX_FILTER_BOX:
-            hr = Setup2DMips(&baseImages[0], metadata.arraySize, mdata2, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            for (size_t item = 0; item < metadata.arraySize; ++item)
-            {
-                hr = Generate2DMipsBoxFilter(levels, filter, mipChain, item);
-                if (FAILED(hr))
-                    mipChain.Release();
-            }
-            return hr;
-
-        case TEX_FILTER_POINT:
-            hr = Setup2DMips(&baseImages[0], metadata.arraySize, mdata2, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            for (size_t item = 0; item < metadata.arraySize; ++item)
-            {
-                hr = Generate2DMipsPointFilter(levels, mipChain, item);
-                if (FAILED(hr))
-                    mipChain.Release();
-            }
-            return hr;
-
-        case TEX_FILTER_LINEAR:
-            hr = Setup2DMips(&baseImages[0], metadata.arraySize, mdata2, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            for (size_t item = 0; item < metadata.arraySize; ++item)
-            {
-                hr = Generate2DMipsLinearFilter(levels, filter, mipChain, item);
-                if (FAILED(hr))
-                    mipChain.Release();
-            }
-            return hr;
-
-        case TEX_FILTER_CUBIC:
-            hr = Setup2DMips(&baseImages[0], metadata.arraySize, mdata2, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            for (size_t item = 0; item < metadata.arraySize; ++item)
-            {
-                hr = Generate2DMipsCubicFilter(levels, filter, mipChain, item);
-                if (FAILED(hr))
-                    mipChain.Release();
-            }
-            return hr;
-
-        case TEX_FILTER_TRIANGLE:
-            hr = Setup2DMips(&baseImages[0], metadata.arraySize, mdata2, mipChain);
-            if (FAILED(hr))
-                return hr;
-
-            for (size_t item = 0; item < metadata.arraySize; ++item)
-            {
-                hr = Generate2DMipsTriangleFilter(levels, filter, mipChain, item);
-                if (FAILED(hr))
-                    mipChain.Release();
-            }
-            return hr;
-
-        default:
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Generate mipmap chain for volume texture
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::GenerateMipMaps3D(
-    const Image* baseImages,
-    size_t depth,
-    TEX_FILTER_FLAGS filter,
-    size_t levels,
-    ScratchImage& mipChain) noexcept
-{
-    if (!baseImages || !depth)
-        return E_INVALIDARG;
-
-    if (filter & TEX_FILTER_FORCE_WIC)
-        return HRESULT_E_NOT_SUPPORTED;
-
-    const DXGI_FORMAT format = baseImages[0].format;
-    const size_t width = baseImages[0].width;
-    const size_t height = baseImages[0].height;
-
-    if (!CalculateMipLevels3D(width, height, depth, levels))
-        return E_INVALIDARG;
-
-    if (levels <= 1)
-        return E_INVALIDARG;
-
-    for (size_t slice = 0; slice < depth; ++slice)
-    {
-        if (!baseImages[slice].pixels)
-            return E_POINTER;
-
-        if (baseImages[slice].format != format || baseImages[slice].width != width || baseImages[slice].height != height)
-        {
-            // All base images must be the same format, width, and height
-            return E_FAIL;
-        }
-    }
-
-    if (IsCompressed(format) || IsTypeless(format) || IsPlanar(format) || IsPalettized(format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK");
-
-    HRESULT hr = E_UNEXPECTED;
-
-    unsigned long filter_select = (filter & TEX_FILTER_MODE_MASK);
-    if (!filter_select)
-    {
-        // Default filter choice
-        filter_select = (ispow2(width) && ispow2(height) && ispow2(depth)) ? TEX_FILTER_BOX : TEX_FILTER_TRIANGLE;
-    }
-
-    switch (filter_select)
-    {
-    case TEX_FILTER_BOX:
-        hr = Setup3DMips(baseImages, depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsBoxFilter(depth, levels, filter, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    case TEX_FILTER_POINT:
-        hr = Setup3DMips(baseImages, depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsPointFilter(depth, levels, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    case TEX_FILTER_LINEAR:
-        hr = Setup3DMips(baseImages, depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsLinearFilter(depth, levels, filter, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    case TEX_FILTER_CUBIC:
-        hr = Setup3DMips(baseImages, depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsCubicFilter(depth, levels, filter, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    case TEX_FILTER_TRIANGLE:
-        hr = Setup3DMips(baseImages, depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsTriangleFilter(depth, levels, filter, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    default:
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::GenerateMipMaps3D(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    TEX_FILTER_FLAGS filter,
-    size_t levels,
-    ScratchImage& mipChain)
-{
-    if (!srcImages || !nimages || !IsValid(metadata.format))
-        return E_INVALIDARG;
-
-    if (filter & TEX_FILTER_FORCE_WIC)
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (!metadata.IsVolumemap()
-        || IsCompressed(metadata.format) || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (!CalculateMipLevels3D(metadata.width, metadata.height, metadata.depth, levels))
-        return E_INVALIDARG;
-
-    if (levels <= 1)
-        return E_INVALIDARG;
-
-    std::vector<Image> baseImages;
-    baseImages.reserve(metadata.depth);
-    for (size_t slice = 0; slice < metadata.depth; ++slice)
-    {
-        const size_t index = metadata.ComputeIndex(0, 0, slice);
-        if (index >= nimages)
-            return E_FAIL;
-
-        const Image& src = srcImages[index];
-        if (!src.pixels)
-            return E_POINTER;
-
-        if (src.format != metadata.format || src.width != metadata.width || src.height != metadata.height)
-        {
-            // All base images must be the same format, width, and height
-            return E_FAIL;
-        }
-
-        baseImages.push_back(src);
-    }
-
-    assert(baseImages.size() == metadata.depth);
-
-    HRESULT hr = E_UNEXPECTED;
-
-    static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK");
-
-    unsigned long filter_select = (filter & TEX_FILTER_MODE_MASK);
-    if (!filter_select)
-    {
-        // Default filter choice
-        filter_select = (ispow2(metadata.width) && ispow2(metadata.height) && ispow2(metadata.depth)) ? TEX_FILTER_BOX : TEX_FILTER_TRIANGLE;
-    }
-
-    switch (filter_select)
-    {
-    case TEX_FILTER_BOX:
-        hr = Setup3DMips(&baseImages[0], metadata.depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsBoxFilter(metadata.depth, levels, filter, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    case TEX_FILTER_POINT:
-        hr = Setup3DMips(&baseImages[0], metadata.depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsPointFilter(metadata.depth, levels, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    case TEX_FILTER_LINEAR:
-        hr = Setup3DMips(&baseImages[0], metadata.depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsLinearFilter(metadata.depth, levels, filter, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    case TEX_FILTER_CUBIC:
-        hr = Setup3DMips(&baseImages[0], metadata.depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsCubicFilter(metadata.depth, levels, filter, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    case TEX_FILTER_TRIANGLE:
-        hr = Setup3DMips(&baseImages[0], metadata.depth, levels, mipChain);
-        if (FAILED(hr))
-            return hr;
-
-        hr = Generate3DMipsTriangleFilter(metadata.depth, levels, filter, mipChain);
-        if (FAILED(hr))
-            mipChain.Release();
-        return hr;
-
-    default:
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::ScaleMipMapsAlphaForCoverage(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    size_t item,
-    float alphaReference,
-    ScratchImage& mipChain) noexcept
-{
-    if (!srcImages || !nimages || !IsValid(metadata.format) || nimages > metadata.mipLevels || !mipChain.GetImages())
-        return E_INVALIDARG;
-
-    if (metadata.IsVolumemap()
-        || IsCompressed(metadata.format) || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (srcImages[0].format != metadata.format || srcImages[0].width != metadata.width || srcImages[0].height != metadata.height)
-    {
-        // Base image must be the same format, width, and height
-        return E_FAIL;
-    }
-
-    float targetCoverage = 0.0f;
-    HRESULT hr = CalculateAlphaCoverage(srcImages[0], alphaReference, 1.0f, targetCoverage);
-    if (FAILED(hr))
-        return hr;
-
-    // Copy base image
-    {
-        const Image& src = srcImages[0];
-
-        const Image *dest = mipChain.GetImage(0, item, 0);
-        if (!dest)
-            return E_POINTER;
-
-        uint8_t* pDest = dest->pixels;
-        if (!pDest)
-            return E_POINTER;
-
-        const uint8_t *pSrc = src.pixels;
-        const size_t rowPitch = src.rowPitch;
-        for (size_t h = 0; h < metadata.height; ++h)
-        {
-            const size_t msize = std::min<size_t>(dest->rowPitch, rowPitch);
-            memcpy(pDest, pSrc, msize);
-            pSrc += rowPitch;
-            pDest += dest->rowPitch;
-        }
-    }
-
-    for (size_t level = 1; level < metadata.mipLevels; ++level)
-    {
-        if (level >= nimages)
-            return E_FAIL;
-
-        float alphaScale = 0.0f;
-        hr = EstimateAlphaScaleForCoverage(srcImages[level], alphaReference, targetCoverage, alphaScale);
-        if (FAILED(hr))
-            return hr;
-
-        const Image* mipImage = mipChain.GetImage(level, item, 0);
-        if (!mipImage)
-            return E_POINTER;
-
-        hr = ScaleAlpha(srcImages[level], alphaScale, *mipImage);
-        if (FAILED(hr))
-            return hr;
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexMisc.cpp b/thirdparty/directxtex/DirectXTexMisc.cpp
deleted file mode 100644
index 1f3b9be..0000000
--- a/thirdparty/directxtex/DirectXTexMisc.cpp
+++ /dev/null
@@ -1,767 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexMisc.cpp
-//
-// DirectX Texture Library - Misc image operations
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wignored-attributes"
-#endif
-
-namespace
-{
-    const XMVECTORF32 g_Gamma22 = { { { 2.2f, 2.2f, 2.2f, 1.f } } };
-
-    //-------------------------------------------------------------------------------------
-    HRESULT ComputeMSE_(
-        const Image& image1,
-        const Image& image2,
-        float& mse,
-        _Out_writes_opt_(4) float* mseV,
-        CMSE_FLAGS flags) noexcept
-    {
-        if (!image1.pixels || !image2.pixels)
-            return E_POINTER;
-
-        assert(image1.width == image2.width && image1.height == image2.height);
-        assert(!IsCompressed(image1.format) && !IsCompressed(image2.format));
-
-        const size_t width = image1.width;
-
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 2);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        // Flags implied from image formats
-        switch (image1.format)
-        {
-        case DXGI_FORMAT_B8G8R8X8_UNORM:
-            flags |= CMSE_IGNORE_ALPHA;
-            break;
-
-        case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-            flags |= CMSE_IMAGE1_SRGB | CMSE_IGNORE_ALPHA;
-            break;
-
-        case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-        case DXGI_FORMAT_BC1_UNORM_SRGB:
-        case DXGI_FORMAT_BC2_UNORM_SRGB:
-        case DXGI_FORMAT_BC3_UNORM_SRGB:
-        case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        case DXGI_FORMAT_BC7_UNORM_SRGB:
-            flags |= CMSE_IMAGE1_SRGB;
-            break;
-
-        default:
-            break;
-        }
-
-        switch (image2.format)
-        {
-        case DXGI_FORMAT_B8G8R8X8_UNORM:
-            flags |= CMSE_IGNORE_ALPHA;
-            break;
-
-        case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-            flags |= CMSE_IMAGE2_SRGB | CMSE_IGNORE_ALPHA;
-            break;
-
-        case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-        case DXGI_FORMAT_BC1_UNORM_SRGB:
-        case DXGI_FORMAT_BC2_UNORM_SRGB:
-        case DXGI_FORMAT_BC3_UNORM_SRGB:
-        case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        case DXGI_FORMAT_BC7_UNORM_SRGB:
-            flags |= CMSE_IMAGE2_SRGB;
-            break;
-
-        default:
-            break;
-        }
-
-        const uint8_t *pSrc1 = image1.pixels;
-        const size_t rowPitch1 = image1.rowPitch;
-
-        const uint8_t *pSrc2 = image2.pixels;
-        const size_t rowPitch2 = image2.rowPitch;
-
-        XMVECTOR acc = g_XMZero;
-        static XMVECTORF32 two = { { { 2.0f, 2.0f, 2.0f, 2.0f } } };
-
-        for (size_t h = 0; h < image1.height; ++h)
-        {
-            XMVECTOR* ptr1 = scanline.get();
-            if (!LoadScanline(ptr1, width, pSrc1, rowPitch1, image1.format))
-                return E_FAIL;
-
-            XMVECTOR* ptr2 = scanline.get() + width;
-            if (!LoadScanline(ptr2, width, pSrc2, rowPitch2, image2.format))
-                return E_FAIL;
-
-            for (size_t i = 0; i < width; ++i)
-            {
-                XMVECTOR v1 = *(ptr1++);
-                if (flags & CMSE_IMAGE1_SRGB)
-                {
-                    v1 = XMVectorPow(v1, g_Gamma22);
-                }
-                if (flags & CMSE_IMAGE1_X2_BIAS)
-                {
-                    v1 = XMVectorMultiplyAdd(v1, two, g_XMNegativeOne);
-                }
-
-                XMVECTOR v2 = *(ptr2++);
-                if (flags & CMSE_IMAGE2_SRGB)
-                {
-                    v2 = XMVectorPow(v2, g_Gamma22);
-                }
-                if (flags & CMSE_IMAGE2_X2_BIAS)
-                {
-                    v2 = XMVectorMultiplyAdd(v2, two, g_XMNegativeOne);
-                }
-
-                // sum[ (I1 - I2)^2 ]
-                XMVECTOR v = XMVectorSubtract(v1, v2);
-                if (flags & CMSE_IGNORE_RED)
-                {
-                    v = XMVectorSelect(v, g_XMZero, g_XMMaskX);
-                }
-                if (flags & CMSE_IGNORE_GREEN)
-                {
-                    v = XMVectorSelect(v, g_XMZero, g_XMMaskY);
-                }
-                if (flags & CMSE_IGNORE_BLUE)
-                {
-                    v = XMVectorSelect(v, g_XMZero, g_XMMaskZ);
-                }
-                if (flags & CMSE_IGNORE_ALPHA)
-                {
-                    v = XMVectorSelect(v, g_XMZero, g_XMMaskW);
-                }
-
-                acc = XMVectorMultiplyAdd(v, v, acc);
-            }
-
-            pSrc1 += rowPitch1;
-            pSrc2 += rowPitch2;
-        }
-
-        // MSE = sum[ (I1 - I2)^2 ] / w*h
-        const XMVECTOR d = XMVectorReplicate(float(image1.width * image1.height));
-        const XMVECTOR v = XMVectorDivide(acc, d);
-        if (mseV)
-        {
-            XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(mseV), v);
-            mse = mseV[0] + mseV[1] + mseV[2] + mseV[3];
-        }
-        else
-        {
-            XMFLOAT4 _mseV;
-            XMStoreFloat4(&_mseV, v);
-            mse = _mseV.x + _mseV.y + _mseV.z + _mseV.w;
-        }
-
-        return S_OK;
-    }
-
-    //-------------------------------------------------------------------------------------
-    HRESULT EvaluateImage_(
-        const Image& image,
-        const std::function<void __cdecl(_In_reads_(width) const XMVECTOR* pixels, size_t width, size_t y)>& pixelFunc)
-    {
-        if (!pixelFunc)
-            return E_INVALIDARG;
-
-        if (!image.pixels)
-            return E_POINTER;
-
-        assert(!IsCompressed(image.format));
-
-        const size_t width = image.width;
-
-        auto scanline = make_AlignedArrayXMVECTOR(width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        const uint8_t *pSrc = image.pixels;
-        const size_t rowPitch = image.rowPitch;
-
-        for (size_t h = 0; h < image.height; ++h)
-        {
-            if (!LoadScanline(scanline.get(), width, pSrc, rowPitch, image.format))
-                return E_FAIL;
-
-            pixelFunc(scanline.get(), width, h);
-
-            pSrc += rowPitch;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    HRESULT TransformImage_(
-        const Image& srcImage,
-        const std::function<void __cdecl(_Out_writes_(width) XMVECTOR* outPixels, _In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)>& pixelFunc,
-        const Image& destImage)
-    {
-        if (!pixelFunc)
-            return E_INVALIDARG;
-
-        if (!srcImage.pixels || !destImage.pixels)
-            return E_POINTER;
-
-        if (srcImage.width != destImage.width || srcImage.height != destImage.height || srcImage.format != destImage.format)
-            return E_FAIL;
-
-        const size_t width = srcImage.width;
-
-        auto scanlines = make_AlignedArrayXMVECTOR(uint64_t(width) * 2);
-        if (!scanlines)
-            return E_OUTOFMEMORY;
-
-        XMVECTOR* sScanline = scanlines.get();
-        XMVECTOR* dScanline = scanlines.get() + width;
-
-        const uint8_t *pSrc = srcImage.pixels;
-        const size_t spitch = srcImage.rowPitch;
-
-        uint8_t *pDest = destImage.pixels;
-        const size_t dpitch = destImage.rowPitch;
-
-        for (size_t h = 0; h < srcImage.height; ++h)
-        {
-            if (!LoadScanline(sScanline, width, pSrc, spitch, srcImage.format))
-                return E_FAIL;
-
-        #ifdef _DEBUG
-            memset(dScanline, 0xCD, sizeof(XMVECTOR)*width);
-        #endif
-
-            pixelFunc(dScanline, sScanline, width, h);
-
-            if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, dScanline, width))
-                return E_FAIL;
-
-            pSrc += spitch;
-            pDest += dpitch;
-        }
-
-        return S_OK;
-    }
-};
-
-
-//=====================================================================================
-// Entry points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Copies a rectangle from one image into another
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::CopyRectangle(
-    const Image& srcImage,
-    const Rect& srcRect,
-    const Image& dstImage,
-    TEX_FILTER_FLAGS filter,
-    size_t xOffset,
-    size_t yOffset) noexcept
-{
-    if (!srcImage.pixels || !dstImage.pixels)
-        return E_POINTER;
-
-    if (IsCompressed(srcImage.format) || IsCompressed(dstImage.format)
-        || IsPlanar(srcImage.format) || IsPlanar(dstImage.format)
-        || IsPalettized(srcImage.format) || IsPalettized(dstImage.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    // Validate rectangle/offset
-    if (!srcRect.w || !srcRect.h || ((srcRect.x + srcRect.w) > srcImage.width) || ((srcRect.y + srcRect.h) > srcImage.height))
-    {
-        return E_INVALIDARG;
-    }
-
-    if (((xOffset + srcRect.w) > dstImage.width) || ((yOffset + srcRect.h) > dstImage.height))
-    {
-        return E_INVALIDARG;
-    }
-
-    // Compute source bytes-per-pixel
-    size_t sbpp = BitsPerPixel(srcImage.format);
-    if (!sbpp)
-        return E_FAIL;
-
-    if (sbpp < 8)
-    {
-        // We don't support monochrome (DXGI_FORMAT_R1_UNORM)
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    const uint8_t* pEndSrc = srcImage.pixels + srcImage.rowPitch*srcImage.height;
-    const uint8_t* pEndDest = dstImage.pixels + dstImage.rowPitch*dstImage.height;
-
-    // Round to bytes
-    sbpp = (sbpp + 7) / 8;
-
-    const uint8_t* pSrc = srcImage.pixels + (srcRect.y * srcImage.rowPitch) + (srcRect.x * sbpp);
-
-    if (srcImage.format == dstImage.format)
-    {
-        // Direct copy case (avoid intermediate conversions)
-        uint8_t* pDest = dstImage.pixels + (yOffset * dstImage.rowPitch) + (xOffset * sbpp);
-        const size_t copyW = srcRect.w * sbpp;
-        for (size_t h = 0; h < srcRect.h; ++h)
-        {
-            if (((pSrc + copyW) > pEndSrc) || (pDest > pEndDest))
-                return E_FAIL;
-
-            memcpy(pDest, pSrc, copyW);
-
-            pSrc += srcImage.rowPitch;
-            pDest += dstImage.rowPitch;
-        }
-
-        return S_OK;
-    }
-
-    // Compute destination bytes-per-pixel (not the same format as source)
-    size_t dbpp = BitsPerPixel(dstImage.format);
-    if (!dbpp)
-        return E_FAIL;
-
-    if (dbpp < 8)
-    {
-        // We don't support monochrome (DXGI_FORMAT_R1_UNORM)
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-    // Round to bytes
-    dbpp = (dbpp + 7) / 8;
-
-    uint8_t* pDest = dstImage.pixels + (yOffset * dstImage.rowPitch) + (xOffset * dbpp);
-
-    auto scanline = make_AlignedArrayXMVECTOR(srcRect.w);
-    if (!scanline)
-        return E_OUTOFMEMORY;
-
-    const size_t copyS = srcRect.w * sbpp;
-    const size_t copyD = srcRect.w * dbpp;
-
-    for (size_t h = 0; h < srcRect.h; ++h)
-    {
-        if (((pSrc + copyS) > pEndSrc) || ((pDest + copyD) > pEndDest))
-            return E_FAIL;
-
-        if (!LoadScanline(scanline.get(), srcRect.w, pSrc, copyS, srcImage.format))
-            return E_FAIL;
-
-        ConvertScanline(scanline.get(), srcRect.w, dstImage.format, srcImage.format, filter);
-
-        if (!StoreScanline(pDest, copyD, dstImage.format, scanline.get(), srcRect.w))
-            return E_FAIL;
-
-        pSrc += srcImage.rowPitch;
-        pDest += dstImage.rowPitch;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Computes the Mean-Squared-Error (MSE) between two images
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::ComputeMSE(
-    const Image& image1,
-    const Image& image2,
-    float& mse,
-    float* mseV,
-    CMSE_FLAGS flags) noexcept
-{
-    if (!image1.pixels || !image2.pixels)
-        return E_POINTER;
-
-    if (image1.width != image2.width || image1.height != image2.height)
-        return E_INVALIDARG;
-
-    if (!IsValid(image1.format) || !IsValid(image2.format))
-        return E_INVALIDARG;
-
-    if (IsPlanar(image1.format) || IsPlanar(image2.format)
-        || IsPalettized(image1.format) || IsPalettized(image2.format)
-        || IsTypeless(image1.format) || IsTypeless(image2.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (IsCompressed(image1.format))
-    {
-        if (IsCompressed(image2.format))
-        {
-            // Case 1: both images are compressed, expand to RGBA32F
-            ScratchImage temp1;
-            HRESULT hr = Decompress(image1, DXGI_FORMAT_R32G32B32A32_FLOAT, temp1);
-            if (FAILED(hr))
-                return hr;
-
-            ScratchImage temp2;
-            hr = Decompress(image2, DXGI_FORMAT_R32G32B32A32_FLOAT, temp2);
-            if (FAILED(hr))
-                return hr;
-
-            const Image* img1 = temp1.GetImage(0, 0, 0);
-            const Image* img2 = temp2.GetImage(0, 0, 0);
-            if (!img1 || !img2)
-                return E_POINTER;
-
-            return ComputeMSE_(*img1, *img2, mse, mseV, flags);
-        }
-        else
-        {
-            // Case 2: image1 is compressed, expand to RGBA32F
-            ScratchImage temp;
-            HRESULT hr = Decompress(image1, DXGI_FORMAT_R32G32B32A32_FLOAT, temp);
-            if (FAILED(hr))
-                return hr;
-
-            const Image* img = temp.GetImage(0, 0, 0);
-            if (!img)
-                return E_POINTER;
-
-            return ComputeMSE_(*img, image2, mse, mseV, flags);
-        }
-    }
-    else
-    {
-        if (IsCompressed(image2.format))
-        {
-            // Case 3: image2 is compressed, expand to RGBA32F
-            ScratchImage temp;
-            HRESULT hr = Decompress(image2, DXGI_FORMAT_R32G32B32A32_FLOAT, temp);
-            if (FAILED(hr))
-                return hr;
-
-            const Image* img = temp.GetImage(0, 0, 0);
-            if (!img)
-                return E_POINTER;
-
-            return ComputeMSE_(image1, *img, mse, mseV, flags);
-        }
-        else
-        {
-            // Case 4: neither image is compressed
-            return ComputeMSE_(image1, image2, mse, mseV, flags);
-        }
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Evaluates a user-supplied function for all the pixels in the image
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::EvaluateImage(
-    const Image& image,
-    std::function<void __cdecl(_In_reads_(width) const XMVECTOR* pixels, size_t width, size_t y)> pixelFunc)
-{
-    if (image.width > UINT32_MAX
-        || image.height > UINT32_MAX)
-        return E_INVALIDARG;
-
-    if (!IsValid(image.format))
-        return E_INVALIDARG;
-
-    if (IsPlanar(image.format) || IsPalettized(image.format) || IsTypeless(image.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (IsCompressed(image.format))
-    {
-        ScratchImage temp;
-        HRESULT hr = Decompress(image, DXGI_FORMAT_R32G32B32A32_FLOAT, temp);
-        if (FAILED(hr))
-            return hr;
-
-        const Image* img = temp.GetImage(0, 0, 0);
-        if (!img)
-            return E_POINTER;
-
-        return EvaluateImage_(*img, pixelFunc);
-    }
-    else
-    {
-        return EvaluateImage_(image, pixelFunc);
-    }
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::EvaluateImage(
-    const Image* images,
-    size_t nimages,
-    const TexMetadata& metadata,
-    std::function<void __cdecl(_In_reads_(width) const XMVECTOR* pixels, size_t width, size_t y)> pixelFunc)
-{
-    if (!images || !nimages)
-        return E_INVALIDARG;
-
-    if (!IsValid(metadata.format))
-        return E_INVALIDARG;
-
-    if (IsPlanar(metadata.format) || IsPalettized(metadata.format) || IsTypeless(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (metadata.width > UINT32_MAX
-        || metadata.height > UINT32_MAX)
-        return E_INVALIDARG;
-
-    if (metadata.IsVolumemap() && metadata.depth > UINT16_MAX)
-        return E_INVALIDARG;
-
-    ScratchImage temp;
-    DXGI_FORMAT format = metadata.format;
-    if (IsCompressed(format))
-    {
-        HRESULT hr = Decompress(images, nimages, metadata, DXGI_FORMAT_R32G32B32A32_FLOAT, temp);
-        if (FAILED(hr))
-            return hr;
-
-        if (nimages != temp.GetImageCount())
-            return E_UNEXPECTED;
-
-        images = temp.GetImages();
-        format = DXGI_FORMAT_R32G32B32A32_FLOAT;
-    }
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-    case TEX_DIMENSION_TEXTURE2D:
-        for (size_t index = 0; index < nimages; ++index)
-        {
-            const Image& img = images[index];
-            if (img.format != format)
-                return E_FAIL;
-
-            if ((img.width > UINT32_MAX) || (img.height > UINT32_MAX))
-                return E_FAIL;
-
-            HRESULT hr = EvaluateImage_(img, pixelFunc);
-            if (FAILED(hr))
-                return hr;
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        {
-            size_t index = 0;
-            size_t d = metadata.depth;
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                for (size_t slice = 0; slice < d; ++slice, ++index)
-                {
-                    if (index >= nimages)
-                        return E_FAIL;
-
-                    const Image& img = images[index];
-                    if (img.format != format)
-                        return E_FAIL;
-
-                    if ((img.width > UINT32_MAX) || (img.height > UINT32_MAX))
-                        return E_FAIL;
-
-                    HRESULT hr = EvaluateImage_(img, pixelFunc);
-                    if (FAILED(hr))
-                        return hr;
-                }
-
-                if (d > 1)
-                    d >>= 1;
-            }
-        }
-        break;
-
-    default:
-        return E_FAIL;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Use a user-supplied function to compute a new image from an input image
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::TransformImage(
-    const Image& image,
-    std::function<void __cdecl(_Out_writes_(width) XMVECTOR* outPixels, _In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
-    ScratchImage& result)
-{
-    if (image.width > UINT32_MAX
-        || image.height > UINT32_MAX)
-        return E_INVALIDARG;
-
-    if (IsPlanar(image.format) || IsPalettized(image.format) || IsCompressed(image.format) || IsTypeless(image.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    HRESULT hr = result.Initialize2D(image.format, image.width, image.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image* dimg = result.GetImage(0, 0, 0);
-    if (!dimg)
-    {
-        result.Release();
-        return E_POINTER;
-    }
-
-    hr = TransformImage_(image, pixelFunc, *dimg);
-    if (FAILED(hr))
-    {
-        result.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::TransformImage(
-    const Image* srcImages,
-    size_t nimages, const TexMetadata& metadata,
-    std::function<void __cdecl(_Out_writes_(width) XMVECTOR* outPixels, _In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
-    ScratchImage& result)
-{
-    if (!srcImages || !nimages)
-        return E_INVALIDARG;
-
-    if (IsPlanar(metadata.format) || IsPalettized(metadata.format) || IsCompressed(metadata.format) || IsTypeless(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if (metadata.width > UINT32_MAX
-        || metadata.height > UINT32_MAX)
-        return E_INVALIDARG;
-
-    if (metadata.IsVolumemap() && metadata.depth > UINT16_MAX)
-        return E_INVALIDARG;
-
-    HRESULT hr = result.Initialize(metadata);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != result.GetImageCount())
-    {
-        result.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = result.GetImages();
-    if (!dest)
-    {
-        result.Release();
-        return E_POINTER;
-    }
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-    case TEX_DIMENSION_TEXTURE2D:
-        for (size_t index = 0; index < nimages; ++index)
-        {
-            const Image& src = srcImages[index];
-            if (src.format != metadata.format)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            const Image& dst = dest[index];
-
-            if (src.width != dst.width || src.height != dst.height)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            hr = TransformImage_(src, pixelFunc, dst);
-            if (FAILED(hr))
-            {
-                result.Release();
-                return hr;
-            }
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        {
-            size_t index = 0;
-            size_t d = metadata.depth;
-            for (size_t level = 0; level < metadata.mipLevels; ++level)
-            {
-                for (size_t slice = 0; slice < d; ++slice, ++index)
-                {
-                    if (index >= nimages)
-                    {
-                        result.Release();
-                        return E_FAIL;
-                    }
-
-                    const Image& src = srcImages[index];
-                    if (src.format != metadata.format)
-                    {
-                        result.Release();
-                        return E_FAIL;
-                    }
-
-                    if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
-                    {
-                        result.Release();
-                        return E_FAIL;
-                    }
-
-                    const Image& dst = dest[index];
-
-                    if (src.width != dst.width || src.height != dst.height)
-                    {
-                        result.Release();
-                        return E_FAIL;
-                    }
-
-                    hr = TransformImage_(src, pixelFunc, dst);
-                    if (FAILED(hr))
-                    {
-                        result.Release();
-                        return hr;
-                    }
-                }
-
-                if (d > 1)
-                    d >>= 1;
-            }
-        }
-        break;
-
-    default:
-        result.Release();
-        return E_FAIL;
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexNormalMaps.cpp b/thirdparty/directxtex/DirectXTexNormalMaps.cpp
deleted file mode 100644
index 0a35900..0000000
--- a/thirdparty/directxtex/DirectXTexNormalMaps.cpp
+++ /dev/null
@@ -1,393 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexNormalMaps.cpp
-//
-// DirectX Texture Library - Normal map operations
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-
-namespace
-{
-
-#pragma prefast(suppress : 25000, "FXMVECTOR is 16 bytes")
-    inline float EvaluateColor(_In_ FXMVECTOR val, _In_ CNMAP_FLAGS flags) noexcept
-    {
-        XMFLOAT4A f;
-
-        static XMVECTORF32 lScale = { { { 0.2125f, 0.7154f, 0.0721f, 1.f } } };
-
-        static_assert(CNMAP_CHANNEL_RED == 0x1, "CNMAP_CHANNEL_ flag values don't match mask");
-        switch (flags & 0xf)
-        {
-        case 0:
-        case CNMAP_CHANNEL_RED:     return XMVectorGetX(val);
-        case CNMAP_CHANNEL_GREEN:   return XMVectorGetY(val);
-        case CNMAP_CHANNEL_BLUE:    return XMVectorGetZ(val);
-        case CNMAP_CHANNEL_ALPHA:   return XMVectorGetW(val);
-
-        case CNMAP_CHANNEL_LUMINANCE:
-            {
-                const XMVECTOR v = XMVectorMultiply(val, lScale);
-                XMStoreFloat4A(&f, v);
-                return f.x + f.y + f.z;
-            }
-
-        default:
-            assert(false);
-            return 0.f;
-        }
-    }
-
-    void EvaluateRow(
-        _In_reads_(width) const XMVECTOR* pSource,
-        _Out_writes_(width + 2) float* pDest,
-        size_t width,
-        CNMAP_FLAGS flags) noexcept
-    {
-        assert(pSource && pDest);
-        assert(width > 0);
-
-        for (size_t x = 0; x < width; ++x)
-        {
-            pDest[x + 1] = EvaluateColor(pSource[x], flags);
-        }
-
-        if (flags & CNMAP_MIRROR_U)
-        {
-            // Mirror in U
-            pDest[0] = EvaluateColor(pSource[0], flags);
-            pDest[width + 1] = EvaluateColor(pSource[width - 1], flags);
-        }
-        else
-        {
-            // Wrap in U
-            pDest[0] = EvaluateColor(pSource[width - 1], flags);
-            pDest[width + 1] = EvaluateColor(pSource[0], flags);
-        }
-    }
-
-    HRESULT ComputeNMap(_In_ const Image& srcImage, _In_ CNMAP_FLAGS flags, _In_ float amplitude,
-        _In_ DXGI_FORMAT format, _In_ const Image& normalMap) noexcept
-    {
-        if (!srcImage.pixels || !normalMap.pixels)
-            return E_INVALIDARG;
-
-        const uint32_t convFlags = GetConvertFlags(format);
-        if (!convFlags)
-            return E_FAIL;
-
-        if (!(convFlags & (CONVF_UNORM | CONVF_SNORM | CONVF_FLOAT)))
-            return HRESULT_E_NOT_SUPPORTED;
-
-        const size_t width = srcImage.width;
-        const size_t height = srcImage.height;
-        if (width != normalMap.width || height != normalMap.height)
-            return E_FAIL;
-
-        // Allocate temporary space (4 scanlines and 3 evaluated rows)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(width) * 4);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        auto buffer = make_AlignedArrayFloat((uint64_t(width) + 2) * 3);
-        if (!buffer)
-            return E_OUTOFMEMORY;
-
-        uint8_t* pDest = normalMap.pixels;
-        if (!pDest)
-            return E_POINTER;
-
-        XMVECTOR* row0 = scanline.get();
-        XMVECTOR* row1 = row0 + width;
-        XMVECTOR* row2 = row1 + width;
-        XMVECTOR* target = row2 + width;
-
-        float* val0 = buffer.get();
-        float* val1 = val0 + width + 2;
-        float* val2 = val1 + width + 2;
-
-        const size_t rowPitch = srcImage.rowPitch;
-        const uint8_t* pSrc = srcImage.pixels;
-
-        // Read first scanline row into 'row1'
-        if (!LoadScanline(row1, width, pSrc, rowPitch, srcImage.format))
-            return E_FAIL;
-
-        // Setup 'row0'
-        if (flags & CNMAP_MIRROR_V)
-        {
-            // Mirror first row
-            memcpy(row0, row1, rowPitch);
-        }
-        else
-        {
-            // Read last row (Wrap V)
-            if (!LoadScanline(row0, width, pSrc + (rowPitch * (height - 1)), rowPitch, srcImage.format))
-                return E_FAIL;
-        }
-
-        // Evaluate the initial rows
-        EvaluateRow(row0, val0, width, flags);
-        EvaluateRow(row1, val1, width, flags);
-
-        pSrc += rowPitch;
-
-        for (size_t y = 0; y < height; ++y)
-        {
-            // Load next scanline of source image
-            if (y < (height - 1))
-            {
-                if (!LoadScanline(row2, width, pSrc, rowPitch, srcImage.format))
-                    return E_FAIL;
-            }
-            else
-            {
-                if (flags & CNMAP_MIRROR_V)
-                {
-                    // Use last row of source image
-                    if (!LoadScanline(row2, width, srcImage.pixels + (rowPitch * (height - 1)), rowPitch, srcImage.format))
-                        return E_FAIL;
-                }
-                else
-                {
-                    // Use first row of source image (Wrap V)
-                    if (!LoadScanline(row2, width, srcImage.pixels, rowPitch, srcImage.format))
-                        return E_FAIL;
-                }
-            }
-
-            // Evaluate row
-            EvaluateRow(row2, val2, width, flags);
-
-            // Generate target scanline
-            XMVECTOR *dptr = target;
-            for (size_t x = 0; x < width; ++x)
-            {
-                // Compute normal via central differencing
-                float totDelta = (val0[x] - val0[x + 2]) + (val1[x] - val1[x + 2]) + (val2[x] - val2[x + 2]);
-                const float deltaZX = totDelta * amplitude / 6.f;
-
-                totDelta = (val0[x] - val2[x]) + (val0[x + 1] - val2[x + 1]) + (val0[x + 2] - val2[x + 2]);
-                const float deltaZY = totDelta * amplitude / 6.f;
-
-                const XMVECTOR vx = XMVectorSetZ(g_XMNegIdentityR0, deltaZX);   // (-1.0f, 0.0f, deltaZX)
-                const XMVECTOR vy = XMVectorSetZ(g_XMNegIdentityR1, deltaZY);   // (0.0f, -1.0f, deltaZY)
-
-                const XMVECTOR normal = XMVector3Normalize(XMVector3Cross(vx, vy));
-
-                // Compute alpha (1.0 or an occlusion term)
-                float alpha = 1.f;
-
-                if (flags & CNMAP_COMPUTE_OCCLUSION)
-                {
-                    float delta = 0.f;
-                    const float c = val1[x + 1];
-
-                    float t = val0[x] - c;  if (t > 0.f) delta += t;
-                    t = val0[x + 1] - c;    if (t > 0.f) delta += t;
-                    t = val0[x + 2] - c;    if (t > 0.f) delta += t;
-                    t = val1[x] - c;    if (t > 0.f) delta += t;
-                    // Skip current pixel
-                    t = val1[x + 2] - c;    if (t > 0.f) delta += t;
-                    t = val2[x] - c;    if (t > 0.f) delta += t;
-                    t = val2[x + 1] - c;    if (t > 0.f) delta += t;
-                    t = val2[x + 2] - c;    if (t > 0.f) delta += t;
-
-                    // Average delta (divide by 8, scale by amplitude factor)
-                    delta *= 0.125f * amplitude;
-                    if (delta > 0.f)
-                    {
-                        // If < 0, then no occlusion
-                        const float r = sqrtf(1.f + delta*delta);
-                        alpha = (r - delta) / r;
-                    }
-                }
-
-                // Encode based on target format
-                if (convFlags & CONVF_UNORM)
-                {
-                    // 0.5f*normal + 0.5f -or- invert sign case: -0.5f*normal + 0.5f
-                    const XMVECTOR n1 = XMVectorMultiplyAdd((flags & CNMAP_INVERT_SIGN) ? g_XMNegativeOneHalf : g_XMOneHalf, normal, g_XMOneHalf);
-                    *dptr++ = XMVectorSetW(n1, alpha);
-                }
-                else if (flags & CNMAP_INVERT_SIGN)
-                {
-                    *dptr++ = XMVectorSetW(XMVectorNegate(normal), alpha);
-                }
-                else
-                {
-                    *dptr++ = XMVectorSetW(normal, alpha);
-                }
-            }
-
-            if (!StoreScanline(pDest, normalMap.rowPitch, format, target, width))
-                return E_FAIL;
-
-            // Cycle buffers
-            float* temp = val0;
-            val0 = val1;
-            val1 = val2;
-            val2 = temp;
-
-            pSrc += rowPitch;
-            pDest += normalMap.rowPitch;
-        }
-
-        return S_OK;
-    }
-}
-
-
-//=====================================================================================
-// Entry points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Generates a normal map from a height-map
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::ComputeNormalMap(
-    const Image& srcImage,
-    CNMAP_FLAGS flags,
-    float amplitude,
-    DXGI_FORMAT format,
-    ScratchImage& normalMap) noexcept
-{
-    if (!srcImage.pixels || !IsValid(format))
-        return E_INVALIDARG;
-
-    static_assert(CNMAP_CHANNEL_RED == 0x1, "CNMAP_CHANNEL_ flag values don't match mask");
-    switch (flags & 0xf)
-    {
-    case 0:
-    case CNMAP_CHANNEL_RED:
-    case CNMAP_CHANNEL_GREEN:
-    case CNMAP_CHANNEL_BLUE:
-    case CNMAP_CHANNEL_ALPHA:
-    case CNMAP_CHANNEL_LUMINANCE:
-        break;
-
-    default:
-        return E_INVALIDARG;
-    }
-
-    if (IsCompressed(format) || IsCompressed(srcImage.format)
-        || IsTypeless(format) || IsTypeless(srcImage.format)
-        || IsPlanar(format) || IsPlanar(srcImage.format)
-        || IsPalettized(format) || IsPalettized(srcImage.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    // Setup target image
-    normalMap.Release();
-
-    HRESULT hr = normalMap.Initialize2D(format, srcImage.width, srcImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *img = normalMap.GetImage(0, 0, 0);
-    if (!img)
-    {
-        normalMap.Release();
-        return E_POINTER;
-    }
-
-    hr = ComputeNMap(srcImage, flags, amplitude, format, *img);
-    if (FAILED(hr))
-    {
-        normalMap.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::ComputeNormalMap(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    CNMAP_FLAGS flags,
-    float amplitude,
-    DXGI_FORMAT format,
-    ScratchImage& normalMaps) noexcept
-{
-    if (!srcImages || !nimages || !IsValid(format))
-        return E_INVALIDARG;
-
-    if (IsCompressed(format) || IsCompressed(metadata.format)
-        || IsTypeless(format) || IsTypeless(metadata.format)
-        || IsPlanar(format) || IsPlanar(metadata.format)
-        || IsPalettized(format) || IsPalettized(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    static_assert(CNMAP_CHANNEL_RED == 0x1, "CNMAP_CHANNEL_ flag values don't match mask");
-    switch (flags & 0xf)
-    {
-    case 0:
-    case CNMAP_CHANNEL_RED:
-    case CNMAP_CHANNEL_GREEN:
-    case CNMAP_CHANNEL_BLUE:
-    case CNMAP_CHANNEL_ALPHA:
-    case CNMAP_CHANNEL_LUMINANCE:
-        break;
-
-    default:
-        return E_INVALIDARG;
-    }
-
-    normalMaps.Release();
-
-    TexMetadata mdata2 = metadata;
-    mdata2.format = format;
-    HRESULT hr = normalMaps.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != normalMaps.GetImageCount())
-    {
-        normalMaps.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = normalMaps.GetImages();
-    if (!dest)
-    {
-        normalMaps.Release();
-        return E_POINTER;
-    }
-
-    for (size_t index = 0; index < nimages; ++index)
-    {
-        assert(dest[index].format == format);
-
-        const Image& src = srcImages[index];
-        if (IsCompressed(src.format) || IsTypeless(src.format))
-        {
-            normalMaps.Release();
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        if (src.width != dest[index].width || src.height != dest[index].height)
-        {
-            normalMaps.Release();
-            return E_FAIL;
-        }
-
-        hr = ComputeNMap(src, flags, amplitude, format, dest[index]);
-        if (FAILED(hr))
-        {
-            normalMaps.Release();
-            return hr;
-        }
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexP.h b/thirdparty/directxtex/DirectXTexP.h
deleted file mode 100644
index 38fdc44..0000000
--- a/thirdparty/directxtex/DirectXTexP.h
+++ /dev/null
@@ -1,439 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexP.h
-//
-// DirectX Texture Library - Private header
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-// Off by default warnings
-#pragma warning(disable : 4619 4616 4061 4265 4365 4571 4623 4625 4626 4628 4668 4710 4711 4746 4774 4820 4987 5026 5027 5031 5032 5039 5045 5219 5246 5264 26812)
-// C4619/4616 #pragma warning warnings
-// C4061 enumerator 'X' in switch of enum 'X' is not explicitly handled by a case label
-// C4265 class has virtual functions, but destructor is not virtual
-// C4365 signed/unsigned mismatch
-// C4571 behavior change
-// C4623 default constructor was implicitly defined as deleted
-// C4625 copy constructor was implicitly defined as deleted
-// C4626 assignment operator was implicitly defined as deleted
-// C4628 digraphs not supported
-// C4668 not defined as a preprocessor macro
-// C4710 function not inlined
-// C4711 selected for automatic inline expansion
-// C4746 volatile access of '<expression>' is subject to /volatile:<iso|ms> setting
-// C4774 format string expected in argument 3 is not a string literal
-// C4820 padding added after data member
-// C4987 nonstandard extension used
-// C5026 move constructor was implicitly defined as deleted
-// C5027 move assignment operator was implicitly defined as deleted
-// C5031/5032 push/pop mismatches in windows headers
-// C5039 pointer or reference to potentially throwing function passed to extern C function under - EHc
-// C5045 Spectre mitigation warning
-// C5219 implicit conversion from 'int' to 'float', possible loss of data
-// C5246 the initialization of a subobject should be wrapped in braces
-// C5264 'const' variable is not used
-// 26812: The enum type 'x' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).
-
-// Windows 8.1 SDK related Off by default warnings
-#pragma warning(disable : 4471 4917 4986 5029)
-// C4471 forward declaration of an unscoped enumeration must have an underlying type
-// C4917 a GUID can only be associated with a class, interface or namespace
-// C4986 exception specification does not match previous declaration
-// C5029 nonstandard extension used
-
-// Xbox One XDK related Off by default warnings
-#pragma warning(disable : 4643)
-// C4643 Forward declaring in namespace std is not permitted by the C++ Standard
-
-#ifdef __INTEL_COMPILER
-#pragma warning(disable : 161)
-// warning #161: unrecognized #pragma
-#endif
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wc++98-compat"
-#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
-#pragma clang diagnostic ignored "-Wc++98-compat-local-type-template-args"
-#pragma clang diagnostic ignored "-Wcovered-switch-default"
-#pragma clang diagnostic ignored "-Wfloat-equal"
-#pragma clang diagnostic ignored "-Wglobal-constructors"
-#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
-#pragma clang diagnostic ignored "-Wlanguage-extension-token"
-#pragma clang diagnostic ignored "-Wmissing-variable-declarations"
-#pragma clang diagnostic ignored "-Wnested-anon-types"
-#pragma clang diagnostic ignored "-Wreserved-id-macro"
-#pragma clang diagnostic ignored "-Wswitch-enum"
-#pragma clang diagnostic ignored "-Wtautological-type-limit-compare"
-#pragma clang diagnostic ignored "-Wunknown-pragmas"
-#endif
-
-#ifdef _WIN32
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-
-#pragma warning(push)
-#pragma warning(disable : 4005)
-#define NOMINMAX 1
-#define NODRAWTEXT
-#define NOGDI
-#define NOBITMAP
-#define NOMCX
-#define NOSERVICE
-#define NOHELP
-#pragma warning(pop)
-
-#include <Windows.h>
-
-#ifdef __MINGW32__
-#include <unknwn.h>
-#endif
-
-#ifndef _WIN32_WINNT_WIN10
-#define _WIN32_WINNT_WIN10 0x0A00
-#endif
-
-#ifdef _GAMING_XBOX_SCARLETT
-#pragma warning(push)
-#pragma warning(disable: 5204 5249)
-#include <d3d12_xs.h>
-#pragma warning(pop)
-#elif defined(_GAMING_XBOX)
-#pragma warning(push)
-#pragma warning(disable: 5204)
-#include <d3d12_x.h>
-#pragma warning(pop)
-#elif defined(_XBOX_ONE) && defined(_TITLE)
-#include <d3d12_x.h>
-#include <d3d11_x.h>
-#elif (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
-#ifdef USING_DIRECTX_HEADERS
-#include <directx/dxgiformat.h>
-#include <directx/d3d12.h>
-#else
-#include <d3d12.h>
-#endif
-#include <d3d11_4.h>
-#else
-#include <d3d11_1.h>
-#endif
-#else // !WIN32
-#include <wsl/winadapter.h>
-#include <wsl/wrladapter.h>
-#include <directx/d3d12.h>
-#endif
-
-#include <algorithm>
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <cstring>
-#include <iterator>
-#include <memory>
-#include <new>
-#include <tuple>
-
-#ifndef _WIN32
-#include <fstream>
-#include <filesystem>
-#include <thread>
-#endif
-
-#define _XM_NO_XMVECTOR_OVERLOADS_
-
-#include <DirectXPackedVector.h>
-
-#if (DIRECTX_MATH_VERSION < 315)
-#define XM_ALIGNED_DATA(x) __declspec(align(x))
-#endif
-
-#include "DirectXTex.h"
-
-#ifdef _WIN32
-#include <malloc.h>
-
-#if defined(NTDDI_WIN10_FE) || defined(__MINGW32__)
-#include <ole2.h>
-#else
-#include <Ole2.h>
-#endif
-#include <wincodec.h>
-#include <wrl\client.h>
-#else
-using WICPixelFormatGUID = GUID;
-#endif
-
-#include "scoped.h"
-
-#define XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT DXGI_FORMAT(116)
-#define XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT DXGI_FORMAT(117)
-#define XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT DXGI_FORMAT(118)
-#define XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS DXGI_FORMAT(119)
-#define XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT DXGI_FORMAT(120)
-
-#define WIN10_DXGI_FORMAT_P208 DXGI_FORMAT(130)
-#define WIN10_DXGI_FORMAT_V208 DXGI_FORMAT(131)
-#define WIN10_DXGI_FORMAT_V408 DXGI_FORMAT(132)
-
-#ifndef XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM
-#define XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM DXGI_FORMAT(189)
-#endif
-
-#define XBOX_DXGI_FORMAT_R4G4_UNORM DXGI_FORMAT(190)
-
-#if defined(__MINGW32__) && !defined(E_BOUNDS)
-#define E_BOUNDS static_cast<HRESULT>(0x8000000BL)
-#endif
-
-// HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW)
-#define HRESULT_E_ARITHMETIC_OVERFLOW static_cast<HRESULT>(0x80070216L)
-
-// HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED)
-#define HRESULT_E_NOT_SUPPORTED static_cast<HRESULT>(0x80070032L)
-
-// HRESULT_FROM_WIN32(ERROR_HANDLE_EOF)
-#define HRESULT_E_HANDLE_EOF static_cast<HRESULT>(0x80070026L)
-
-// HRESULT_FROM_WIN32(ERROR_INVALID_DATA)
-#define HRESULT_E_INVALID_DATA static_cast<HRESULT>(0x8007000DL)
-
-// HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE)
-#define HRESULT_E_FILE_TOO_LARGE static_cast<HRESULT>(0x800700DFL)
-
-// HRESULT_FROM_WIN32(ERROR_CANNOT_MAKE)
-#define HRESULT_E_CANNOT_MAKE static_cast<HRESULT>(0x80070052L)
-
-// HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)
-#ifndef E_NOT_SUFFICIENT_BUFFER
-#define E_NOT_SUFFICIENT_BUFFER static_cast<HRESULT>(0x8007007AL)
-#endif
-
-//-------------------------------------------------------------------------------------
-namespace DirectX
-{
-    namespace Internal
-    {
-        //-----------------------------------------------------------------------------
-        // WIC helper functions
-    #ifdef _WIN32
-        DXGI_FORMAT __cdecl WICToDXGI(_In_ const GUID& guid) noexcept;
-        bool __cdecl DXGIToWIC(_In_ DXGI_FORMAT format, _Out_ GUID& guid, _In_ bool ignoreRGBvsBGR = false) noexcept;
-
-        TEX_FILTER_FLAGS __cdecl CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept;
-
-        inline WICBitmapDitherType __cdecl GetWICDither(_In_ TEX_FILTER_FLAGS flags) noexcept
-        {
-            static_assert(TEX_FILTER_DITHER == 0x10000, "TEX_FILTER_DITHER* flag values don't match mask");
-
-            static_assert(static_cast<int>(TEX_FILTER_DITHER) == static_cast<int>(WIC_FLAGS_DITHER), "TEX_FILTER_DITHER* should match WIC_FLAGS_DITHER*");
-            static_assert(static_cast<int>(TEX_FILTER_DITHER_DIFFUSION) == static_cast<int>(WIC_FLAGS_DITHER_DIFFUSION), "TEX_FILTER_DITHER* should match WIC_FLAGS_DITHER*");
-
-            switch (flags & TEX_FILTER_DITHER_MASK)
-            {
-            case TEX_FILTER_DITHER:
-                return WICBitmapDitherTypeOrdered4x4;
-
-            case TEX_FILTER_DITHER_DIFFUSION:
-                return WICBitmapDitherTypeErrorDiffusion;
-
-            default:
-                return WICBitmapDitherTypeNone;
-            }
-        }
-
-        inline WICBitmapDitherType __cdecl GetWICDither(_In_ WIC_FLAGS flags) noexcept
-        {
-            switch (flags & TEX_FILTER_DITHER_MASK)
-            {
-            case WIC_FLAGS_DITHER:
-                return WICBitmapDitherTypeOrdered4x4;
-
-            case WIC_FLAGS_DITHER_DIFFUSION:
-                return WICBitmapDitherTypeErrorDiffusion;
-
-            default:
-                return WICBitmapDitherTypeNone;
-            }
-        }
-
-        inline WICBitmapInterpolationMode __cdecl GetWICInterp(_In_ WIC_FLAGS flags) noexcept
-        {
-            static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK");
-
-            static_assert(static_cast<int>(TEX_FILTER_POINT) == static_cast<int>(WIC_FLAGS_FILTER_POINT), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
-            static_assert(static_cast<int>(TEX_FILTER_LINEAR) == static_cast<int>(WIC_FLAGS_FILTER_LINEAR), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
-            static_assert(static_cast<int>(TEX_FILTER_CUBIC) == static_cast<int>(WIC_FLAGS_FILTER_CUBIC), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
-            static_assert(static_cast<int>(TEX_FILTER_FANT) == static_cast<int>(WIC_FLAGS_FILTER_FANT), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
-
-            switch (flags & TEX_FILTER_MODE_MASK)
-            {
-            case TEX_FILTER_POINT:
-                return WICBitmapInterpolationModeNearestNeighbor;
-
-            case TEX_FILTER_LINEAR:
-                return WICBitmapInterpolationModeLinear;
-
-            case TEX_FILTER_CUBIC:
-                return WICBitmapInterpolationModeCubic;
-
-            case TEX_FILTER_FANT:
-            default:
-                return WICBitmapInterpolationModeFant;
-            }
-        }
-
-        inline WICBitmapInterpolationMode __cdecl GetWICInterp(_In_ TEX_FILTER_FLAGS flags) noexcept
-        {
-            switch (flags & TEX_FILTER_MODE_MASK)
-            {
-            case TEX_FILTER_POINT:
-                return WICBitmapInterpolationModeNearestNeighbor;
-
-            case TEX_FILTER_LINEAR:
-                return WICBitmapInterpolationModeLinear;
-
-            case TEX_FILTER_CUBIC:
-                return WICBitmapInterpolationModeCubic;
-
-            case TEX_FILTER_FANT:
-            default:
-                return WICBitmapInterpolationModeFant;
-            }
-        }
-    #endif // WIN32
-
-        //---------------------------------------------------------------------------------
-        // Image helper functions
-        _Success_(return) bool __cdecl DetermineImageArray(
-            _In_ const TexMetadata& metadata, _In_ CP_FLAGS cpFlags,
-            _Out_ size_t& nImages, _Out_ size_t& pixelSize) noexcept;
-
-        _Success_(return) bool __cdecl SetupImageArray(
-            _In_reads_bytes_(pixelSize) uint8_t* pMemory, _In_ size_t pixelSize,
-            _In_ const TexMetadata& metadata, _In_ CP_FLAGS cpFlags,
-            _Out_writes_(nImages) Image* images, _In_ size_t nImages) noexcept;
-
-        //---------------------------------------------------------------------------------
-        // Conversion helper functions
-
-        enum TEXP_SCANLINE_FLAGS : uint32_t
-        {
-            TEXP_SCANLINE_NONE = 0,
-
-            TEXP_SCANLINE_SETALPHA = 0x1,
-            // Set alpha channel to known opaque value
-
-            TEXP_SCANLINE_LEGACY = 0x2,
-            // Enables specific legacy format conversion cases
-        };
-
-        enum CONVERT_FLAGS : uint32_t
-        {
-            CONVF_FLOAT = 0x1,
-            CONVF_UNORM = 0x2,
-            CONVF_UINT = 0x4,
-            CONVF_SNORM = 0x8,
-            CONVF_SINT = 0x10,
-            CONVF_DEPTH = 0x20,
-            CONVF_STENCIL = 0x40,
-            CONVF_SHAREDEXP = 0x80,
-            CONVF_BGR = 0x100,
-            CONVF_XR = 0x200,
-            CONVF_PACKED = 0x400,
-            CONVF_BC = 0x800,
-            CONVF_YUV = 0x1000,
-            CONVF_POS_ONLY = 0x2000,
-            CONVF_R = 0x10000,
-            CONVF_G = 0x20000,
-            CONVF_B = 0x40000,
-            CONVF_A = 0x80000,
-            CONVF_RGB_MASK = 0x70000,
-            CONVF_RGBA_MASK = 0xF0000,
-        };
-
-        uint32_t __cdecl GetConvertFlags(_In_ DXGI_FORMAT format) noexcept;
-
-        void __cdecl CopyScanline(
-            _When_(pDestination == pSource, _Inout_updates_bytes_(outSize))
-            _When_(pDestination != pSource, _Out_writes_bytes_(outSize))
-            void* pDestination, _In_ size_t outSize,
-            _In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize,
-            _In_ DXGI_FORMAT format, _In_ uint32_t tflags) noexcept;
-
-        void __cdecl SwizzleScanline(
-            _When_(pDestination == pSource, _In_)
-            _When_(pDestination != pSource, _Out_writes_bytes_(outSize))
-            void* pDestination, _In_ size_t outSize,
-            _In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize,
-            _In_ DXGI_FORMAT format, _In_ uint32_t tflags) noexcept;
-
-        _Success_(return) bool __cdecl ExpandScanline(
-            _Out_writes_bytes_(outSize) void* pDestination, _In_ size_t outSize,
-            _In_ DXGI_FORMAT outFormat,
-            _In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize,
-            _In_ DXGI_FORMAT inFormat, _In_ uint32_t tflags) noexcept;
-
-        _Success_(return) bool __cdecl LoadScanline(
-            _Out_writes_(count) XMVECTOR* pDestination, _In_ size_t count,
-            _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-            _In_ DXGI_FORMAT format) noexcept;
-
-        _Success_(return) bool __cdecl LoadScanlineLinear(
-            _Out_writes_(count) XMVECTOR* pDestination, _In_ size_t count,
-            _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
-            _In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS flags) noexcept;
-
-        _Success_(return) bool __cdecl StoreScanline(
-            _Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format,
-            _In_reads_(count) const XMVECTOR* pSource, _In_ size_t count, _In_ float threshold = 0) noexcept;
-
-        _Success_(return) bool __cdecl StoreScanlineLinear(
-            _Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format,
-            _Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count,
-            _In_ TEX_FILTER_FLAGS flags, _In_ float threshold = 0) noexcept;
-
-        _Success_(return) bool __cdecl StoreScanlineDither(
-            _Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format,
-            _Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count,
-            _In_ float threshold, size_t y, size_t z,
-            _Inout_updates_all_opt_(count + 2) XMVECTOR* pDiffusionErrors) noexcept;
-
-        HRESULT __cdecl ConvertToR32G32B32A32(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept;
-
-        HRESULT __cdecl ConvertFromR32G32B32A32(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept;
-        HRESULT __cdecl ConvertFromR32G32B32A32(
-            _In_ const Image& srcImage, _In_ DXGI_FORMAT format, _Inout_ ScratchImage& image) noexcept;
-        HRESULT __cdecl ConvertFromR32G32B32A32(
-            _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
-            _In_ DXGI_FORMAT format, _Out_ ScratchImage& result) noexcept;
-
-        HRESULT __cdecl ConvertToR16G16B16A16(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept;
-
-        HRESULT __cdecl ConvertFromR16G16B16A16(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept;
-
-        void __cdecl ConvertScanline(
-            _Inout_updates_all_(count) XMVECTOR* pBuffer, _In_ size_t count,
-            _In_ DXGI_FORMAT outFormat, _In_ DXGI_FORMAT inFormat, _In_ TEX_FILTER_FLAGS flags) noexcept;
-
-        //---------------------------------------------------------------------------------
-        // Misc helper functions
-        bool __cdecl IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept;
-        bool __cdecl CalculateMipLevels(_In_ size_t width, _In_ size_t height, _Inout_ size_t& mipLevels) noexcept;
-        bool __cdecl CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth,
-            _Inout_ size_t& mipLevels) noexcept;
-
-    #ifdef _WIN32
-        HRESULT __cdecl ResizeSeparateColorAndAlpha(_In_ IWICImagingFactory* pWIC,
-            _In_ bool iswic2,
-            _In_ IWICBitmap* original,
-            _In_ size_t newWidth, _In_ size_t newHeight, _In_ TEX_FILTER_FLAGS filter,
-            _Inout_ const Image* img) noexcept;
-    #endif
-
-    } // namespace Internal
-} // namespace DirectX
diff --git a/thirdparty/directxtex/DirectXTexPMAlpha.cpp b/thirdparty/directxtex/DirectXTexPMAlpha.cpp
deleted file mode 100644
index 059af95..0000000
--- a/thirdparty/directxtex/DirectXTexPMAlpha.cpp
+++ /dev/null
@@ -1,344 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexPMAlpha.cpp
-//
-// DirectX Texture Library - Premultiplied alpha operations
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-
-namespace
-{
-    constexpr TEX_FILTER_FLAGS GetSRGBFlags(_In_ TEX_PMALPHA_FLAGS compress) noexcept
-    {
-        static_assert(TEX_FILTER_SRGB_IN == 0x1000000, "TEX_FILTER_SRGB flag values don't match TEX_FILTER_SRGB_MASK");
-        static_assert(static_cast<int>(TEX_PMALPHA_SRGB_IN) == static_cast<int>(TEX_FILTER_SRGB_IN), "TEX_PMALPHA_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_PMALPHA_SRGB_OUT) == static_cast<int>(TEX_FILTER_SRGB_OUT), "TEX_PMALPHA_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_PMALPHA_SRGB) == static_cast<int>(TEX_FILTER_SRGB), "TEX_PMALPHA_SRGB* should match TEX_FILTER_SRGB*");
-        return static_cast<TEX_FILTER_FLAGS>(compress & TEX_FILTER_SRGB_MASK);
-    }
-
-    //---------------------------------------------------------------------------------
-    // NonPremultiplied alpha -> Premultiplied alpha
-    HRESULT PremultiplyAlpha_(const Image& srcImage, const Image& destImage) noexcept
-    {
-        assert(srcImage.width == destImage.width);
-        assert(srcImage.height == destImage.height);
-
-        auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        const uint8_t *pSrc = srcImage.pixels;
-        uint8_t *pDest = destImage.pixels;
-        if (!pSrc || !pDest)
-            return E_POINTER;
-
-        for (size_t h = 0; h < srcImage.height; ++h)
-        {
-            if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
-                return E_FAIL;
-
-            XMVECTOR* ptr = scanline.get();
-            for (size_t w = 0; w < srcImage.width; ++w)
-            {
-                const XMVECTOR v = *ptr;
-                XMVECTOR alpha = XMVectorSplatW(*ptr);
-                alpha = XMVectorMultiply(v, alpha);
-                *(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
-            }
-
-            if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
-                return E_FAIL;
-
-            pSrc += srcImage.rowPitch;
-            pDest += destImage.rowPitch;
-        }
-
-        return S_OK;
-    }
-
-    HRESULT PremultiplyAlphaLinear(const Image& srcImage, TEX_PMALPHA_FLAGS flags, const Image& destImage) noexcept
-    {
-        assert(srcImage.width == destImage.width);
-        assert(srcImage.height == destImage.height);
-
-        static_assert(static_cast<int>(TEX_PMALPHA_SRGB_IN) == static_cast<int>(TEX_FILTER_SRGB_IN), "TEX_PMALHPA_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_PMALPHA_SRGB_OUT) == static_cast<int>(TEX_FILTER_SRGB_OUT), "TEX_PMALHPA_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_PMALPHA_SRGB) == static_cast<int>(TEX_FILTER_SRGB), "TEX_PMALHPA_SRGB* should match TEX_FILTER_SRGB*");
-        flags &= TEX_PMALPHA_SRGB;
-
-        auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        const uint8_t *pSrc = srcImage.pixels;
-        uint8_t *pDest = destImage.pixels;
-        if (!pSrc || !pDest)
-            return E_POINTER;
-
-        const TEX_FILTER_FLAGS filter = GetSRGBFlags(flags);
-
-        for (size_t h = 0; h < srcImage.height; ++h)
-        {
-            if (!LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter))
-                return E_FAIL;
-
-            XMVECTOR* ptr = scanline.get();
-            for (size_t w = 0; w < srcImage.width; ++w)
-            {
-                const XMVECTOR v = *ptr;
-                XMVECTOR alpha = XMVectorSplatW(*ptr);
-                alpha = XMVectorMultiply(v, alpha);
-                *(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
-            }
-
-            if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter))
-                return E_FAIL;
-
-            pSrc += srcImage.rowPitch;
-            pDest += destImage.rowPitch;
-        }
-
-        return S_OK;
-    }
-
-    //---------------------------------------------------------------------------------
-    // Premultiplied alpha -> NonPremultiplied alpha (a.k.a. Straight alpha)
-    HRESULT DemultiplyAlpha(const Image& srcImage, const Image& destImage) noexcept
-    {
-        assert(srcImage.width == destImage.width);
-        assert(srcImage.height == destImage.height);
-
-        auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        const uint8_t *pSrc = srcImage.pixels;
-        uint8_t *pDest = destImage.pixels;
-        if (!pSrc || !pDest)
-            return E_POINTER;
-
-        for (size_t h = 0; h < srcImage.height; ++h)
-        {
-            if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
-                return E_FAIL;
-
-            XMVECTOR* ptr = scanline.get();
-            for (size_t w = 0; w < srcImage.width; ++w)
-            {
-                const XMVECTOR v = *ptr;
-                XMVECTOR alpha = XMVectorSplatW(*ptr);
-                if (XMVectorGetX(alpha) > 0)
-                {
-                    alpha = XMVectorDivide(v, alpha);
-                }
-                *(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
-            }
-
-            if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
-                return E_FAIL;
-
-            pSrc += srcImage.rowPitch;
-            pDest += destImage.rowPitch;
-        }
-
-        return S_OK;
-    }
-
-    HRESULT DemultiplyAlphaLinear(const Image& srcImage, TEX_PMALPHA_FLAGS flags, const Image& destImage) noexcept
-    {
-        assert(srcImage.width == destImage.width);
-        assert(srcImage.height == destImage.height);
-
-        static_assert(static_cast<int>(TEX_PMALPHA_SRGB_IN) == static_cast<int>(TEX_FILTER_SRGB_IN), "TEX_PMALPHA_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_PMALPHA_SRGB_OUT) == static_cast<int>(TEX_FILTER_SRGB_OUT), "TEX_PMALPHA_SRGB* should match TEX_FILTER_SRGB*");
-        static_assert(static_cast<int>(TEX_PMALPHA_SRGB) == static_cast<int>(TEX_FILTER_SRGB), "TEX_PMALPHA_SRGB* should match TEX_FILTER_SRGB*");
-        flags &= TEX_PMALPHA_SRGB;
-
-        auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        const uint8_t *pSrc = srcImage.pixels;
-        uint8_t *pDest = destImage.pixels;
-        if (!pSrc || !pDest)
-            return E_POINTER;
-
-        const TEX_FILTER_FLAGS filter = GetSRGBFlags(flags);
-
-        for (size_t h = 0; h < srcImage.height; ++h)
-        {
-            if (!LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter))
-                return E_FAIL;
-
-            XMVECTOR* ptr = scanline.get();
-            for (size_t w = 0; w < srcImage.width; ++w)
-            {
-                const XMVECTOR v = *ptr;
-                XMVECTOR alpha = XMVectorSplatW(*ptr);
-                if (XMVectorGetX(alpha) > 0)
-                {
-                    alpha = XMVectorDivide(v, alpha);
-                }
-                *(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
-            }
-
-            if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter))
-                return E_FAIL;
-
-            pSrc += srcImage.rowPitch;
-            pDest += destImage.rowPitch;
-        }
-
-        return S_OK;
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Converts to/from a premultiplied alpha version of the texture
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::PremultiplyAlpha(
-    const Image& srcImage,
-    TEX_PMALPHA_FLAGS flags,
-    ScratchImage& image) noexcept
-{
-    if (!srcImage.pixels)
-        return E_POINTER;
-
-    if (IsCompressed(srcImage.format)
-        || IsPlanar(srcImage.format)
-        || IsPalettized(srcImage.format)
-        || IsTypeless(srcImage.format)
-        || !HasAlpha(srcImage.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if ((srcImage.width > UINT32_MAX) || (srcImage.height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    HRESULT hr = image.Initialize2D(srcImage.format, srcImage.width, srcImage.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *rimage = image.GetImage(0, 0, 0);
-    if (!rimage)
-    {
-        image.Release();
-        return E_POINTER;
-    }
-
-    if (flags & TEX_PMALPHA_REVERSE)
-    {
-        hr = (flags & TEX_PMALPHA_IGNORE_SRGB) ? DemultiplyAlpha(srcImage, *rimage) : DemultiplyAlphaLinear(srcImage, flags, *rimage);
-    }
-    else
-    {
-        hr = (flags & TEX_PMALPHA_IGNORE_SRGB) ? PremultiplyAlpha_(srcImage, *rimage) : PremultiplyAlphaLinear(srcImage, flags, *rimage);
-    }
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Converts to/from a premultiplied alpha version of the texture (complex)
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::PremultiplyAlpha(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    TEX_PMALPHA_FLAGS flags,
-    ScratchImage& result) noexcept
-{
-    if (!srcImages || !nimages)
-        return E_INVALIDARG;
-
-    if (IsCompressed(metadata.format)
-        || IsPlanar(metadata.format)
-        || IsPalettized(metadata.format)
-        || IsTypeless(metadata.format)
-        || !HasAlpha(metadata.format))
-        return HRESULT_E_NOT_SUPPORTED;
-
-    if ((metadata.width > UINT32_MAX) || (metadata.height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    if (metadata.IsPMAlpha() != ((flags & TEX_PMALPHA_REVERSE) != 0))
-        return E_FAIL;
-
-    TexMetadata mdata2 = metadata;
-    mdata2.SetAlphaMode((flags & TEX_PMALPHA_REVERSE) ? TEX_ALPHA_MODE_STRAIGHT : TEX_ALPHA_MODE_PREMULTIPLIED);
-    HRESULT hr = result.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages != result.GetImageCount())
-    {
-        result.Release();
-        return E_FAIL;
-    }
-
-    const Image* dest = result.GetImages();
-    if (!dest)
-    {
-        result.Release();
-        return E_POINTER;
-    }
-
-    for (size_t index = 0; index < nimages; ++index)
-    {
-        const Image& src = srcImages[index];
-        if (src.format != metadata.format)
-        {
-            result.Release();
-            return E_FAIL;
-        }
-
-        if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
-            return E_FAIL;
-
-        const Image& dst = dest[index];
-        assert(dst.format == metadata.format);
-
-        if (src.width != dst.width || src.height != dst.height)
-        {
-            result.Release();
-            return E_FAIL;
-        }
-
-        if (flags & TEX_PMALPHA_REVERSE)
-        {
-            hr = (flags & TEX_PMALPHA_IGNORE_SRGB) ? DemultiplyAlpha(src, dst) : DemultiplyAlphaLinear(src, flags, dst);
-        }
-        else
-        {
-            hr = (flags & TEX_PMALPHA_IGNORE_SRGB) ? PremultiplyAlpha_(src, dst) : PremultiplyAlphaLinear(src, flags, dst);
-        }
-        if (FAILED(hr))
-        {
-            result.Release();
-            return hr;
-        }
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexResize.cpp b/thirdparty/directxtex/DirectXTexResize.cpp
deleted file mode 100644
index 831235b..0000000
--- a/thirdparty/directxtex/DirectXTexResize.cpp
+++ /dev/null
@@ -1,1118 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexResize.cpp
-//
-// DirectX Texture Library - Image resizing operations
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#include "filters.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-using Microsoft::WRL::ComPtr;
-
-namespace
-{
-#ifdef _WIN32
-    //--- Do image resize using WIC ---
-    HRESULT PerformResizeUsingWIC(
-        const Image& srcImage,
-        TEX_FILTER_FLAGS filter,
-        const WICPixelFormatGUID& pfGUID,
-        const Image& destImage) noexcept
-    {
-        if (!srcImage.pixels || !destImage.pixels)
-            return E_POINTER;
-
-        assert(srcImage.format == destImage.format);
-
-        bool iswic2 = false;
-        auto pWIC = GetWICFactory(iswic2);
-        if (!pWIC)
-            return E_NOINTERFACE;
-
-        ComPtr<IWICComponentInfo> componentInfo;
-        HRESULT hr = pWIC->CreateComponentInfo(pfGUID, componentInfo.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        ComPtr<IWICPixelFormatInfo2> pixelFormatInfo;
-        hr = componentInfo.As(&pixelFormatInfo);
-        if (FAILED(hr))
-            return hr;
-
-        BOOL supportsTransparency = FALSE;
-        hr = pixelFormatInfo->SupportsTransparency(&supportsTransparency);
-        if (FAILED(hr))
-            return hr;
-
-        if (srcImage.rowPitch > UINT32_MAX || srcImage.slicePitch > UINT32_MAX
-            || destImage.rowPitch > UINT32_MAX || destImage.slicePitch > UINT32_MAX)
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-        ComPtr<IWICBitmap> source;
-        hr = pWIC->CreateBitmapFromMemory(static_cast<UINT>(srcImage.width), static_cast<UINT>(srcImage.height), pfGUID,
-            static_cast<UINT>(srcImage.rowPitch), static_cast<UINT>(srcImage.slicePitch),
-            srcImage.pixels, source.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        if ((filter & TEX_FILTER_SEPARATE_ALPHA) && supportsTransparency)
-        {
-            hr = ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), destImage.width, destImage.height, filter, &destImage);
-            if (FAILED(hr))
-                return hr;
-        }
-        else
-        {
-            ComPtr<IWICBitmapScaler> scaler;
-            hr = pWIC->CreateBitmapScaler(scaler.GetAddressOf());
-            if (FAILED(hr))
-                return hr;
-
-            hr = scaler->Initialize(source.Get(),
-                static_cast<UINT>(destImage.width), static_cast<UINT>(destImage.height),
-                GetWICInterp(filter));
-            if (FAILED(hr))
-                return hr;
-
-            WICPixelFormatGUID pfScaler;
-            hr = scaler->GetPixelFormat(&pfScaler);
-            if (FAILED(hr))
-                return hr;
-
-            if (memcmp(&pfScaler, &pfGUID, sizeof(WICPixelFormatGUID)) == 0)
-            {
-                hr = scaler->CopyPixels(nullptr, static_cast<UINT>(destImage.rowPitch), static_cast<UINT>(destImage.slicePitch), destImage.pixels);
-                if (FAILED(hr))
-                    return hr;
-            }
-            else
-            {
-                // The WIC bitmap scaler is free to return a different pixel format than the source image, so here we
-                // convert it back
-                ComPtr<IWICFormatConverter> FC;
-                hr = pWIC->CreateFormatConverter(FC.GetAddressOf());
-                if (FAILED(hr))
-                    return hr;
-
-                BOOL canConvert = FALSE;
-                hr = FC->CanConvert(pfScaler, pfGUID, &canConvert);
-                if (FAILED(hr) || !canConvert)
-                {
-                    return E_UNEXPECTED;
-                }
-
-                hr = FC->Initialize(scaler.Get(), pfGUID, GetWICDither(filter), nullptr,
-                    0, WICBitmapPaletteTypeMedianCut);
-                if (FAILED(hr))
-                    return hr;
-
-                hr = FC->CopyPixels(nullptr, static_cast<UINT>(destImage.rowPitch), static_cast<UINT>(destImage.slicePitch), destImage.pixels);
-                if (FAILED(hr))
-                    return hr;
-            }
-        }
-
-        return S_OK;
-    }
-
-
-    //--- Do conversion, resize using WIC, conversion cycle ---
-    HRESULT PerformResizeViaF32(
-        const Image& srcImage,
-        TEX_FILTER_FLAGS filter,
-        const Image& destImage) noexcept
-    {
-        if (!srcImage.pixels || !destImage.pixels)
-            return E_POINTER;
-
-        assert(srcImage.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
-        assert(srcImage.format == destImage.format);
-
-        ScratchImage temp;
-        HRESULT hr = ConvertToR32G32B32A32(srcImage, temp);
-        if (FAILED(hr))
-            return hr;
-
-        const Image *tsrc = temp.GetImage(0, 0, 0);
-        if (!tsrc)
-            return E_POINTER;
-
-        ScratchImage rtemp;
-        hr = rtemp.Initialize2D(DXGI_FORMAT_R32G32B32A32_FLOAT, destImage.width, destImage.height, 1, 1);
-        if (FAILED(hr))
-            return hr;
-
-        const Image *tdest = rtemp.GetImage(0, 0, 0);
-        if (!tdest)
-            return E_POINTER;
-
-        hr = PerformResizeUsingWIC(*tsrc, filter, GUID_WICPixelFormat128bppRGBAFloat, *tdest);
-        if (FAILED(hr))
-            return hr;
-
-        temp.Release();
-
-        hr = ConvertFromR32G32B32A32(*tdest, destImage);
-        if (FAILED(hr))
-            return hr;
-
-        return S_OK;
-    }
-
-
-    //--- determine when to use WIC vs. non-WIC paths ---
-    bool UseWICFiltering(_In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS filter) noexcept
-    {
-        if (filter & TEX_FILTER_FORCE_NON_WIC)
-        {
-            // Explicit flag indicates use of non-WIC code paths
-            return false;
-        }
-
-        if (filter & TEX_FILTER_FORCE_WIC)
-        {
-            // Explicit flag to use WIC code paths, skips all the case checks below
-            return true;
-        }
-
-        if (IsSRGB(format) || (filter & TEX_FILTER_SRGB))
-        {
-            // Use non-WIC code paths for sRGB correct filtering
-            return false;
-        }
-
-    #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
-        if (format == DXGI_FORMAT_R16G16B16A16_FLOAT
-            || format == DXGI_FORMAT_R16_FLOAT)
-        {
-            // Use non-WIC code paths as these conversions are not supported by Xbox version of WIC
-            return false;
-        }
-    #endif
-
-        static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK");
-
-        switch (filter & TEX_FILTER_MODE_MASK)
-        {
-        case TEX_FILTER_LINEAR:
-            if (filter & TEX_FILTER_WRAP)
-            {
-                // WIC only supports 'clamp' semantics (MIRROR is equivalent to clamp for linear)
-                return false;
-            }
-
-            if (BitsPerColor(format) > 8)
-            {
-                // Avoid the WIC bitmap scaler when doing Linear filtering of XR/HDR formats
-                return false;
-            }
-            break;
-
-        case TEX_FILTER_CUBIC:
-            if (filter & (TEX_FILTER_WRAP | TEX_FILTER_MIRROR))
-            {
-                // WIC only supports 'clamp' semantics
-                return false;
-            }
-
-            if (BitsPerColor(format) > 8)
-            {
-                // Avoid the WIC bitmap scaler when doing Cubic filtering of XR/HDR formats
-                return false;
-            }
-            break;
-
-        case TEX_FILTER_TRIANGLE:
-            // WIC does not implement this filter
-            return false;
-
-        default:
-            if (BitsPerColor(format) > 8)
-            {
-                // Avoid the WIC bitmap scaler when doing filtering of XR/HDR formats
-                return false;
-            }
-            break;
-        }
-
-        return true;
-    }
-#endif // WIN32
-
-    //-------------------------------------------------------------------------------------
-    // Resize custom filters
-    //-------------------------------------------------------------------------------------
-
-    //--- Point Filter ---
-    HRESULT ResizePointFilter(const Image& srcImage, const Image& destImage) noexcept
-    {
-        assert(srcImage.pixels && destImage.pixels);
-        assert(srcImage.format == destImage.format);
-
-        // Allocate temporary space (2 scanlines)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(srcImage.width) + destImage.width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* row = target + destImage.width;
-
-    #ifdef _DEBUG
-        memset(row, 0xCD, sizeof(XMVECTOR)*srcImage.width);
-    #endif
-
-        const uint8_t* pSrc = srcImage.pixels;
-        uint8_t* pDest = destImage.pixels;
-
-        const size_t rowPitch = srcImage.rowPitch;
-
-        const size_t xinc = (srcImage.width << 16) / destImage.width;
-        const size_t yinc = (srcImage.height << 16) / destImage.height;
-
-        size_t lasty = size_t(-1);
-
-        size_t sy = 0;
-        for (size_t y = 0; y < destImage.height; ++y)
-        {
-            if ((lasty ^ sy) >> 16)
-            {
-                if (!LoadScanline(row, srcImage.width, pSrc + (rowPitch * (sy >> 16)), rowPitch, srcImage.format))
-                    return E_FAIL;
-                lasty = sy;
-            }
-
-            size_t sx = 0;
-            for (size_t x = 0; x < destImage.width; ++x)
-            {
-                target[x] = row[sx >> 16];
-                sx += xinc;
-            }
-
-            if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, target, destImage.width))
-                return E_FAIL;
-            pDest += destImage.rowPitch;
-
-            sy += yinc;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- Box Filter ---
-    HRESULT ResizeBoxFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        assert(srcImage.pixels && destImage.pixels);
-        assert(srcImage.format == destImage.format);
-
-        if (((destImage.width << 1) != srcImage.width) || ((destImage.height << 1) != srcImage.height))
-            return E_FAIL;
-
-        // Allocate temporary space (3 scanlines)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(srcImage.width) * 2 + destImage.width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* urow0 = target + destImage.width;
-        XMVECTOR* urow1 = urow0 + srcImage.width;
-
-    #ifdef _DEBUG
-        memset(urow0, 0xCD, sizeof(XMVECTOR)*srcImage.width);
-        memset(urow1, 0xDD, sizeof(XMVECTOR)*srcImage.width);
-    #endif
-
-        const XMVECTOR* urow2 = urow0 + 1;
-        const XMVECTOR* urow3 = urow1 + 1;
-
-        const uint8_t* pSrc = srcImage.pixels;
-        uint8_t* pDest = destImage.pixels;
-
-        const size_t rowPitch = srcImage.rowPitch;
-
-        for (size_t y = 0; y < destImage.height; ++y)
-        {
-            if (!LoadScanlineLinear(urow0, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
-                return E_FAIL;
-            pSrc += rowPitch;
-
-            if (urow0 != urow1)
-            {
-                if (!LoadScanlineLinear(urow1, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
-                    return E_FAIL;
-                pSrc += rowPitch;
-            }
-
-            for (size_t x = 0; x < destImage.width; ++x)
-            {
-                const size_t x2 = x << 1;
-
-                AVERAGE4(target[x], urow0[x2], urow1[x2], urow2[x2], urow3[x2])
-            }
-
-            if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
-                return E_FAIL;
-            pDest += destImage.rowPitch;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- Linear Filter ---
-    HRESULT ResizeLinearFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        assert(srcImage.pixels && destImage.pixels);
-        assert(srcImage.format == destImage.format);
-
-        // Allocate temporary space (3 scanlines, plus X and Y filters)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(srcImage.width) * 2 + destImage.width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        std::unique_ptr<LinearFilter[]> lf(new (std::nothrow) LinearFilter[destImage.width + destImage.height]);
-        if (!lf)
-            return E_OUTOFMEMORY;
-
-        LinearFilter* lfX = lf.get();
-        LinearFilter* lfY = lf.get() + destImage.width;
-
-        CreateLinearFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
-        CreateLinearFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* row0 = target + destImage.width;
-        XMVECTOR* row1 = row0 + srcImage.width;
-
-    #ifdef _DEBUG
-        memset(row0, 0xCD, sizeof(XMVECTOR)*srcImage.width);
-        memset(row1, 0xDD, sizeof(XMVECTOR)*srcImage.width);
-    #endif
-
-        const uint8_t* pSrc = srcImage.pixels;
-        uint8_t* pDest = destImage.pixels;
-
-        const size_t rowPitch = srcImage.rowPitch;
-
-        size_t u0 = size_t(-1);
-        size_t u1 = size_t(-1);
-
-        for (size_t y = 0; y < destImage.height; ++y)
-        {
-            auto const& toY = lfY[y];
-
-            if (toY.u0 != u0)
-            {
-                if (toY.u0 != u1)
-                {
-                    u0 = toY.u0;
-
-                    if (!LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter))
-                        return E_FAIL;
-                }
-                else
-                {
-                    u0 = u1;
-                    u1 = size_t(-1);
-
-                    std::swap(row0, row1);
-                }
-            }
-
-            if (toY.u1 != u1)
-            {
-                u1 = toY.u1;
-
-                if (!LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter))
-                    return E_FAIL;
-            }
-
-            for (size_t x = 0; x < destImage.width; ++x)
-            {
-                auto const& toX = lfX[x];
-
-                BILINEAR_INTERPOLATE(target[x], toX, toY, row0, row1)
-            }
-
-            if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
-                return E_FAIL;
-            pDest += destImage.rowPitch;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- Cubic Filter ---
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wextra-semi-stmt"
-#endif
-
-    HRESULT ResizeCubicFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        assert(srcImage.pixels && destImage.pixels);
-        assert(srcImage.format == destImage.format);
-
-        // Allocate temporary space (5 scanlines, plus X and Y filters)
-        auto scanline = make_AlignedArrayXMVECTOR(uint64_t(srcImage.width) * 4 + destImage.width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        std::unique_ptr<CubicFilter[]> cf(new (std::nothrow) CubicFilter[destImage.width + destImage.height]);
-        if (!cf)
-            return E_OUTOFMEMORY;
-
-        CubicFilter* cfX = cf.get();
-        CubicFilter* cfY = cf.get() + destImage.width;
-
-        CreateCubicFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
-        CreateCubicFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
-
-        XMVECTOR* target = scanline.get();
-
-        XMVECTOR* row0 = target + destImage.width;
-        XMVECTOR* row1 = row0 + srcImage.width;
-        XMVECTOR* row2 = row0 + srcImage.width * 2;
-        XMVECTOR* row3 = row0 + srcImage.width * 3;
-
-    #ifdef _DEBUG
-        memset(row0, 0xCD, sizeof(XMVECTOR)*srcImage.width);
-        memset(row1, 0xDD, sizeof(XMVECTOR)*srcImage.width);
-        memset(row2, 0xED, sizeof(XMVECTOR)*srcImage.width);
-        memset(row3, 0xFD, sizeof(XMVECTOR)*srcImage.width);
-    #endif
-
-        const uint8_t* pSrc = srcImage.pixels;
-        uint8_t* pDest = destImage.pixels;
-
-        const size_t rowPitch = srcImage.rowPitch;
-
-        size_t u0 = size_t(-1);
-        size_t u1 = size_t(-1);
-        size_t u2 = size_t(-1);
-        size_t u3 = size_t(-1);
-
-        for (size_t y = 0; y < destImage.height; ++y)
-        {
-            auto const& toY = cfY[y];
-
-            // Scanline 1
-            if (toY.u0 != u0)
-            {
-                if (toY.u0 != u1 && toY.u0 != u2 && toY.u0 != u3)
-                {
-                    u0 = toY.u0;
-
-                    if (!LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter))
-                        return E_FAIL;
-                }
-                else if (toY.u0 == u1)
-                {
-                    u0 = u1;
-                    u1 = size_t(-1);
-
-                    std::swap(row0, row1);
-                }
-                else if (toY.u0 == u2)
-                {
-                    u0 = u2;
-                    u2 = size_t(-1);
-
-                    std::swap(row0, row2);
-                }
-                else if (toY.u0 == u3)
-                {
-                    u0 = u3;
-                    u3 = size_t(-1);
-
-                    std::swap(row0, row3);
-                }
-            }
-
-            // Scanline 2
-            if (toY.u1 != u1)
-            {
-                if (toY.u1 != u2 && toY.u1 != u3)
-                {
-                    u1 = toY.u1;
-
-                    if (!LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter))
-                        return E_FAIL;
-                }
-                else if (toY.u1 == u2)
-                {
-                    u1 = u2;
-                    u2 = size_t(-1);
-
-                    std::swap(row1, row2);
-                }
-                else if (toY.u1 == u3)
-                {
-                    u1 = u3;
-                    u3 = size_t(-1);
-
-                    std::swap(row1, row3);
-                }
-            }
-
-            // Scanline 3
-            if (toY.u2 != u2)
-            {
-                if (toY.u2 != u3)
-                {
-                    u2 = toY.u2;
-
-                    if (!LoadScanlineLinear(row2, srcImage.width, pSrc + (rowPitch * u2), rowPitch, srcImage.format, filter))
-                        return E_FAIL;
-                }
-                else
-                {
-                    u2 = u3;
-                    u3 = size_t(-1);
-
-                    std::swap(row2, row3);
-                }
-            }
-
-            // Scanline 4
-            if (toY.u3 != u3)
-            {
-                u3 = toY.u3;
-
-                if (!LoadScanlineLinear(row3, srcImage.width, pSrc + (rowPitch * u3), rowPitch, srcImage.format, filter))
-                    return E_FAIL;
-            }
-
-            for (size_t x = 0; x < destImage.width; ++x)
-            {
-                auto const& toX = cfX[x];
-
-                XMVECTOR C0, C1, C2, C3;
-
-                CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3]);
-                CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3]);
-                CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3]);
-                CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3]);
-
-                CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3);
-            }
-
-            if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
-                return E_FAIL;
-            pDest += destImage.rowPitch;
-        }
-
-        return S_OK;
-    }
-
-
-    //--- Triangle Filter ---
-    HRESULT ResizeTriangleFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
-    {
-        using namespace DirectX::Filters;
-
-        assert(srcImage.pixels && destImage.pixels);
-        assert(srcImage.format == destImage.format);
-
-        // Allocate initial temporary space (1 scanline, accumulation rows, plus X and Y filters)
-        auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
-        if (!scanline)
-            return E_OUTOFMEMORY;
-
-        std::unique_ptr<TriangleRow[]> rowActive(new (std::nothrow) TriangleRow[destImage.height]);
-        if (!rowActive)
-            return E_OUTOFMEMORY;
-
-        TriangleRow * rowFree = nullptr;
-
-        std::unique_ptr<Filter> tfX;
-        HRESULT hr = CreateTriangleFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
-        if (FAILED(hr))
-            return hr;
-
-        std::unique_ptr<Filter> tfY;
-        hr = CreateTriangleFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
-        if (FAILED(hr))
-            return hr;
-
-        XMVECTOR* row = scanline.get();
-
-    #ifdef _DEBUG
-        memset(row, 0xCD, sizeof(XMVECTOR)*srcImage.width);
-    #endif
-
-        auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes);
-        auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes);
-
-        // Count times rows get written
-        for (FilterFrom* yFrom = tfY->from; yFrom < yFromEnd; )
-        {
-            for (size_t j = 0; j < yFrom->count; ++j)
-            {
-                const size_t v = yFrom->to[j].u;
-                assert(v < destImage.height);
-                ++rowActive[v].remaining;
-            }
-
-            yFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(yFrom) + yFrom->sizeInBytes);
-        }
-
-        // Filter image
-        const uint8_t* pSrc = srcImage.pixels;
-        const size_t rowPitch = srcImage.rowPitch;
-        const uint8_t* pEndSrc = pSrc + rowPitch * srcImage.height;
-
-        uint8_t* pDest = destImage.pixels;
-
-        for (FilterFrom* yFrom = tfY->from; yFrom < yFromEnd; )
-        {
-            // Create accumulation rows as needed
-            for (size_t j = 0; j < yFrom->count; ++j)
-            {
-                const size_t v = yFrom->to[j].u;
-                assert(v < destImage.height);
-                TriangleRow* rowAcc = &rowActive[v];
-
-                if (!rowAcc->scanline)
-                {
-                    if (rowFree)
-                    {
-                        // Steal and reuse scanline from 'free row' list
-                        assert(rowFree->scanline != nullptr);
-                        rowAcc->scanline.reset(rowFree->scanline.release());
-                        rowFree = rowFree->next;
-                    }
-                    else
-                    {
-                        auto nscanline = make_AlignedArrayXMVECTOR(destImage.width);
-                        if (!nscanline)
-                            return E_OUTOFMEMORY;
-                        rowAcc->scanline.swap(nscanline);
-                    }
-
-                    memset(rowAcc->scanline.get(), 0, sizeof(XMVECTOR) * destImage.width);
-                }
-            }
-
-            // Load source scanline
-            if ((pSrc + rowPitch) > pEndSrc)
-                return E_FAIL;
-
-            if (!LoadScanlineLinear(row, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
-                return E_FAIL;
-
-            pSrc += rowPitch;
-
-            // Process row
-            size_t x = 0;
-            for (FilterFrom* xFrom = tfX->from; xFrom < xFromEnd; ++x)
-            {
-                for (size_t j = 0; j < yFrom->count; ++j)
-                {
-                    const size_t v = yFrom->to[j].u;
-                    assert(v < destImage.height);
-                    const float yweight = yFrom->to[j].weight;
-
-                    XMVECTOR* accPtr = rowActive[v].scanline.get();
-                    if (!accPtr)
-                        return E_POINTER;
-
-                    for (size_t k = 0; k < xFrom->count; ++k)
-                    {
-                        size_t u = xFrom->to[k].u;
-                        assert(u < destImage.width);
-
-                        const XMVECTOR weight = XMVectorReplicate(yweight * xFrom->to[k].weight);
-
-                        assert(x < srcImage.width);
-                        accPtr[u] = XMVectorMultiplyAdd(row[x], weight, accPtr[u]);
-                    }
-                }
-
-                xFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(xFrom) + xFrom->sizeInBytes);
-            }
-
-            // Write completed accumulation rows
-            for (size_t j = 0; j < yFrom->count; ++j)
-            {
-                size_t v = yFrom->to[j].u;
-                assert(v < destImage.height);
-                TriangleRow* rowAcc = &rowActive[v];
-
-                assert(rowAcc->remaining > 0);
-                --rowAcc->remaining;
-
-                if (!rowAcc->remaining)
-                {
-                    XMVECTOR* pAccSrc = rowAcc->scanline.get();
-                    if (!pAccSrc)
-                        return E_POINTER;
-
-                    switch (destImage.format)
-                    {
-                    case DXGI_FORMAT_R10G10B10A2_UNORM:
-                    case DXGI_FORMAT_R10G10B10A2_UINT:
-                        {
-                            // Need to slightly bias results for floating-point error accumulation which can
-                            // be visible with harshly quantized values
-                            static const XMVECTORF32 Bias = { { { 0.f, 0.f, 0.f, 0.1f } } };
-
-                            XMVECTOR* ptr = pAccSrc;
-                            for (size_t i = 0; i < destImage.width; ++i, ++ptr)
-                            {
-                                *ptr = XMVectorAdd(*ptr, Bias);
-                            }
-                        }
-                        break;
-
-                    default:
-                        break;
-                    }
-
-                    // This performs any required clamping
-                    if (!StoreScanlineLinear(pDest + (destImage.rowPitch * v), destImage.rowPitch, destImage.format, pAccSrc, destImage.width, filter))
-                        return E_FAIL;
-
-                    // Put row on freelist to reuse it's allocated scanline
-                    rowAcc->next = rowFree;
-                    rowFree = rowAcc;
-                }
-            }
-
-            yFrom = reinterpret_cast<FilterFrom*>(reinterpret_cast<uint8_t*>(yFrom) + yFrom->sizeInBytes);
-        }
-
-        return S_OK;
-    }
-
-
-    //--- Custom filter resize ---
-    HRESULT PerformResizeUsingCustomFilters(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
-    {
-        if (!srcImage.pixels || !destImage.pixels)
-            return E_POINTER;
-
-        static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK");
-
-        unsigned long filter_select = filter & TEX_FILTER_MODE_MASK;
-        if (!filter_select)
-        {
-            // Default filter choice
-            filter_select = (((destImage.width << 1) == srcImage.width) && ((destImage.height << 1) == srcImage.height))
-                ? TEX_FILTER_BOX : TEX_FILTER_LINEAR;
-        }
-
-        switch (filter_select)
-        {
-        case TEX_FILTER_POINT:
-            return ResizePointFilter(srcImage, destImage);
-
-        case TEX_FILTER_BOX:
-            return ResizeBoxFilter(srcImage, filter, destImage);
-
-        case TEX_FILTER_LINEAR:
-            return ResizeLinearFilter(srcImage, filter, destImage);
-
-        case TEX_FILTER_CUBIC:
-            return ResizeCubicFilter(srcImage, filter, destImage);
-
-        case TEX_FILTER_TRIANGLE:
-            return ResizeTriangleFilter(srcImage, filter, destImage);
-
-        default:
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Resize image
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::Resize(
-    const Image& srcImage,
-    size_t width,
-    size_t height,
-    TEX_FILTER_FLAGS filter,
-    ScratchImage& image) noexcept
-{
-    if (width == 0 || height == 0)
-        return E_INVALIDARG;
-
-    if ((srcImage.width > UINT32_MAX) || (srcImage.height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    if ((width > UINT32_MAX) || (height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    if (!srcImage.pixels)
-        return E_POINTER;
-
-    if (IsCompressed(srcImage.format))
-    {
-        // We don't support resizing compressed images
-        return HRESULT_E_NOT_SUPPORTED;
-    }
-
-#ifdef _WIN32
-    bool usewic = UseWICFiltering(srcImage.format, filter);
-
-    WICPixelFormatGUID pfGUID = {};
-    const bool wicpf = (usewic) ? DXGIToWIC(srcImage.format, pfGUID, true) : false;
-
-    if (usewic && !wicpf)
-    {
-        // Check to see if the source and/or result size is too big for WIC
-        const uint64_t expandedSize = uint64_t(width) * uint64_t(height) * sizeof(float) * 4;
-        const uint64_t expandedSize2 = uint64_t(srcImage.width) * uint64_t(srcImage.height) * sizeof(float) * 4;
-        if (expandedSize > UINT32_MAX || expandedSize2 > UINT32_MAX)
-        {
-            if (filter & TEX_FILTER_FORCE_WIC)
-                return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-            usewic = false;
-        }
-    }
-#endif // WIN32
-
-    HRESULT hr = image.Initialize2D(srcImage.format, width, height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    const Image *rimage = image.GetImage(0, 0, 0);
-    if (!rimage)
-        return E_POINTER;
-
-#ifdef _WIN32
-    if (usewic)
-    {
-        if (wicpf)
-        {
-            // Case 1: Source format is supported by Windows Imaging Component
-            hr = PerformResizeUsingWIC(srcImage, filter, pfGUID, *rimage);
-        }
-        else
-        {
-            // Case 2: Source format is not supported by WIC, so we have to convert, resize, and convert back
-            hr = PerformResizeViaF32(srcImage, filter, *rimage);
-        }
-    }
-    else
-    #endif
-    {
-        // Case 3: not using WIC resizing
-        hr = PerformResizeUsingCustomFilters(srcImage, filter, *rimage);
-    }
-
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Resize image (complex)
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::Resize(
-    const Image* srcImages,
-    size_t nimages,
-    const TexMetadata& metadata,
-    size_t width,
-    size_t height,
-    TEX_FILTER_FLAGS filter,
-    ScratchImage& result) noexcept
-{
-    if (!srcImages || !nimages || width == 0 || height == 0)
-        return E_INVALIDARG;
-
-    if ((width > UINT32_MAX) || (height > UINT32_MAX))
-        return E_INVALIDARG;
-
-    TexMetadata mdata2 = metadata;
-    mdata2.width = width;
-    mdata2.height = height;
-    mdata2.mipLevels = 1;
-    HRESULT hr = result.Initialize(mdata2);
-    if (FAILED(hr))
-        return hr;
-
-#ifdef _WIN32
-    bool usewic = !metadata.IsPMAlpha() && UseWICFiltering(metadata.format, filter);
-
-    WICPixelFormatGUID pfGUID = {};
-    const bool wicpf = (usewic) ? DXGIToWIC(metadata.format, pfGUID, true) : false;
-
-    if (usewic && !wicpf)
-    {
-        // Check to see if the source and/or result size is too big for WIC
-        const uint64_t expandedSize = uint64_t(width) * uint64_t(height) * sizeof(float) * 4;
-        const uint64_t expandedSize2 = uint64_t(metadata.width) * uint64_t(metadata.height) * sizeof(float) * 4;
-        if (expandedSize > UINT32_MAX || expandedSize2 > UINT32_MAX)
-        {
-            if (filter & TEX_FILTER_FORCE_WIC)
-                return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-            usewic = false;
-        }
-    }
-#endif
-
-    switch (metadata.dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-    case TEX_DIMENSION_TEXTURE2D:
-        assert(metadata.depth == 1);
-
-        for (size_t item = 0; item < metadata.arraySize; ++item)
-        {
-            const size_t srcIndex = metadata.ComputeIndex(0, item, 0);
-            if (srcIndex >= nimages)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            const Image* srcimg = &srcImages[srcIndex];
-            const Image* destimg = result.GetImage(0, item, 0);
-            if (!srcimg || !destimg)
-            {
-                result.Release();
-                return E_POINTER;
-            }
-
-            if (srcimg->format != metadata.format)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            if ((srcimg->width > UINT32_MAX) || (srcimg->height > UINT32_MAX))
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-        #ifdef _WIN32
-            if (usewic)
-            {
-                if (wicpf)
-                {
-                    // Case 1: Source format is supported by Windows Imaging Component
-                    hr = PerformResizeUsingWIC(*srcimg, filter, pfGUID, *destimg);
-                }
-                else
-                {
-                    // Case 2: Source format is not supported by WIC, so we have to convert, resize, and convert back
-                    hr = PerformResizeViaF32(*srcimg, filter, *destimg);
-                }
-            }
-            else
-            #endif
-            {
-                // Case 3: not using WIC resizing
-                hr = PerformResizeUsingCustomFilters(*srcimg, filter, *destimg);
-            }
-
-            if (FAILED(hr))
-            {
-                result.Release();
-                return hr;
-            }
-        }
-        break;
-
-    case TEX_DIMENSION_TEXTURE3D:
-        assert(metadata.arraySize == 1);
-
-        for (size_t slice = 0; slice < metadata.depth; ++slice)
-        {
-            const size_t srcIndex = metadata.ComputeIndex(0, 0, slice);
-            if (srcIndex >= nimages)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            const Image* srcimg = &srcImages[srcIndex];
-            const Image* destimg = result.GetImage(0, 0, slice);
-            if (!srcimg || !destimg)
-            {
-                result.Release();
-                return E_POINTER;
-            }
-
-            if (srcimg->format != metadata.format)
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-            if ((srcimg->width > UINT32_MAX) || (srcimg->height > UINT32_MAX))
-            {
-                result.Release();
-                return E_FAIL;
-            }
-
-        #ifdef _WIN32
-            if (usewic)
-            {
-                if (wicpf)
-                {
-                    // Case 1: Source format is supported by Windows Imaging Component
-                    hr = PerformResizeUsingWIC(*srcimg, filter, pfGUID, *destimg);
-                }
-                else
-                {
-                    // Case 2: Source format is not supported by WIC, so we have to convert, resize, and convert back
-                    hr = PerformResizeViaF32(*srcimg, filter, *destimg);
-                }
-            }
-            else
-            #endif
-            {
-                // Case 3: not using WIC resizing
-                hr = PerformResizeUsingCustomFilters(*srcimg, filter, *destimg);
-            }
-
-            if (FAILED(hr))
-            {
-                result.Release();
-                return hr;
-            }
-        }
-        break;
-
-    default:
-        result.Release();
-        return E_FAIL;
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexTGA.cpp b/thirdparty/directxtex/DirectXTexTGA.cpp
deleted file mode 100644
index 025ff90..0000000
--- a/thirdparty/directxtex/DirectXTexTGA.cpp
+++ /dev/null
@@ -1,2524 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexTGA.cpp
-//
-// DirectX Texture Library - Targa Truevision (TGA) file format reader/writer
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-//
-// The implementation here has the following limitations:
-//      * Does not support files that contain color maps (these are rare in practice)
-//      * Interleaved files are not supported (deprecated aspect of TGA format)
-//      * Only supports 8-bit grayscale; 16-, 24-, and 32-bit truecolor images RLE or uncompressed
-//        plus 24-bit color-mapped uncompressed images
-//      * Always writes uncompressed files (i.e. can read RLE compression, but does not write it)
-//
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-
-namespace
-{
-    constexpr float GAMMA_EPSILON = 0.01f;
-
-    const char g_Signature[] = "TRUEVISION-XFILE.";
-        // This is the official footer signature for the TGA 2.0 file format.
-
-    enum TGAImageType
-    {
-        TGA_NO_IMAGE = 0,
-        TGA_COLOR_MAPPED = 1,
-        TGA_TRUECOLOR = 2,
-        TGA_BLACK_AND_WHITE = 3,
-        TGA_COLOR_MAPPED_RLE = 9,
-        TGA_TRUECOLOR_RLE = 10,
-        TGA_BLACK_AND_WHITE_RLE = 11,
-    };
-
-    enum TGADescriptorFlags
-    {
-        TGA_FLAGS_INVERTX = 0x10,
-        TGA_FLAGS_INVERTY = 0x20,
-        TGA_FLAGS_INTERLEAVED_2WAY = 0x40, // Deprecated
-        TGA_FLAGS_INTERLEAVED_4WAY = 0x80, // Deprecated
-    };
-
-    enum TGAAttributesType : uint8_t
-    {
-        TGA_ATTRIBUTE_NONE = 0,             // 0: no alpha data included
-        TGA_ATTRIBUTE_IGNORED = 1,          // 1: undefined data, can be ignored
-        TGA_ATTRIBUTE_UNDEFINED = 2,        // 2: uedefined data, should be retained
-        TGA_ATTRIBUTE_ALPHA = 3,            // 3: useful alpha channel data
-        TGA_ATTRIBUTE_PREMULTIPLIED = 4,    // 4: pre-multiplied alpha
-    };
-
-#pragma pack(push,1)
-    struct TGA_HEADER
-    {
-        uint8_t     bIDLength;
-        uint8_t     bColorMapType;
-        uint8_t     bImageType;
-        uint16_t    wColorMapFirst;
-        uint16_t    wColorMapLength;
-        uint8_t     bColorMapSize;
-        uint16_t    wXOrigin;
-        uint16_t    wYOrigin;
-        uint16_t    wWidth;
-        uint16_t    wHeight;
-        uint8_t     bBitsPerPixel;
-        uint8_t     bDescriptor;
-    };
-
-    static_assert(sizeof(TGA_HEADER) == 18, "TGA 2.0 size mismatch");
-
-    constexpr size_t TGA_HEADER_LEN = 18;
-
-    struct TGA_FOOTER
-    {
-        uint32_t    dwExtensionOffset;
-        uint32_t    dwDeveloperOffset;
-        char        Signature[18];
-    };
-
-    static_assert(sizeof(TGA_FOOTER) == 26, "TGA 2.0 size mismatch");
-
-    struct TGA_EXTENSION
-    {
-        uint16_t    wSize;
-        char        szAuthorName[41];
-        char        szAuthorComment[324];
-        uint16_t    wStampMonth;
-        uint16_t    wStampDay;
-        uint16_t    wStampYear;
-        uint16_t    wStampHour;
-        uint16_t    wStampMinute;
-        uint16_t    wStampSecond;
-        char        szJobName[41];
-        uint16_t    wJobHour;
-        uint16_t    wJobMinute;
-        uint16_t    wJobSecond;
-        char        szSoftwareId[41];
-        uint16_t    wVersionNumber;
-        uint8_t     bVersionLetter;
-        uint32_t    dwKeyColor;
-        uint16_t    wPixelNumerator;
-        uint16_t    wPixelDenominator;
-        uint16_t    wGammaNumerator;
-        uint16_t    wGammaDenominator;
-        uint32_t    dwColorOffset;
-        uint32_t    dwStampOffset;
-        uint32_t    dwScanOffset;
-        uint8_t     bAttributesType;
-    };
-
-    static_assert(sizeof(TGA_EXTENSION) == 495, "TGA 2.0 size mismatch");
-
-#pragma pack(pop)
-
-    enum CONVERSION_FLAGS
-    {
-        CONV_FLAGS_NONE = 0x0,
-        CONV_FLAGS_EXPAND = 0x1,        // Conversion requires expanded pixel size
-        CONV_FLAGS_INVERTX = 0x2,       // If set, scanlines are right-to-left
-        CONV_FLAGS_INVERTY = 0x4,       // If set, scanlines are top-to-bottom
-        CONV_FLAGS_RLE = 0x8,           // Source data is RLE compressed
-        CONV_FLAGS_PALETTED = 0x10,     // Source data is paletted
-
-        CONV_FLAGS_SWIZZLE = 0x10000,   // Swizzle BGR<->RGB data
-        CONV_FLAGS_888 = 0x20000,       // 24bpp format
-    };
-
-
-    //-------------------------------------------------------------------------------------
-    // Decodes TGA header
-    //-------------------------------------------------------------------------------------
-    HRESULT DecodeTGAHeader(
-        _In_reads_bytes_(size) const void* pSource,
-        size_t size,
-        TGA_FLAGS flags,
-        _Out_ TexMetadata& metadata,
-        size_t& offset,
-        _Inout_opt_ uint32_t* convFlags) noexcept
-    {
-        if (!pSource)
-            return E_INVALIDARG;
-
-        memset(&metadata, 0, sizeof(TexMetadata));
-
-        if (size < TGA_HEADER_LEN)
-        {
-            return HRESULT_E_INVALID_DATA;
-        }
-
-        auto pHeader = static_cast<const TGA_HEADER*>(pSource);
-
-        if (pHeader->bDescriptor & (TGA_FLAGS_INTERLEAVED_2WAY | TGA_FLAGS_INTERLEAVED_4WAY))
-        {
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        if (!pHeader->wWidth || !pHeader->wHeight)
-        {
-            // These are uint16 values so are already bounded by UINT16_MAX.
-            return HRESULT_E_INVALID_DATA;
-        }
-
-        switch (pHeader->bImageType)
-        {
-        case TGA_NO_IMAGE:
-        case TGA_COLOR_MAPPED_RLE:
-            return HRESULT_E_NOT_SUPPORTED;
-
-        case TGA_COLOR_MAPPED:
-            if (pHeader->bColorMapType != 1
-                || pHeader->wColorMapLength == 0
-                || pHeader->bBitsPerPixel != 8)
-            {
-                return HRESULT_E_NOT_SUPPORTED;
-            }
-
-            switch (pHeader->bColorMapSize)
-            {
-            case 24:
-                if (flags & TGA_FLAGS_BGR)
-                {
-                    metadata.format = DXGI_FORMAT_B8G8R8X8_UNORM;
-                }
-                else
-                {
-                    metadata.format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                    metadata.SetAlphaMode(TEX_ALPHA_MODE_OPAQUE);
-                }
-                break;
-
-            // Other possible values are 15, 16, and 32 which we do not support.
-
-            default:
-                return HRESULT_E_NOT_SUPPORTED;
-            }
-
-            if (convFlags)
-            {
-                *convFlags |= CONV_FLAGS_PALETTED;
-            }
-            break;
-
-        case TGA_TRUECOLOR:
-        case TGA_TRUECOLOR_RLE:
-            if (pHeader->bColorMapType != 0
-                || pHeader->wColorMapLength != 0)
-            {
-                return HRESULT_E_NOT_SUPPORTED;
-            }
-
-            switch (pHeader->bBitsPerPixel)
-            {
-            case 16:
-                metadata.format = DXGI_FORMAT_B5G5R5A1_UNORM;
-                break;
-
-            case 24:
-                if (flags & TGA_FLAGS_BGR)
-                {
-                    metadata.format = DXGI_FORMAT_B8G8R8X8_UNORM;
-                }
-                else
-                {
-                    metadata.format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                    metadata.SetAlphaMode(TEX_ALPHA_MODE_OPAQUE);
-                }
-
-                if (convFlags)
-                    *convFlags |= CONV_FLAGS_EXPAND;
-                break;
-
-            case 32:
-                metadata.format = (flags & TGA_FLAGS_BGR) ? DXGI_FORMAT_B8G8R8A8_UNORM : DXGI_FORMAT_R8G8B8A8_UNORM;
-                break;
-
-            default:
-                return HRESULT_E_NOT_SUPPORTED;
-            }
-
-            if (convFlags && (pHeader->bImageType == TGA_TRUECOLOR_RLE))
-            {
-                *convFlags |= CONV_FLAGS_RLE;
-            }
-            break;
-
-        case TGA_BLACK_AND_WHITE:
-        case TGA_BLACK_AND_WHITE_RLE:
-            if (pHeader->bColorMapType != 0
-                || pHeader->wColorMapLength != 0)
-            {
-                return HRESULT_E_NOT_SUPPORTED;
-            }
-
-            switch (pHeader->bBitsPerPixel)
-            {
-            case 8:
-                metadata.format = DXGI_FORMAT_R8_UNORM;
-                break;
-
-            default:
-                return HRESULT_E_NOT_SUPPORTED;
-            }
-
-            if (convFlags && (pHeader->bImageType == TGA_BLACK_AND_WHITE_RLE))
-            {
-                *convFlags |= CONV_FLAGS_RLE;
-            }
-            break;
-
-        default:
-            return HRESULT_E_INVALID_DATA;
-        }
-
-        metadata.width = pHeader->wWidth;
-        metadata.height = pHeader->wHeight;
-        metadata.depth = metadata.arraySize = metadata.mipLevels = 1;
-        metadata.dimension = TEX_DIMENSION_TEXTURE2D;
-
-        if (convFlags)
-        {
-            if (pHeader->bDescriptor & TGA_FLAGS_INVERTX)
-                *convFlags |= CONV_FLAGS_INVERTX;
-
-            if (pHeader->bDescriptor & TGA_FLAGS_INVERTY)
-                *convFlags |= CONV_FLAGS_INVERTY;
-        }
-
-        offset = TGA_HEADER_LEN;
-
-        if (pHeader->bIDLength != 0)
-        {
-            offset += pHeader->bIDLength;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Reads palette for color-mapped TGA formats
-    //-------------------------------------------------------------------------------------
-    HRESULT ReadPalette(
-        _In_reads_(TGA_HEADER_LEN) const uint8_t* header,
-        _In_reads_bytes_(size) const void* pSource,
-        size_t size,
-        TGA_FLAGS flags,
-        uint8_t palette[256 * 4],
-        size_t& colorMapSize) noexcept
-    {
-        assert(header && pSource);
-
-        auto pHeader = reinterpret_cast<const TGA_HEADER*>(header);
-
-        if (pHeader->bColorMapType != 1
-            || pHeader->wColorMapLength == 0
-            || pHeader->wColorMapLength > 256
-            || pHeader->bColorMapSize != 24)
-        {
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        const size_t maxColorMap = size_t(pHeader->wColorMapFirst) + size_t(pHeader->wColorMapLength);
-        if (maxColorMap > 256)
-        {
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        colorMapSize = size_t(pHeader->wColorMapLength) * ((size_t(pHeader->bColorMapSize) + 7) >> 3);
-        if (colorMapSize > size)
-        {
-            return HRESULT_E_INVALID_DATA;
-        }
-
-        auto bytes = reinterpret_cast<const uint8_t*>(pSource);
-
-        for (size_t i = pHeader->wColorMapFirst; i < maxColorMap; ++i)
-        {
-            if (flags & TGA_FLAGS_BGR)
-            {
-                palette[i * 4 + 0] = bytes[0];
-                palette[i * 4 + 2] = bytes[2];
-            }
-            else
-            {
-                palette[i * 4 + 0] = bytes[2];
-                palette[i * 4 + 2] = bytes[0];
-            }
-            palette[i * 4 + 1] = bytes[1];
-            palette[i * 4 + 3] = 255;
-            bytes += 3;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Set alpha for images with all 0 alpha channel
-    //-------------------------------------------------------------------------------------
-    HRESULT SetAlphaChannelToOpaque(_In_ const Image* image) noexcept
-    {
-        assert(image);
-
-        uint8_t* pPixels = image->pixels;
-        if (!pPixels)
-            return E_POINTER;
-
-        for (size_t y = 0; y < image->height; ++y)
-        {
-            CopyScanline(pPixels, image->rowPitch, pPixels, image->rowPitch, image->format, TEXP_SCANLINE_SETALPHA);
-            pPixels += image->rowPitch;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Uncompress pixel data from a TGA into the target image
-    //-------------------------------------------------------------------------------------
-    HRESULT UncompressPixels(
-        _In_reads_bytes_(size) const void* pSource,
-        size_t size,
-        TGA_FLAGS flags,
-        _In_ const Image* image,
-        _In_ uint32_t convFlags) noexcept
-    {
-        assert(pSource && size > 0);
-
-        if (!image || !image->pixels)
-            return E_POINTER;
-
-        // Compute TGA image data pitch
-        size_t rowPitch, slicePitch;
-        HRESULT hr = ComputePitch(image->format, image->width, image->height, rowPitch, slicePitch,
-            (convFlags & CONV_FLAGS_EXPAND) ? CP_FLAGS_24BPP : CP_FLAGS_NONE);
-        if (FAILED(hr))
-            return hr;
-
-        auto sPtr = static_cast<const uint8_t*>(pSource);
-        const uint8_t* endPtr = sPtr + size;
-
-        bool opaquealpha = false;
-
-        switch (image->format)
-        {
-        //--------------------------------------------------------------------------- 8-bit
-        case DXGI_FORMAT_R8_UNORM:
-            for (size_t y = 0; y < image->height; ++y)
-            {
-                size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-                assert(offset < rowPitch);
-
-                uint8_t* dPtr = image->pixels
-                    + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1)))
-                    + offset;
-
-                for (size_t x = 0; x < image->width; )
-                {
-                    if (sPtr >= endPtr)
-                        return E_FAIL;
-
-                    if (*sPtr & 0x80)
-                    {
-                        // Repeat
-                        size_t j = size_t(*sPtr & 0x7F) + 1;
-                        if (++sPtr >= endPtr)
-                            return E_FAIL;
-
-                        for (; j > 0; --j, ++x)
-                        {
-                            if (x >= image->width)
-                                return E_FAIL;
-
-                            *dPtr = *sPtr;
-
-                            if (convFlags & CONV_FLAGS_INVERTX)
-                                --dPtr;
-                            else
-                                ++dPtr;
-                        }
-
-                        ++sPtr;
-                    }
-                    else
-                    {
-                        // Literal
-                        size_t j = size_t(*sPtr & 0x7F) + 1;
-                        ++sPtr;
-
-                        if (sPtr + j > endPtr)
-                            return E_FAIL;
-
-                        for (; j > 0; --j, ++x)
-                        {
-                            if (x >= image->width)
-                                return E_FAIL;
-
-                            *dPtr = *(sPtr++);
-
-                            if (convFlags & CONV_FLAGS_INVERTX)
-                                --dPtr;
-                            else
-                                ++dPtr;
-                        }
-                    }
-                }
-            }
-            break;
-
-        //-------------------------------------------------------------------------- 16-bit
-        case DXGI_FORMAT_B5G5R5A1_UNORM:
-            {
-                uint32_t minalpha = 255;
-                uint32_t maxalpha = 0;
-
-                for (size_t y = 0; y < image->height; ++y)
-                {
-                    size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-                    assert(offset * 2 < rowPitch);
-
-                    auto dPtr = reinterpret_cast<uint16_t*>(image->pixels
-                        + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1))))
-                        + offset;
-
-                    for (size_t x = 0; x < image->width; )
-                    {
-                        if (sPtr >= endPtr)
-                            return E_FAIL;
-
-                        if (*sPtr & 0x80)
-                        {
-                            // Repeat
-                            size_t j = size_t(*sPtr & 0x7F) + 1;
-                            ++sPtr;
-
-                            if (sPtr + 1 >= endPtr)
-                                return E_FAIL;
-
-                            auto t = static_cast<uint16_t>(uint32_t(*sPtr) | uint32_t(*(sPtr + 1u) << 8));
-
-                            const uint32_t alpha = (t & 0x8000) ? 255 : 0;
-                            minalpha = std::min(minalpha, alpha);
-                            maxalpha = std::max(maxalpha, alpha);
-
-                            sPtr += 2;
-
-                            for (; j > 0; --j, ++x)
-                            {
-                                if (x >= image->width)
-                                    return E_FAIL;
-
-                                *dPtr = t;
-
-                                if (convFlags & CONV_FLAGS_INVERTX)
-                                    --dPtr;
-                                else
-                                    ++dPtr;
-                            }
-                        }
-                        else
-                        {
-                            // Literal
-                            size_t j = size_t(*sPtr & 0x7F) + 1;
-                            ++sPtr;
-
-                            if (sPtr + (j * 2) > endPtr)
-                                return E_FAIL;
-
-                            for (; j > 0; --j, ++x)
-                            {
-                                if (x >= image->width)
-                                    return E_FAIL;
-
-                                auto t = static_cast<uint16_t>(uint32_t(*sPtr) | uint32_t(*(sPtr + 1u) << 8));
-
-                                const uint32_t alpha = (t & 0x8000) ? 255 : 0;
-                                minalpha = std::min(minalpha, alpha);
-                                maxalpha = std::max(maxalpha, alpha);
-
-                                sPtr += 2;
-                                *dPtr = t;
-
-                                if (convFlags & CONV_FLAGS_INVERTX)
-                                    --dPtr;
-                                else
-                                    ++dPtr;
-                            }
-                        }
-                    }
-                }
-
-                // If there are no non-zero alpha channel entries, we'll assume alpha is not used and force it to opaque
-                if (maxalpha == 0 && !(flags & TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA))
-                {
-                    opaquealpha = true;
-                    hr = SetAlphaChannelToOpaque(image);
-                    if (FAILED(hr))
-                        return hr;
-                }
-                else if (minalpha == 255)
-                {
-                    opaquealpha = true;
-                }
-            }
-            break;
-
-            //------------------------------------------------------ 24/32-bit (with swizzling)
-        case DXGI_FORMAT_R8G8B8A8_UNORM:
-            {
-                uint32_t minalpha = 255;
-                uint32_t maxalpha = 0;
-
-                for (size_t y = 0; y < image->height; ++y)
-                {
-                    size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-
-                    auto dPtr = reinterpret_cast<uint32_t*>(image->pixels
-                        + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1))))
-                        + offset;
-
-                    for (size_t x = 0; x < image->width; )
-                    {
-                        if (sPtr >= endPtr)
-                            return E_FAIL;
-
-                        if (*sPtr & 0x80)
-                        {
-                            // Repeat
-                            size_t j = size_t(*sPtr & 0x7F) + 1;
-                            ++sPtr;
-
-                            uint32_t t;
-                            if (convFlags & CONV_FLAGS_EXPAND)
-                            {
-                                assert(offset * 3 < rowPitch);
-
-                                if (sPtr + 2 >= endPtr)
-                                    return E_FAIL;
-
-                                // BGR -> RGBA
-                                t = uint32_t(*sPtr << 16) | uint32_t(*(sPtr + 1) << 8) | uint32_t(*(sPtr + 2)) | 0xFF000000;
-                                sPtr += 3;
-
-                                minalpha = maxalpha = 255;
-                            }
-                            else
-                            {
-                                assert(offset * 4 < rowPitch);
-
-                                if (sPtr + 3 >= endPtr)
-                                    return E_FAIL;
-
-                                // BGRA -> RGBA
-                                const uint32_t alpha = *(sPtr + 3);
-                                t = uint32_t(*sPtr << 16) | uint32_t(*(sPtr + 1) << 8) | uint32_t(*(sPtr + 2)) | uint32_t(alpha << 24);
-
-                                minalpha = std::min(minalpha, alpha);
-                                maxalpha = std::max(maxalpha, alpha);
-
-                                sPtr += 4;
-                            }
-
-                            for (; j > 0; --j, ++x)
-                            {
-                                if (x >= image->width)
-                                    return E_FAIL;
-
-                                *dPtr = t;
-
-                                if (convFlags & CONV_FLAGS_INVERTX)
-                                    --dPtr;
-                                else
-                                    ++dPtr;
-                            }
-                        }
-                        else
-                        {
-                            // Literal
-                            size_t j = size_t(*sPtr & 0x7F) + 1;
-                            ++sPtr;
-
-                            if (convFlags & CONV_FLAGS_EXPAND)
-                            {
-                                if (sPtr + (j * 3) > endPtr)
-                                    return E_FAIL;
-                            }
-                            else
-                            {
-                                if (sPtr + (j * 4) > endPtr)
-                                    return E_FAIL;
-                            }
-
-                            for (; j > 0; --j, ++x)
-                            {
-                                if (x >= image->width)
-                                    return E_FAIL;
-
-                                if (convFlags & CONV_FLAGS_EXPAND)
-                                {
-                                    assert(offset * 3 < rowPitch);
-
-                                    if (sPtr + 2 >= endPtr)
-                                        return E_FAIL;
-
-                                    // BGR -> RGBA
-                                    *dPtr = uint32_t(*sPtr << 16) | uint32_t(*(sPtr + 1) << 8) | uint32_t(*(sPtr + 2)) | 0xFF000000;
-                                    sPtr += 3;
-
-                                    minalpha = maxalpha = 255;
-                                }
-                                else
-                                {
-                                    assert(offset * 4 < rowPitch);
-
-                                    if (sPtr + 3 >= endPtr)
-                                        return E_FAIL;
-
-                                    // BGRA -> RGBA
-                                    uint32_t alpha = *(sPtr + 3);
-                                    *dPtr = uint32_t(*sPtr << 16) | uint32_t(*(sPtr + 1) << 8) | uint32_t(*(sPtr + 2)) | uint32_t(alpha << 24);
-
-                                    minalpha = std::min(minalpha, alpha);
-                                    maxalpha = std::max(maxalpha, alpha);
-
-                                    sPtr += 4;
-                                }
-
-                                if (convFlags & CONV_FLAGS_INVERTX)
-                                    --dPtr;
-                                else
-                                    ++dPtr;
-                            }
-                        }
-                    }
-                }
-
-                // If there are no non-zero alpha channel entries, we'll assume alpha is not used and force it to opaque
-                if (maxalpha == 0 && !(flags & TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA))
-                {
-                    opaquealpha = true;
-                    hr = SetAlphaChannelToOpaque(image);
-                    if (FAILED(hr))
-                        return hr;
-                }
-                else if (minalpha == 255)
-                {
-                    opaquealpha = true;
-                }
-            }
-            break;
-
-            //-------------------------------------------------------------------- 32-bit (BGR)
-        case DXGI_FORMAT_B8G8R8A8_UNORM:
-            {
-                assert((convFlags & CONV_FLAGS_EXPAND) == 0);
-
-                uint32_t minalpha = 255;
-                uint32_t maxalpha = 0;
-
-                for (size_t y = 0; y < image->height; ++y)
-                {
-                    size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-
-                    auto dPtr = reinterpret_cast<uint32_t*>(image->pixels
-                        + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1))))
-                        + offset;
-
-                    for (size_t x = 0; x < image->width; )
-                    {
-                        if (sPtr >= endPtr)
-                            return E_FAIL;
-
-                        if (*sPtr & 0x80)
-                        {
-                            // Repeat
-                            size_t j = size_t(*sPtr & 0x7F) + 1;
-                            ++sPtr;
-
-                            assert(offset * 4 < rowPitch);
-
-                            if (sPtr + 3 >= endPtr)
-                                return E_FAIL;
-
-                            const uint32_t alpha = *(sPtr + 3);
-
-                            auto t = *reinterpret_cast<const uint32_t*>(sPtr);
-
-                            minalpha = std::min(minalpha, alpha);
-                            maxalpha = std::max(maxalpha, alpha);
-
-                            sPtr += 4;
-
-                            for (; j > 0; --j, ++x)
-                            {
-                                if (x >= image->width)
-                                    return E_FAIL;
-
-                                *dPtr = t;
-
-                                if (convFlags & CONV_FLAGS_INVERTX)
-                                    --dPtr;
-                                else
-                                    ++dPtr;
-                            }
-                        }
-                        else
-                        {
-                            // Literal
-                            size_t j = size_t(*sPtr & 0x7F) + 1;
-                            ++sPtr;
-
-                            if (sPtr + (j * 4) > endPtr)
-                                return E_FAIL;
-
-                            for (; j > 0; --j, ++x)
-                            {
-                                if (x >= image->width)
-                                    return E_FAIL;
-
-                                assert(offset * 4 < rowPitch);
-
-                                if (sPtr + 3 >= endPtr)
-                                    return E_FAIL;
-
-                                const uint32_t alpha = *(sPtr + 3);
-                                *dPtr = *reinterpret_cast<const uint32_t*>(sPtr);
-
-                                minalpha = std::min(minalpha, alpha);
-                                maxalpha = std::max(maxalpha, alpha);
-
-                                sPtr += 4;
-
-                                if (convFlags & CONV_FLAGS_INVERTX)
-                                    --dPtr;
-                                else
-                                    ++dPtr;
-                            }
-                        }
-                    }
-                }
-
-                // If there are no non-zero alpha channel entries, we'll assume alpha is not used and force it to opaque
-                if (maxalpha == 0 && !(flags & TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA))
-                {
-                    opaquealpha = true;
-                    hr = SetAlphaChannelToOpaque(image);
-                    if (FAILED(hr))
-                        return hr;
-                }
-                else if (minalpha == 255)
-                {
-                    opaquealpha = true;
-                }
-            }
-            break;
-
-            //-------------------------------------------------------------------- 24-bit (BGR)
-        case DXGI_FORMAT_B8G8R8X8_UNORM:
-            {
-                assert((convFlags & CONV_FLAGS_EXPAND) != 0);
-
-                for (size_t y = 0; y < image->height; ++y)
-                {
-                    size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-
-                    auto dPtr = reinterpret_cast<uint32_t*>(image->pixels
-                        + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1))))
-                        + offset;
-
-                    for (size_t x = 0; x < image->width; )
-                    {
-                        if (sPtr >= endPtr)
-                            return E_FAIL;
-
-                        if (*sPtr & 0x80)
-                        {
-                            // Repeat
-                            size_t j = size_t(*sPtr & 0x7F) + 1;
-                            ++sPtr;
-
-                            assert(offset * 3 < rowPitch);
-
-                            if (sPtr + 2 >= endPtr)
-                                return E_FAIL;
-
-                            uint32_t t = uint32_t(*sPtr) | uint32_t(*(sPtr + 1) << 8) | uint32_t(*(sPtr + 2) << 16);
-                            sPtr += 3;
-
-                            for (; j > 0; --j, ++x)
-                            {
-                                if (x >= image->width)
-                                    return E_FAIL;
-
-                                *dPtr = t;
-
-                                if (convFlags & CONV_FLAGS_INVERTX)
-                                    --dPtr;
-                                else
-                                    ++dPtr;
-                            }
-                        }
-                        else
-                        {
-                            // Literal
-                            size_t j = size_t(*sPtr & 0x7F) + 1;
-                            ++sPtr;
-
-                            if (sPtr + (j * 3) > endPtr)
-                                return E_FAIL;
-
-                            for (; j > 0; --j, ++x)
-                            {
-                                if (x >= image->width)
-                                    return E_FAIL;
-
-                                assert(offset * 3 < rowPitch);
-
-                                if (sPtr + 2 >= endPtr)
-                                    return E_FAIL;
-
-                                *dPtr = uint32_t(*sPtr) | uint32_t(*(sPtr + 1) << 8) | uint32_t(*(sPtr + 2) << 16);
-                                sPtr += 3;
-
-                                if (convFlags & CONV_FLAGS_INVERTX)
-                                    --dPtr;
-                                else
-                                    ++dPtr;
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-
-            //---------------------------------------------------------------------------------
-        default:
-            return E_FAIL;
-        }
-
-        return opaquealpha ? S_FALSE : S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Copies pixel data from a TGA into the target image
-    //-------------------------------------------------------------------------------------
-    HRESULT CopyPixels(
-        _In_reads_bytes_(size) const void* pSource,
-        size_t size,
-        TGA_FLAGS flags,
-        _In_ const Image* image,
-        _In_ uint32_t convFlags,
-        _In_opt_ const uint8_t* palette) noexcept
-    {
-        assert(pSource && size > 0);
-
-        if (!image || !image->pixels)
-            return E_POINTER;
-
-        // Compute TGA image data pitch
-        size_t rowPitch, slicePitch;
-        HRESULT hr = ComputePitch(image->format, image->width, image->height,
-            rowPitch, slicePitch,
-            (convFlags & CONV_FLAGS_EXPAND) ? CP_FLAGS_24BPP : CP_FLAGS_NONE);
-        if (FAILED(hr))
-            return hr;
-
-        auto sPtr = static_cast<const uint8_t*>(pSource);
-        const uint8_t* endPtr = sPtr + size;
-
-        bool opaquealpha = false;
-
-        if ((convFlags & CONV_FLAGS_PALETTED) != 0)
-        {
-            if (!palette)
-                return E_UNEXPECTED;
-
-            const auto table = reinterpret_cast<const uint32_t*>(palette);
-
-            for (size_t y = 0; y < image->height; ++y)
-            {
-                size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-                assert(offset < rowPitch);
-
-                auto dPtr = reinterpret_cast<uint32_t*>(image->pixels
-                    + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1))))
-                    + offset;
-
-                for (size_t x = 0; x < image->width; ++x)
-                {
-                    if (sPtr >= endPtr)
-                        return E_FAIL;
-
-                    *dPtr = table[*(sPtr++)];
-
-                    if (convFlags & CONV_FLAGS_INVERTX)
-                        --dPtr;
-                    else
-                        ++dPtr;
-                }
-            }
-        }
-        else
-        {
-            switch (image->format)
-            {
-            //----------------------------------------------------------------------- 8-bit
-            case DXGI_FORMAT_R8_UNORM:
-                for (size_t y = 0; y < image->height; ++y)
-                {
-                    size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-                    assert(offset < rowPitch);
-
-                    uint8_t* dPtr = image->pixels
-                        + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1)))
-                        + offset;
-
-                    for (size_t x = 0; x < image->width; ++x)
-                    {
-                        if (sPtr >= endPtr)
-                            return E_FAIL;
-
-                        *dPtr = *(sPtr++);
-
-                        if (convFlags & CONV_FLAGS_INVERTX)
-                            --dPtr;
-                        else
-                            ++dPtr;
-                    }
-                }
-                break;
-
-            //---------------------------------------------------------------------- 16-bit
-            case DXGI_FORMAT_B5G5R5A1_UNORM:
-                {
-                    uint32_t minalpha = 255;
-                    uint32_t maxalpha = 0;
-
-                    for (size_t y = 0; y < image->height; ++y)
-                    {
-                        size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-                        assert(offset * 2 < rowPitch);
-
-                        auto dPtr = reinterpret_cast<uint16_t*>(image->pixels
-                            + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1))))
-                            + offset;
-
-                        for (size_t x = 0; x < image->width; ++x)
-                        {
-                            if (sPtr + 1 >= endPtr)
-                                return E_FAIL;
-
-                            auto t = static_cast<uint16_t>(uint32_t(*sPtr) | uint32_t(*(sPtr + 1u) << 8));
-                            sPtr += 2;
-                            *dPtr = t;
-
-                            const uint32_t alpha = (t & 0x8000) ? 255 : 0;
-                            minalpha = std::min(minalpha, alpha);
-                            maxalpha = std::max(maxalpha, alpha);
-
-                            if (convFlags & CONV_FLAGS_INVERTX)
-                                --dPtr;
-                            else
-                                ++dPtr;
-                        }
-                    }
-
-                    // If there are no non-zero alpha channel entries, we'll assume alpha is not used and force it to opaque
-                    if (maxalpha == 0 && !(flags & TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA))
-                    {
-                        opaquealpha = true;
-                        hr = SetAlphaChannelToOpaque(image);
-                        if (FAILED(hr))
-                            return hr;
-                    }
-                    else if (minalpha == 255)
-                    {
-                        opaquealpha = true;
-                    }
-                }
-                break;
-
-            //-------------------------------------------------- 24/32-bit (with swizzling)
-            case DXGI_FORMAT_R8G8B8A8_UNORM:
-                {
-                    uint32_t minalpha = 255;
-                    uint32_t maxalpha = 0;
-
-                    for (size_t y = 0; y < image->height; ++y)
-                    {
-                        size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-
-                        auto dPtr = reinterpret_cast<uint32_t*>(image->pixels
-                            + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1))))
-                            + offset;
-
-                        for (size_t x = 0; x < image->width; ++x)
-                        {
-                            if (convFlags & CONV_FLAGS_EXPAND)
-                            {
-                                assert(offset * 3 < rowPitch);
-
-                                if (sPtr + 2 >= endPtr)
-                                    return E_FAIL;
-
-                                // BGR -> RGBA
-                                *dPtr = uint32_t(*sPtr << 16) | uint32_t(*(sPtr + 1) << 8) | uint32_t(*(sPtr + 2)) | 0xFF000000;
-                                sPtr += 3;
-
-                                minalpha = maxalpha = 255;
-                            }
-                            else
-                            {
-                                assert(offset * 4 < rowPitch);
-
-                                if (sPtr + 3 >= endPtr)
-                                    return E_FAIL;
-
-                                // BGRA -> RGBA
-                                uint32_t alpha = *(sPtr + 3);
-                                *dPtr = uint32_t(*sPtr << 16) | uint32_t(*(sPtr + 1) << 8) | uint32_t(*(sPtr + 2)) | uint32_t(alpha << 24);
-
-                                minalpha = std::min(minalpha, alpha);
-                                maxalpha = std::max(maxalpha, alpha);
-
-                                sPtr += 4;
-                            }
-
-                            if (convFlags & CONV_FLAGS_INVERTX)
-                                --dPtr;
-                            else
-                                ++dPtr;
-                        }
-                    }
-
-                    // If there are no non-zero alpha channel entries, we'll assume alpha is not used and force it to opaque
-                    if (maxalpha == 0 && !(flags & TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA))
-                    {
-                        opaquealpha = true;
-                        hr = SetAlphaChannelToOpaque(image);
-                        if (FAILED(hr))
-                            return hr;
-                    }
-                    else if (minalpha == 255)
-                    {
-                        opaquealpha = true;
-                    }
-                }
-                break;
-
-            //---------------------------------------------------------------- 32-bit (BGR)
-            case DXGI_FORMAT_B8G8R8A8_UNORM:
-                {
-                    assert((convFlags & CONV_FLAGS_EXPAND) == 0);
-
-                    uint32_t minalpha = 255;
-                    uint32_t maxalpha = 0;
-
-                    for (size_t y = 0; y < image->height; ++y)
-                    {
-                        size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-
-                        auto dPtr = reinterpret_cast<uint32_t*>(image->pixels
-                            + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1))))
-                            + offset;
-
-                        for (size_t x = 0; x < image->width; ++x)
-                        {
-                            assert(offset * 4 < rowPitch);
-
-                            if (sPtr + 3 >= endPtr)
-                                return E_FAIL;
-
-                            const uint32_t alpha = *(sPtr + 3);
-                            *dPtr = *reinterpret_cast<const uint32_t*>(sPtr);
-
-                            minalpha = std::min(minalpha, alpha);
-                            maxalpha = std::max(maxalpha, alpha);
-
-                            sPtr += 4;
-
-                            if (convFlags & CONV_FLAGS_INVERTX)
-                                --dPtr;
-                            else
-                                ++dPtr;
-                        }
-                    }
-
-                    // If there are no non-zero alpha channel entries, we'll assume alpha is not used and force it to opaque
-                    if (maxalpha == 0 && !(flags & TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA))
-                    {
-                        opaquealpha = true;
-                        hr = SetAlphaChannelToOpaque(image);
-                        if (FAILED(hr))
-                            return hr;
-                    }
-                    else if (minalpha == 255)
-                    {
-                        opaquealpha = true;
-                    }
-                }
-                break;
-
-            //---------------------------------------------------------------- 24-bit (BGR)
-            case DXGI_FORMAT_B8G8R8X8_UNORM:
-                {
-                    assert((convFlags & CONV_FLAGS_EXPAND) != 0);
-
-                    for (size_t y = 0; y < image->height; ++y)
-                    {
-                        size_t offset = ((convFlags & CONV_FLAGS_INVERTX) ? (image->width - 1) : 0);
-
-                        auto dPtr = reinterpret_cast<uint32_t*>(image->pixels
-                            + (image->rowPitch * ((convFlags & CONV_FLAGS_INVERTY) ? y : (image->height - y - 1))))
-                            + offset;
-
-                        for (size_t x = 0; x < image->width; ++x)
-                        {
-                            assert(offset * 3 < rowPitch);
-
-                            if (sPtr + 2 >= endPtr)
-                                return E_FAIL;
-
-                            *dPtr = uint32_t(*sPtr) | uint32_t(*(sPtr + 1) << 8) | uint32_t(*(sPtr + 2) << 16);
-                            sPtr += 3;
-
-                            if (convFlags & CONV_FLAGS_INVERTX)
-                                --dPtr;
-                            else
-                                ++dPtr;
-                        }
-                    }
-                }
-                break;
-
-            //-----------------------------------------------------------------------------
-            default:
-                return E_FAIL;
-            }
-        }
-
-        return opaquealpha ? S_FALSE : S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Encodes TGA file header
-    //-------------------------------------------------------------------------------------
-    HRESULT EncodeTGAHeader(_In_ const Image& image, _Out_ TGA_HEADER& header, _Inout_ uint32_t& convFlags) noexcept
-    {
-        memset(&header, 0, TGA_HEADER_LEN);
-
-        if ((image.width > UINT16_MAX)
-            || (image.height > UINT16_MAX))
-        {
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        header.wWidth = static_cast<uint16_t>(image.width);
-        header.wHeight = static_cast<uint16_t>(image.height);
-
-        switch (image.format)
-        {
-        case DXGI_FORMAT_R8G8B8A8_UNORM:
-        case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-            header.bImageType = TGA_TRUECOLOR;
-            header.bBitsPerPixel = 32;
-            header.bDescriptor = TGA_FLAGS_INVERTY | 8;
-            convFlags |= CONV_FLAGS_SWIZZLE;
-            break;
-
-        case DXGI_FORMAT_B8G8R8A8_UNORM:
-        case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-            header.bImageType = TGA_TRUECOLOR;
-            header.bBitsPerPixel = 32;
-            header.bDescriptor = TGA_FLAGS_INVERTY | 8;
-            break;
-
-        case DXGI_FORMAT_B8G8R8X8_UNORM:
-        case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-            header.bImageType = TGA_TRUECOLOR;
-            header.bBitsPerPixel = 24;
-            header.bDescriptor = TGA_FLAGS_INVERTY;
-            convFlags |= CONV_FLAGS_888;
-            break;
-
-        case DXGI_FORMAT_R8_UNORM:
-        case DXGI_FORMAT_A8_UNORM:
-            header.bImageType = TGA_BLACK_AND_WHITE;
-            header.bBitsPerPixel = 8;
-            header.bDescriptor = TGA_FLAGS_INVERTY;
-            break;
-
-        case DXGI_FORMAT_B5G5R5A1_UNORM:
-            header.bImageType = TGA_TRUECOLOR;
-            header.bBitsPerPixel = 16;
-            header.bDescriptor = TGA_FLAGS_INVERTY | 1;
-            break;
-
-        default:
-            return HRESULT_E_NOT_SUPPORTED;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Copies BGRX data to form BGR 24bpp data
-    //-------------------------------------------------------------------------------------
-#pragma warning(suppress: 6001 6101) // In the case where outSize is insufficient we do not write to pDestination
-    void Copy24bppScanline(
-        _Out_writes_bytes_(outSize) void* pDestination,
-        _In_ size_t outSize,
-        _In_reads_bytes_(inSize) const void* pSource,
-        _In_ size_t inSize) noexcept
-    {
-        assert(pDestination && outSize > 0);
-        assert(pSource && inSize > 0);
-
-        assert(pDestination != pSource);
-
-        const uint32_t * __restrict sPtr = static_cast<const uint32_t*>(pSource);
-        uint8_t * __restrict dPtr = static_cast<uint8_t*>(pDestination);
-
-        if (inSize >= 4 && outSize >= 3)
-        {
-            const uint8_t* endPtr = dPtr + outSize;
-
-            for (size_t count = 0; count < (inSize - 3); count += 4)
-            {
-                uint32_t t = *(sPtr++);
-
-                if (dPtr + 3 > endPtr)
-                    return;
-
-                *(dPtr++) = uint8_t(t & 0xFF);              // Blue
-                *(dPtr++) = uint8_t((t & 0xFF00) >> 8);     // Green
-                *(dPtr++) = uint8_t((t & 0xFF0000) >> 16);  // Red
-            }
-        }
-    }
-
-    //-------------------------------------------------------------------------------------
-    // TGA 2.0 Extension helpers
-    //-------------------------------------------------------------------------------------
-    void SetExtension(_In_ TGA_EXTENSION *ext, TGA_FLAGS flags, const TexMetadata& metadata) noexcept
-    {
-        memset(ext, 0, sizeof(TGA_EXTENSION));
-
-        ext->wSize = sizeof(TGA_EXTENSION);
-
-        memcpy(ext->szSoftwareId, "DirectXTex", sizeof("DirectXTex"));
-        ext->wVersionNumber = DIRECTX_TEX_VERSION;
-        ext->bVersionLetter = ' ';
-
-        const bool sRGB = ((flags & TGA_FLAGS_FORCE_LINEAR) == 0) && ((flags & TGA_FLAGS_FORCE_SRGB) != 0 || IsSRGB(metadata.format));
-        if (sRGB)
-        {
-            ext->wGammaNumerator = 22;
-            ext->wGammaDenominator = 10;
-        }
-        else if (flags & TGA_FLAGS_FORCE_LINEAR)
-        {
-            ext->wGammaNumerator = 1;
-            ext->wGammaDenominator = 1;
-        }
-
-        switch (metadata.GetAlphaMode())
-        {
-        case TEX_ALPHA_MODE_UNKNOWN:
-            ext->bAttributesType = HasAlpha(metadata.format) ? TGA_ATTRIBUTE_UNDEFINED : TGA_ATTRIBUTE_NONE;
-            break;
-
-        case TEX_ALPHA_MODE_STRAIGHT:
-            ext->bAttributesType = TGA_ATTRIBUTE_ALPHA;
-            break;
-
-        case TEX_ALPHA_MODE_PREMULTIPLIED:
-            ext->bAttributesType = TGA_ATTRIBUTE_PREMULTIPLIED;
-            break;
-
-        case TEX_ALPHA_MODE_OPAQUE:
-            ext->bAttributesType = TGA_ATTRIBUTE_IGNORED;
-            break;
-
-        case TEX_ALPHA_MODE_CUSTOM:
-            ext->bAttributesType = TGA_ATTRIBUTE_UNDEFINED;
-            break;
-        }
-
-        // Set file time stamp
-        {
-            time_t now = {};
-            time(&now);
-
-        #ifdef _WIN32
-            tm info;
-            auto pinfo = &info;
-            if (!gmtime_s(pinfo, &now))
-            #else
-            const tm* pinfo = gmtime(&now);
-            if (pinfo)
-            #endif
-            {
-                ext->wStampMonth = static_cast<uint16_t>(pinfo->tm_mon + 1);
-                ext->wStampDay = static_cast<uint16_t>(pinfo->tm_mday);
-                ext->wStampYear = static_cast<uint16_t>(pinfo->tm_year + 1900);
-                ext->wStampHour = static_cast<uint16_t>(pinfo->tm_hour);
-                ext->wStampMinute = static_cast<uint16_t>(pinfo->tm_min);
-                ext->wStampSecond = static_cast<uint16_t>(pinfo->tm_sec);
-            }
-        }
-    }
-
-    TEX_ALPHA_MODE GetAlphaModeFromExtension(_In_opt_ const TGA_EXTENSION *ext) noexcept
-    {
-        if (ext && ext->wSize == sizeof(TGA_EXTENSION))
-        {
-            switch (ext->bAttributesType)
-            {
-            case TGA_ATTRIBUTE_IGNORED: return TEX_ALPHA_MODE_OPAQUE;
-            case TGA_ATTRIBUTE_UNDEFINED: return TEX_ALPHA_MODE_CUSTOM;
-            case TGA_ATTRIBUTE_ALPHA: return TEX_ALPHA_MODE_STRAIGHT;
-            case TGA_ATTRIBUTE_PREMULTIPLIED: return TEX_ALPHA_MODE_PREMULTIPLIED;
-            }
-        }
-
-        return TEX_ALPHA_MODE_UNKNOWN;
-    }
-
-    DXGI_FORMAT GetSRGBFromExtension(_In_opt_ const TGA_EXTENSION* ext, DXGI_FORMAT format, TGA_FLAGS flags, _In_opt_ ScratchImage* image) noexcept
-    {
-        bool sRGB = false;
-
-        if (ext && ext->wSize == sizeof(TGA_EXTENSION) && ext->wGammaDenominator != 0)
-        {
-            auto const gamma = static_cast<float>(ext->wGammaNumerator) / static_cast<float>(ext->wGammaDenominator);
-            if (fabsf(gamma - 2.2f) < GAMMA_EPSILON || fabsf(gamma - 2.4f) < GAMMA_EPSILON)
-            {
-                sRGB = true;
-            }
-        }
-        else
-        {
-            sRGB = (flags & TGA_FLAGS_DEFAULT_SRGB) != 0;
-        }
-
-        if (sRGB)
-        {
-            format = MakeSRGB(format);
-            if (image)
-            {
-                image->OverrideFormat(format);
-            }
-        }
-
-        return format;
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Obtain metadata from TGA file in memory/on disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::GetMetadataFromTGAMemory(
-    const void* pSource,
-    size_t size,
-    TGA_FLAGS flags,
-    TexMetadata& metadata) noexcept
-{
-    if (!pSource || size == 0)
-        return E_INVALIDARG;
-
-    size_t offset;
-    HRESULT hr = DecodeTGAHeader(pSource, size, flags, metadata, offset, nullptr);
-    if (FAILED(hr))
-        return hr;
-
-    // Optional TGA 2.0 footer & extension area
-    const TGA_EXTENSION* ext = nullptr;
-    if (size >= sizeof(TGA_FOOTER))
-    {
-        auto footer = reinterpret_cast<const TGA_FOOTER*>(static_cast<const uint8_t*>(pSource) + size - sizeof(TGA_FOOTER));
-
-        if (memcmp(footer->Signature, g_Signature, sizeof(g_Signature)) == 0)
-        {
-            if (footer->dwExtensionOffset != 0
-                && ((footer->dwExtensionOffset + sizeof(TGA_EXTENSION)) <= size))
-            {
-                ext = reinterpret_cast<const TGA_EXTENSION*>(static_cast<const uint8_t*>(pSource) + footer->dwExtensionOffset);
-                metadata.SetAlphaMode(GetAlphaModeFromExtension(ext));
-            }
-        }
-    }
-
-    if (!(flags & TGA_FLAGS_IGNORE_SRGB))
-    {
-        metadata.format = GetSRGBFromExtension(ext, metadata.format, flags, nullptr);
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::GetMetadataFromTGAFile(const wchar_t* szFile, TGA_FLAGS flags, TexMetadata& metadata) noexcept
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-#ifdef _WIN32
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
-    ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
-#else
-    ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
-        FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
-#endif
-    if (!hFile)
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // Get the file size
-    FILE_STANDARD_INFO fileInfo;
-    if (!GetFileInformationByHandleEx(hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo)))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // File is too big for 32-bit allocation, so reject read (4 GB should be plenty large enough for a valid TGA file)
-    if (fileInfo.EndOfFile.HighPart > 0)
-    {
-        return HRESULT_E_FILE_TOO_LARGE;
-    }
-
-    const size_t len = fileInfo.EndOfFile.LowPart;
-#else // !WIN32
-    std::ifstream inFile(std::filesystem::path(szFile), std::ios::in | std::ios::binary | std::ios::ate);
-    if (!inFile)
-        return E_FAIL;
-
-    std::streampos fileLen = inFile.tellg();
-    if (!inFile)
-        return E_FAIL;
-
-    if (fileLen > UINT32_MAX)
-        return HRESULT_E_FILE_TOO_LARGE;
-
-    inFile.seekg(0, std::ios::beg);
-    if (!inFile)
-        return E_FAIL;
-
-    size_t len = fileLen;
-#endif
-
-    // Need at least enough data to fill the standard header to be a valid TGA
-    if (len < TGA_HEADER_LEN)
-    {
-        return E_FAIL;
-    }
-
-    // Read the standard header (we don't need the file footer to parse the file)
-    uint8_t header[TGA_HEADER_LEN] = {};
-
-#ifdef _WIN32
-    DWORD bytesRead = 0;
-    if (!ReadFile(hFile.get(), header, TGA_HEADER_LEN, &bytesRead, nullptr))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    auto const headerLen = static_cast<size_t>(bytesRead);
-#else
-    inFile.read(reinterpret_cast<char*>(header), TGA_HEADER_LEN);
-    if (!inFile)
-        return E_FAIL;
-
-    size_t headerLen = TGA_HEADER_LEN;
-#endif
-
-    size_t offset;
-    HRESULT hr = DecodeTGAHeader(header, headerLen, flags, metadata, offset, nullptr);
-    if (FAILED(hr))
-        return hr;
-
-    // Optional TGA 2.0 footer & extension area
-    const TGA_EXTENSION* ext = nullptr;
-    TGA_EXTENSION extData = {};
-    {
-        TGA_FOOTER footer = {};
-
-    #ifdef _WIN32
-        if (SetFilePointer(hFile.get(), -static_cast<int>(sizeof(TGA_FOOTER)), nullptr, FILE_END) != INVALID_SET_FILE_POINTER)
-        {
-            if (!ReadFile(hFile.get(), &footer, sizeof(TGA_FOOTER), &bytesRead, nullptr))
-            {
-                return HRESULT_FROM_WIN32(GetLastError());
-            }
-
-            if (bytesRead != sizeof(TGA_FOOTER))
-            {
-                return E_FAIL;
-            }
-        }
-    #else
-        inFile.seekg(-static_cast<int>(sizeof(TGA_FOOTER)), std::ios::end);
-        if (inFile)
-        {
-            inFile.read(reinterpret_cast<char*>(&footer), sizeof(TGA_FOOTER));
-            if (!inFile)
-                return E_FAIL;
-        }
-    #endif
-
-        if (memcmp(footer.Signature, g_Signature, sizeof(g_Signature)) == 0)
-        {
-            if (footer.dwExtensionOffset != 0
-                && ((footer.dwExtensionOffset + sizeof(TGA_EXTENSION)) <= len))
-            {
-            #ifdef _WIN32
-                const LARGE_INTEGER filePos = { { static_cast<DWORD>(footer.dwExtensionOffset), 0 } };
-                if (SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN))
-                {
-                    if (ReadFile(hFile.get(), &extData, sizeof(TGA_EXTENSION), &bytesRead, nullptr)
-                        && bytesRead == sizeof(TGA_EXTENSION))
-                    {
-                        ext = &extData;
-                        metadata.SetAlphaMode(GetAlphaModeFromExtension(ext));
-                    }
-                }
-            #else // !WIN32
-                inFile.seekg(static_cast<std::streampos>(footer.dwExtensionOffset), std::ios::beg);
-                if (inFile)
-                {
-                    inFile.read(reinterpret_cast<char*>(&extData), sizeof(TGA_EXTENSION));
-                    if (inFile)
-                    {
-                        ext = &extData;
-                        metadata.SetAlphaMode(GetAlphaModeFromExtension(ext));
-                    }
-                }
-            #endif
-            }
-        }
-    }
-
-    if (!(flags & TGA_FLAGS_IGNORE_SRGB))
-    {
-        metadata.format = GetSRGBFromExtension(ext, metadata.format, flags, nullptr);
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Load a TGA file in memory
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::LoadFromTGAMemory(
-    const void* pSource,
-    size_t size,
-    TGA_FLAGS flags,
-    TexMetadata* metadata,
-    ScratchImage& image) noexcept
-{
-    if (!pSource || size == 0)
-        return E_INVALIDARG;
-
-    image.Release();
-
-    size_t offset;
-    uint32_t convFlags = 0;
-    TexMetadata mdata;
-    HRESULT hr = DecodeTGAHeader(pSource, size, flags, mdata, offset, &convFlags);
-    if (FAILED(hr))
-        return hr;
-
-    if (offset > size)
-        return E_FAIL;
-
-    size_t paletteOffset = 0;
-    uint8_t palette[256 * 4] = {};
-    if (convFlags & CONV_FLAGS_PALETTED)
-    {
-        const size_t remaining = size - offset;
-        if (remaining == 0)
-            return E_FAIL;
-
-        auto pColorMap = static_cast<const uint8_t*>(pSource) + offset;
-
-        _Analysis_assume_(size > TGA_HEADER_LEN);
-        hr = ReadPalette(static_cast<const uint8_t*>(pSource), pColorMap, remaining, flags,
-            palette, paletteOffset);
-        if (FAILED(hr))
-            return hr;
-    }
-
-    const size_t remaining = size - offset - paletteOffset;
-    if (remaining == 0)
-        return E_FAIL;
-
-    const void* pPixels = static_cast<const uint8_t*>(pSource) + offset + paletteOffset;
-
-    hr = image.Initialize2D(mdata.format, mdata.width, mdata.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    if (convFlags & CONV_FLAGS_RLE)
-    {
-        hr = UncompressPixels(pPixels, remaining, flags, image.GetImage(0, 0, 0), convFlags);
-    }
-    else
-    {
-        hr = CopyPixels(pPixels, remaining, flags, image.GetImage(0, 0, 0), convFlags, palette);
-    }
-
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-
-    // Optional TGA 2.0 footer & extension area
-    const TGA_EXTENSION* ext = nullptr;
-    if (size >= sizeof(TGA_FOOTER))
-    {
-        auto footer = reinterpret_cast<const TGA_FOOTER*>(static_cast<const uint8_t*>(pSource) + size - sizeof(TGA_FOOTER));
-
-        if (memcmp(footer->Signature, g_Signature, sizeof(g_Signature)) == 0)
-        {
-            if (footer->dwExtensionOffset != 0
-                && ((footer->dwExtensionOffset + sizeof(TGA_EXTENSION)) <= size))
-            {
-                ext = reinterpret_cast<const TGA_EXTENSION*>(static_cast<const uint8_t*>(pSource) + footer->dwExtensionOffset);
-            }
-        }
-    }
-
-    if (!(flags & TGA_FLAGS_IGNORE_SRGB))
-    {
-        mdata.format = GetSRGBFromExtension(ext, mdata.format, flags, &image);
-    }
-
-    if (metadata)
-    {
-        memcpy(metadata, &mdata, sizeof(TexMetadata));
-        if (hr == S_FALSE)
-        {
-            metadata->SetAlphaMode(TEX_ALPHA_MODE_OPAQUE);
-        }
-        else if (ext)
-        {
-            metadata->SetAlphaMode(GetAlphaModeFromExtension(ext));
-        }
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Load a TGA file from disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::LoadFromTGAFile(
-    const wchar_t* szFile,
-    TGA_FLAGS flags,
-    TexMetadata* metadata,
-    ScratchImage& image) noexcept
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-    image.Release();
-
-#ifdef _WIN32
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
-    ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
-#else
-    ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
-        FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
-#endif
-    if (!hFile)
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // Get the file size
-    FILE_STANDARD_INFO fileInfo;
-    if (!GetFileInformationByHandleEx(hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo)))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    // File is too big for 32-bit allocation, so reject read (4 GB should be plenty large enough for a valid TGA file)
-    if (fileInfo.EndOfFile.HighPart > 0)
-    {
-        return HRESULT_E_FILE_TOO_LARGE;
-    }
-
-    const size_t len = fileInfo.EndOfFile.LowPart;
-#else // !WIN32
-    std::ifstream inFile(std::filesystem::path(szFile), std::ios::in | std::ios::binary | std::ios::ate);
-    if (!inFile)
-        return E_FAIL;
-
-    std::streampos fileLen = inFile.tellg();
-    if (!inFile)
-        return E_FAIL;
-
-    if (fileLen > UINT32_MAX)
-        return HRESULT_E_FILE_TOO_LARGE;
-
-    inFile.seekg(0, std::ios::beg);
-    if (!inFile)
-        return E_FAIL;
-
-    size_t len = fileLen;
-#endif
-
-    // Need at least enough data to fill the header to be a valid TGA
-    if (len < TGA_HEADER_LEN)
-    {
-        return E_FAIL;
-    }
-
-    // Read the header
-    uint8_t header[TGA_HEADER_LEN] = {};
-
-#ifdef _WIN32
-    DWORD bytesRead = 0;
-    if (!ReadFile(hFile.get(), header, TGA_HEADER_LEN, &bytesRead, nullptr))
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    auto const headerLen = static_cast<size_t>(bytesRead);
-#else
-    inFile.read(reinterpret_cast<char*>(header), TGA_HEADER_LEN);
-    if (!inFile)
-        return E_FAIL;
-
-    size_t headerLen = TGA_HEADER_LEN;
-#endif
-
-    size_t offset;
-    uint32_t convFlags = 0;
-    TexMetadata mdata;
-    HRESULT hr = DecodeTGAHeader(header, headerLen, flags, mdata, offset, &convFlags);
-    if (FAILED(hr))
-        return hr;
-
-    // Read the pixels
-    auto const remaining = len - offset;
-    if (remaining == 0)
-        return E_FAIL;
-
-    if (offset > TGA_HEADER_LEN)
-    {
-    #ifdef _WIN32
-            // Skip past the id string
-        const LARGE_INTEGER filePos = { { static_cast<DWORD>(offset), 0 } };
-        if (!SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN))
-        {
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-    #else
-        inFile.seekg(offset, std::ios::beg);
-        if (!inFile)
-            return E_FAIL;
-    #endif
-    }
-
-    hr = image.Initialize2D(mdata.format, mdata.width, mdata.height, 1, 1);
-    if (FAILED(hr))
-        return hr;
-
-    assert(image.GetPixels());
-
-    bool opaquealpha = false;
-
-    if (!(convFlags & (CONV_FLAGS_RLE | CONV_FLAGS_EXPAND | CONV_FLAGS_INVERTX | CONV_FLAGS_PALETTED)) && (convFlags & CONV_FLAGS_INVERTY))
-    {
-        // This case we can read directly into the image buffer in place
-        if (remaining < image.GetPixelsSize())
-        {
-            image.Release();
-            return HRESULT_E_HANDLE_EOF;
-        }
-
-        if (image.GetPixelsSize() > UINT32_MAX)
-        {
-            image.Release();
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-        }
-
-    #ifdef _WIN32
-        if (!ReadFile(hFile.get(), image.GetPixels(), static_cast<DWORD>(image.GetPixelsSize()), &bytesRead, nullptr))
-        {
-            image.Release();
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesRead != image.GetPixelsSize())
-        {
-            image.Release();
-            return E_FAIL;
-        }
-    #else
-        inFile.read(reinterpret_cast<char*>(image.GetPixels()), image.GetPixelsSize());
-        if (!inFile)
-        {
-            image.Release();
-            return E_FAIL;
-        }
-    #endif
-
-        switch (mdata.format)
-        {
-        case DXGI_FORMAT_R8G8B8A8_UNORM:
-            {
-                // TGA stores 32-bit data in BGRA form, need to swizzle to RGBA
-                assert(image.GetImageCount() == 1);
-                const Image* img = image.GetImage(0, 0, 0);
-                if (!img)
-                {
-                    image.Release();
-                    return E_POINTER;
-                }
-
-                uint8_t *pPixels = img->pixels;
-                if (!pPixels)
-                {
-                    image.Release();
-                    return E_POINTER;
-                }
-
-                size_t rowPitch = img->rowPitch;
-
-                // Scan for non-zero alpha channel
-                uint32_t minalpha = 255;
-                uint32_t maxalpha = 0;
-
-                for (size_t h = 0; h < img->height; ++h)
-                {
-                    auto sPtr = reinterpret_cast<const uint32_t*>(pPixels);
-
-                    for (size_t x = 0; x < img->width; ++x)
-                    {
-                        const uint32_t alpha = ((*sPtr & 0xFF000000) >> 24);
-
-                        minalpha = std::min(minalpha, alpha);
-                        maxalpha = std::max(maxalpha, alpha);
-
-                        ++sPtr;
-                    }
-
-                    pPixels += rowPitch;
-                }
-
-                uint32_t tflags = TEXP_SCANLINE_NONE;
-                if (maxalpha == 0 && !(flags & TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA))
-                {
-                    opaquealpha = true;
-                    tflags = TEXP_SCANLINE_SETALPHA;
-                }
-                else if (minalpha == 255)
-                {
-                    opaquealpha = true;
-                }
-
-                // Swizzle scanlines
-                pPixels = img->pixels;
-
-                for (size_t h = 0; h < img->height; ++h)
-                {
-                    SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, mdata.format, tflags);
-                    pPixels += rowPitch;
-                }
-            }
-            break;
-
-        case DXGI_FORMAT_B8G8R8A8_UNORM:
-            {
-                assert(image.GetImageCount() == 1);
-                const Image* img = image.GetImage(0, 0, 0);
-                if (!img)
-                {
-                    image.Release();
-                    return E_POINTER;
-                }
-
-                // Scan for non-zero alpha channel
-                uint32_t minalpha = 255;
-                uint32_t maxalpha = 0;
-
-                const uint8_t *pPixels = img->pixels;
-                if (!pPixels)
-                {
-                    image.Release();
-                    return E_POINTER;
-                }
-
-                const size_t rowPitch = img->rowPitch;
-
-                for (size_t h = 0; h < img->height; ++h)
-                {
-                    auto sPtr = reinterpret_cast<const uint32_t*>(pPixels);
-
-                    for (size_t x = 0; x < img->width; ++x)
-                    {
-                        const uint32_t alpha = ((*sPtr & 0xFF000000) >> 24);
-
-                        minalpha = std::min(minalpha, alpha);
-                        maxalpha = std::max(maxalpha, alpha);
-
-                        ++sPtr;
-                    }
-
-                    pPixels += rowPitch;
-                }
-
-                // If there are no non-zero alpha channel entries, we'll assume alpha is not used and force it to opaque
-                if (maxalpha == 0 && !(flags & TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA))
-                {
-                    opaquealpha = true;
-                    hr = SetAlphaChannelToOpaque(img);
-                    if (FAILED(hr))
-                    {
-                        image.Release();
-                        return hr;
-                    }
-                }
-                else if (minalpha == 255)
-                {
-                    opaquealpha = true;
-                }
-            }
-            break;
-
-        case DXGI_FORMAT_B5G5R5A1_UNORM:
-            {
-                assert(image.GetImageCount() == 1);
-                const Image* img = image.GetImage(0, 0, 0);
-                if (!img)
-                {
-                    image.Release();
-                    return E_POINTER;
-                }
-
-                // Scan for non-zero alpha channel
-                uint32_t minalpha = 255;
-                uint32_t maxalpha = 0;
-
-                const uint8_t *pPixels = img->pixels;
-                if (!pPixels)
-                {
-                    image.Release();
-                    return E_POINTER;
-                }
-
-                const size_t rowPitch = img->rowPitch;
-
-                for (size_t h = 0; h < img->height; ++h)
-                {
-                    auto sPtr = reinterpret_cast<const uint16_t*>(pPixels);
-
-                    for (size_t x = 0; x < img->width; ++x)
-                    {
-                        const uint32_t alpha = (*sPtr & 0x8000) ? 255 : 0;
-
-                        minalpha = std::min(minalpha, alpha);
-                        maxalpha = std::max(maxalpha, alpha);
-
-                        ++sPtr;
-                    }
-
-                    pPixels += rowPitch;
-                }
-
-                // If there are no non-zero alpha channel entries, we'll assume alpha is not used and force it to opaque
-                if (maxalpha == 0 && !(flags & TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA))
-                {
-                    opaquealpha = true;
-                    hr = SetAlphaChannelToOpaque(img);
-                    if (FAILED(hr))
-                    {
-                        image.Release();
-                        return hr;
-                    }
-                }
-                else if (minalpha == 255)
-                {
-                    opaquealpha = true;
-                }
-            }
-            break;
-
-        case DXGI_FORMAT_B8G8R8X8_UNORM:
-            // Should never be trying to direct-read 24bpp
-            return E_FAIL;
-
-        default:
-            break;
-        }
-    }
-    else // RLE || EXPAND || INVERTX || PALETTED || !INVERTY
-    {
-        std::unique_ptr<uint8_t[]> temp(new (std::nothrow) uint8_t[remaining]);
-        if (!temp)
-        {
-            image.Release();
-            return E_OUTOFMEMORY;
-        }
-
-    #ifdef _WIN32
-        if (!ReadFile(hFile.get(), temp.get(), static_cast<DWORD>(remaining), &bytesRead, nullptr))
-        {
-            image.Release();
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesRead != remaining)
-        {
-            image.Release();
-            return E_FAIL;
-        }
-    #else
-        inFile.read(reinterpret_cast<char*>(temp.get()), remaining);
-        if (!inFile)
-        {
-            image.Release();
-            return E_FAIL;
-        }
-    #endif
-
-        size_t paletteOffset = 0;
-        uint8_t palette[256 * 4] = {};
-        if (convFlags & CONV_FLAGS_PALETTED)
-        {
-            hr = ReadPalette(header, temp.get(), remaining, flags, palette, paletteOffset);
-            if (FAILED(hr))
-            {
-                image.Release();
-                return hr;
-            }
-        }
-
-        if (convFlags & CONV_FLAGS_RLE)
-        {
-            hr = UncompressPixels(temp.get() + paletteOffset, remaining - paletteOffset,
-                flags, image.GetImage(0, 0, 0), convFlags);
-        }
-        else
-        {
-            hr = CopyPixels(temp.get() + paletteOffset, remaining - paletteOffset,
-                flags, image.GetImage(0, 0, 0), convFlags, palette);
-        }
-
-        if (FAILED(hr))
-        {
-            image.Release();
-            return hr;
-        }
-
-        if (hr == S_FALSE)
-            opaquealpha = true;
-    }
-
-    // Optional TGA 2.0 footer & extension area
-    const TGA_EXTENSION* ext = nullptr;
-    TGA_EXTENSION extData = {};
-    {
-        TGA_FOOTER footer = {};
-
-    #ifdef _WIN32
-        if (SetFilePointer(hFile.get(), -static_cast<int>(sizeof(TGA_FOOTER)), nullptr, FILE_END) != INVALID_SET_FILE_POINTER)
-        {
-            if (!ReadFile(hFile.get(), &footer, sizeof(TGA_FOOTER), &bytesRead, nullptr))
-            {
-                image.Release();
-                return HRESULT_FROM_WIN32(GetLastError());
-            }
-
-            if (bytesRead != sizeof(TGA_FOOTER))
-            {
-                image.Release();
-                return E_FAIL;
-            }
-        }
-    #else // !WIN32
-        inFile.seekg(-static_cast<int>(sizeof(TGA_FOOTER)), std::ios::end);
-        if (inFile)
-        {
-            inFile.read(reinterpret_cast<char*>(&footer), sizeof(TGA_FOOTER));
-            if (!inFile)
-            {
-                image.Release();
-                return E_FAIL;
-            }
-        }
-    #endif
-
-        if (memcmp(footer.Signature, g_Signature, sizeof(g_Signature)) == 0)
-        {
-            if (footer.dwExtensionOffset != 0
-                && ((footer.dwExtensionOffset + sizeof(TGA_EXTENSION)) <= len))
-            {
-            #ifdef _WIN32
-                const LARGE_INTEGER filePos = { { static_cast<DWORD>(footer.dwExtensionOffset), 0 } };
-                if (SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN))
-                {
-                    if (ReadFile(hFile.get(), &extData, sizeof(TGA_EXTENSION), &bytesRead, nullptr)
-                        && bytesRead == sizeof(TGA_EXTENSION))
-                    {
-                        ext = &extData;
-                    }
-                }
-            #else // !WIN32
-                inFile.seekg(static_cast<std::streampos>(footer.dwExtensionOffset), std::ios::beg);
-                if (inFile)
-                {
-                    inFile.read(reinterpret_cast<char*>(&extData), sizeof(TGA_EXTENSION));
-                    if (inFile)
-                    {
-                        ext = &extData;
-                    }
-                }
-            #endif
-            }
-        }
-    }
-
-    if (!(flags & TGA_FLAGS_IGNORE_SRGB))
-    {
-        mdata.format = GetSRGBFromExtension(ext, mdata.format, flags, &image);
-    }
-
-    if (metadata)
-    {
-        memcpy(metadata, &mdata, sizeof(TexMetadata));
-        if (opaquealpha)
-        {
-            metadata->SetAlphaMode(TEX_ALPHA_MODE_OPAQUE);
-        }
-        else if (ext)
-        {
-            metadata->SetAlphaMode(GetAlphaModeFromExtension(ext));
-        }
-    }
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a TGA file to memory
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::SaveToTGAMemory(
-    const Image& image,
-    TGA_FLAGS flags,
-    Blob& blob,
-    const TexMetadata* metadata) noexcept
-{
-    if ((flags & (TGA_FLAGS_FORCE_LINEAR | TGA_FLAGS_FORCE_SRGB)) != 0 && !metadata)
-        return E_INVALIDARG;
-
-    if (!image.pixels)
-        return E_POINTER;
-
-    TGA_HEADER tga_header = {};
-    uint32_t convFlags = 0;
-    HRESULT hr = EncodeTGAHeader(image, tga_header, convFlags);
-    if (FAILED(hr))
-        return hr;
-
-    blob.Release();
-
-    // Determine memory required for image data
-    size_t rowPitch, slicePitch;
-    hr = ComputePitch(image.format, image.width, image.height, rowPitch, slicePitch,
-        (convFlags & CONV_FLAGS_888) ? CP_FLAGS_24BPP : CP_FLAGS_NONE);
-    if (FAILED(hr))
-        return hr;
-
-    hr = blob.Initialize(TGA_HEADER_LEN
-        + slicePitch
-        + (metadata ? sizeof(TGA_EXTENSION) : 0)
-        + sizeof(TGA_FOOTER));
-    if (FAILED(hr))
-        return hr;
-
-    // Copy header
-    auto destPtr = static_cast<uint8_t*>(blob.GetBufferPointer());
-    assert(destPtr  != nullptr);
-
-    uint8_t* dPtr = destPtr;
-    memcpy(dPtr, &tga_header, TGA_HEADER_LEN);
-    dPtr += TGA_HEADER_LEN;
-
-    const uint8_t* pPixels = image.pixels;
-    assert(pPixels);
-
-    for (size_t y = 0; y < image.height; ++y)
-    {
-        // Copy pixels
-        if (convFlags & CONV_FLAGS_888)
-        {
-            Copy24bppScanline(dPtr, rowPitch, pPixels, image.rowPitch);
-        }
-        else if (convFlags & CONV_FLAGS_SWIZZLE)
-        {
-            SwizzleScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
-        }
-        else
-        {
-            CopyScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
-        }
-
-        dPtr += rowPitch;
-        pPixels += image.rowPitch;
-    }
-
-    uint32_t extOffset = 0;
-    if (metadata)
-    {
-        // metadata is only used for writing the TGA 2.0 extension header
-        auto ext = reinterpret_cast<TGA_EXTENSION*>(dPtr);
-        SetExtension(ext, flags, *metadata);
-
-        extOffset = static_cast<uint32_t>(dPtr - destPtr);
-        dPtr += sizeof(TGA_EXTENSION);
-    }
-
-    // Copy TGA 2.0 footer
-    auto footer = reinterpret_cast<TGA_FOOTER*>(dPtr);
-    footer->dwDeveloperOffset = 0;
-    footer->dwExtensionOffset = extOffset;
-    memcpy(footer->Signature, g_Signature, sizeof(g_Signature));
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a TGA file to disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::SaveToTGAFile(
-    const Image& image,
-    TGA_FLAGS flags,
-    const wchar_t* szFile,
-    const TexMetadata* metadata) noexcept
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-    if ((flags & (TGA_FLAGS_FORCE_LINEAR | TGA_FLAGS_FORCE_SRGB)) != 0 && !metadata)
-        return E_INVALIDARG;
-
-    if (!image.pixels)
-        return E_POINTER;
-
-    TGA_HEADER tga_header = {};
-    uint32_t convFlags = 0;
-    HRESULT hr = EncodeTGAHeader(image, tga_header, convFlags);
-    if (FAILED(hr))
-        return hr;
-
-    // Create file and write header
-#ifdef _WIN32
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
-    ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_WRITE, 0,
-        CREATE_ALWAYS, nullptr)));
-#else
-    ScopedHandle hFile(safe_handle(CreateFileW(szFile,
-        GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr)));
-#endif
-    if (!hFile)
-    {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-
-    auto_delete_file delonfail(hFile.get());
-#else
-    std::ofstream outFile(std::filesystem::path(szFile), std::ios::out | std::ios::binary | std::ios::trunc);
-    if (!outFile)
-        return E_FAIL;
-#endif
-
-    // Determine size for TGA pixel data
-    size_t rowPitch, slicePitch;
-    hr = ComputePitch(image.format, image.width, image.height, rowPitch, slicePitch,
-        (convFlags & CONV_FLAGS_888) ? CP_FLAGS_24BPP : CP_FLAGS_NONE);
-    if (FAILED(hr))
-        return hr;
-
-    if (slicePitch < 65535)
-    {
-        // For small images, it is better to create an in-memory file and write it out
-        Blob blob;
-
-        hr = SaveToTGAMemory(image, flags, blob, metadata);
-        if (FAILED(hr))
-            return hr;
-
-        // Write blob
-    #ifdef _WIN32
-        const DWORD bytesToWrite = static_cast<DWORD>(blob.GetBufferSize());
-        DWORD bytesWritten;
-        if (!WriteFile(hFile.get(), blob.GetBufferPointer(), bytesToWrite, &bytesWritten, nullptr))
-        {
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesWritten != bytesToWrite)
-        {
-            return E_FAIL;
-        }
-    #else
-        outFile.write(reinterpret_cast<char*>(blob.GetBufferPointer()),
-            static_cast<std::streamsize>(blob.GetBufferSize()));
-
-        if (!outFile)
-            return E_FAIL;
-    #endif
-    }
-    else
-    {
-        // Otherwise, write the image one scanline at a time...
-        std::unique_ptr<uint8_t[]> temp(new (std::nothrow) uint8_t[rowPitch]);
-        if (!temp)
-            return E_OUTOFMEMORY;
-
-        // Write header
-    #ifdef _WIN32
-        DWORD bytesWritten;
-        if (!WriteFile(hFile.get(), &tga_header, TGA_HEADER_LEN, &bytesWritten, nullptr))
-        {
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesWritten != TGA_HEADER_LEN)
-            return E_FAIL;
-    #else
-        outFile.write(reinterpret_cast<char*>(&tga_header), TGA_HEADER_LEN);
-        if (!outFile)
-            return E_FAIL;
-    #endif
-
-        if (rowPitch > UINT32_MAX)
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-        // Write pixels
-        const uint8_t* pPixels = image.pixels;
-
-        for (size_t y = 0; y < image.height; ++y)
-        {
-            // Copy pixels
-            if (convFlags & CONV_FLAGS_888)
-            {
-                Copy24bppScanline(temp.get(), rowPitch, pPixels, image.rowPitch);
-            }
-            else if (convFlags & CONV_FLAGS_SWIZZLE)
-            {
-                SwizzleScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
-            }
-            else
-            {
-                CopyScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
-            }
-
-            pPixels += image.rowPitch;
-
-        #ifdef _WIN32
-            if (!WriteFile(hFile.get(), temp.get(), static_cast<DWORD>(rowPitch), &bytesWritten, nullptr))
-            {
-                return HRESULT_FROM_WIN32(GetLastError());
-            }
-
-            if (bytesWritten != rowPitch)
-                return E_FAIL;
-        #else
-            outFile.write(reinterpret_cast<char*>(temp.get()), rowPitch);
-            if (!outFile)
-                return E_FAIL;
-        #endif
-        }
-
-        uint32_t extOffset = 0;
-        if (metadata)
-        {
-            // metadata is only used for writing the TGA 2.0 extension header
-            TGA_EXTENSION ext = {};
-            SetExtension(&ext, flags, *metadata);
-
-        #ifdef _WIN32
-            extOffset = SetFilePointer(hFile.get(), 0, nullptr, FILE_CURRENT);
-            if (extOffset == INVALID_SET_FILE_POINTER)
-            {
-                return E_FAIL;
-            }
-
-            if (!WriteFile(hFile.get(), &ext, sizeof(TGA_EXTENSION), &bytesWritten, nullptr))
-            {
-                return HRESULT_FROM_WIN32(GetLastError());
-            }
-
-            if (bytesWritten != sizeof(TGA_EXTENSION))
-                return E_FAIL;
-        #else
-            extOffset = static_cast<uint32_t>(outFile.tellp());
-            if (!outFile)
-                return E_FAIL;
-
-            outFile.write(reinterpret_cast<char*>(&ext), sizeof(TGA_EXTENSION));
-            if (!outFile)
-                return E_FAIL;
-        #endif
-        }
-
-        // Write TGA 2.0 footer
-        TGA_FOOTER footer = {};
-        footer.dwExtensionOffset = extOffset;
-        memcpy(footer.Signature, g_Signature, sizeof(g_Signature));
-
-    #ifdef _WIN32
-        if (!WriteFile(hFile.get(), &footer, sizeof(TGA_FOOTER), &bytesWritten, nullptr))
-        {
-            return HRESULT_FROM_WIN32(GetLastError());
-        }
-
-        if (bytesWritten != sizeof(footer))
-            return E_FAIL;
-    #else
-        outFile.write(reinterpret_cast<char*>(&footer), sizeof(TGA_FOOTER));
-        if (!outFile)
-            return E_FAIL;
-    #endif
-    }
-
-#ifdef _WIN32
-    delonfail.clear();
-#endif
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexUtil.cpp b/thirdparty/directxtex/DirectXTexUtil.cpp
deleted file mode 100644
index ea24728..0000000
--- a/thirdparty/directxtex/DirectXTexUtil.cpp
+++ /dev/null
@@ -1,1575 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexUtil.cpp
-//
-// DirectX Texture Library - Utilities
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
-static_assert(XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT == DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT, "Xbox mismatch detected");
-static_assert(XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT == DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT, "Xbox mismatch detected");
-static_assert(XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT == DXGI_FORMAT_D16_UNORM_S8_UINT, "Xbox mismatch detected");
-static_assert(XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS == DXGI_FORMAT_R16_UNORM_X8_TYPELESS, "Xbox mismatch detected");
-static_assert(XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT == DXGI_FORMAT_X16_TYPELESS_G8_UINT, "Xbox mismatch detected");
-static_assert(XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM == DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM, "Xbox mismatch detected");
-static_assert(XBOX_DXGI_FORMAT_R4G4_UNORM == DXGI_FORMAT_R4G4_UNORM, "Xbox mismatch detected");
-#endif
-
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
-static_assert(WIN10_DXGI_FORMAT_P208 == DXGI_FORMAT_P208, "Windows SDK mismatch detected");
-static_assert(WIN10_DXGI_FORMAT_V208 == DXGI_FORMAT_V208, "Windows SDK mismatch detected");
-static_assert(WIN10_DXGI_FORMAT_V408 == DXGI_FORMAT_V408, "Windows SDK mismatch detected");
-#endif
-
-using namespace DirectX;
-using Microsoft::WRL::ComPtr;
-
-namespace
-{
-#ifdef _WIN32
-    //-------------------------------------------------------------------------------------
-    // WIC Pixel Format Translation Data
-    //-------------------------------------------------------------------------------------
-    struct WICTranslate
-    {
-        const GUID& wic;
-        DXGI_FORMAT format;
-        bool        srgb;
-    };
-
-    constexpr WICTranslate g_WICFormats[] =
-    {
-        { GUID_WICPixelFormat128bppRGBAFloat,       DXGI_FORMAT_R32G32B32A32_FLOAT,         false },
-
-        { GUID_WICPixelFormat64bppRGBAHalf,         DXGI_FORMAT_R16G16B16A16_FLOAT,         false },
-        { GUID_WICPixelFormat64bppRGBA,             DXGI_FORMAT_R16G16B16A16_UNORM,         true },
-
-        { GUID_WICPixelFormat32bppRGBA,             DXGI_FORMAT_R8G8B8A8_UNORM,             true },
-        { GUID_WICPixelFormat32bppBGRA,             DXGI_FORMAT_B8G8R8A8_UNORM,             true }, // DXGI 1.1
-        { GUID_WICPixelFormat32bppBGR,              DXGI_FORMAT_B8G8R8X8_UNORM,             true }, // DXGI 1.1
-
-        { GUID_WICPixelFormat32bppRGBA1010102XR,    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM, true }, // DXGI 1.1
-        { GUID_WICPixelFormat32bppRGBA1010102,      DXGI_FORMAT_R10G10B10A2_UNORM,          true },
-
-        { GUID_WICPixelFormat16bppBGRA5551,         DXGI_FORMAT_B5G5R5A1_UNORM,             true },
-        { GUID_WICPixelFormat16bppBGR565,           DXGI_FORMAT_B5G6R5_UNORM,               true },
-
-        { GUID_WICPixelFormat32bppGrayFloat,        DXGI_FORMAT_R32_FLOAT,                  false },
-        { GUID_WICPixelFormat16bppGrayHalf,         DXGI_FORMAT_R16_FLOAT,                  false },
-        { GUID_WICPixelFormat16bppGray,             DXGI_FORMAT_R16_UNORM,                  true },
-        { GUID_WICPixelFormat8bppGray,              DXGI_FORMAT_R8_UNORM,                   true },
-
-        { GUID_WICPixelFormat8bppAlpha,             DXGI_FORMAT_A8_UNORM,                   false },
-
-        { GUID_WICPixelFormatBlackWhite,            DXGI_FORMAT_R1_UNORM,                   false },
-    };
-
-    bool g_WIC2 = false;
-    IWICImagingFactory* g_Factory = nullptr;
-
-    BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID *ifactory) noexcept
-    {
-    #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
-        HRESULT hr = CoCreateInstance(
-            CLSID_WICImagingFactory2,
-            nullptr,
-            CLSCTX_INPROC_SERVER,
-            __uuidof(IWICImagingFactory2),
-            ifactory
-        );
-
-        if (SUCCEEDED(hr))
-        {
-            // WIC2 is available on Windows 10, Windows 8.x, and Windows 7 SP1 with KB 2670838 installed
-            g_WIC2 = true;
-            return TRUE;
-        }
-        else
-        {
-            g_WIC2 = false;
-
-            hr = CoCreateInstance(
-                CLSID_WICImagingFactory1,
-                nullptr,
-                CLSCTX_INPROC_SERVER,
-                __uuidof(IWICImagingFactory),
-                ifactory
-            );
-            return SUCCEEDED(hr) ? TRUE : FALSE;
-        }
-    #else
-        g_WIC2 = false;
-
-        return SUCCEEDED(CoCreateInstance(
-            CLSID_WICImagingFactory,
-            nullptr,
-            CLSCTX_INPROC_SERVER,
-            __uuidof(IWICImagingFactory),
-            ifactory)) ? TRUE : FALSE;
-    #endif
-    }
-
-#else // !WIN32
-    inline void * _aligned_malloc(size_t size, size_t alignment)
-    {
-        size = (size + alignment - 1) & ~(alignment - 1);
-        return std::aligned_alloc(alignment, size);
-    }
-
-#define _aligned_free free
-#endif
-}
-
-
-#ifdef _WIN32
-//=====================================================================================
-// WIC Utilities
-//=====================================================================================
-
-_Use_decl_annotations_
-DXGI_FORMAT DirectX::Internal::WICToDXGI(const GUID& guid) noexcept
-{
-    for (size_t i = 0; i < std::size(g_WICFormats); ++i)
-    {
-        if (memcmp(&g_WICFormats[i].wic, &guid, sizeof(GUID)) == 0)
-            return g_WICFormats[i].format;
-    }
-
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
-    if (g_WIC2)
-    {
-        if (memcmp(&GUID_WICPixelFormat96bppRGBFloat, &guid, sizeof(GUID)) == 0)
-            return DXGI_FORMAT_R32G32B32_FLOAT;
-    }
-#endif
-
-    return DXGI_FORMAT_UNKNOWN;
-}
-
-_Use_decl_annotations_
-bool DirectX::Internal::DXGIToWIC(DXGI_FORMAT format, GUID& guid, bool ignoreRGBvsBGR) noexcept
-{
-    switch (format)
-    {
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-        if (ignoreRGBvsBGR)
-        {
-            // If we are not doing conversion so don't really care about BGR vs RGB color-order,
-            // we can use the canonical WIC 32bppBGRA format which avoids an extra format conversion when using the WIC scaler
-            memcpy(&guid, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
-        }
-        else
-        {
-            memcpy(&guid, &GUID_WICPixelFormat32bppRGBA, sizeof(GUID));
-        }
-        return true;
-
-    case DXGI_FORMAT_D32_FLOAT:
-        memcpy(&guid, &GUID_WICPixelFormat32bppGrayFloat, sizeof(GUID));
-        return true;
-
-    case DXGI_FORMAT_D16_UNORM:
-        memcpy(&guid, &GUID_WICPixelFormat16bppGray, sizeof(GUID));
-        return true;
-
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        memcpy(&guid, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
-        return true;
-
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        memcpy(&guid, &GUID_WICPixelFormat32bppBGR, sizeof(GUID));
-        return true;
-
-    #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-        if (g_WIC2)
-        {
-            memcpy(&guid, &GUID_WICPixelFormat96bppRGBFloat, sizeof(GUID));
-            return true;
-        }
-        break;
-    #endif
-
-    default:
-        for (size_t i = 0; i < std::size(g_WICFormats); ++i)
-        {
-            if (g_WICFormats[i].format == format)
-            {
-                memcpy(&guid, &g_WICFormats[i].wic, sizeof(GUID));
-                return true;
-            }
-        }
-        break;
-    }
-
-    memset(&guid, 0, sizeof(GUID));
-    return false;
-}
-
-TEX_FILTER_FLAGS DirectX::Internal::CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept
-{
-    TEX_FILTER_FLAGS srgb = TEX_FILTER_DEFAULT;
-
-    for (size_t i = 0; i < std::size(g_WICFormats); ++i)
-    {
-        if (memcmp(&g_WICFormats[i].wic, &sourceGUID, sizeof(GUID)) == 0)
-        {
-            if (g_WICFormats[i].srgb)
-                srgb |= TEX_FILTER_SRGB_IN;
-        }
-
-        if (memcmp(&g_WICFormats[i].wic, &targetGUID, sizeof(GUID)) == 0)
-        {
-            if (g_WICFormats[i].srgb)
-                srgb |= TEX_FILTER_SRGB_OUT;
-        }
-    }
-
-    if ((srgb & (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT)) == (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT))
-    {
-        srgb &= ~(TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT);
-    }
-
-    return srgb;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Public helper function to get common WIC codec GUIDs
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-REFGUID DirectX::GetWICCodec(WICCodecs codec) noexcept
-{
-    switch (codec)
-    {
-    case WIC_CODEC_BMP:
-        return GUID_ContainerFormatBmp;
-
-    case WIC_CODEC_JPEG:
-        return GUID_ContainerFormatJpeg;
-
-    case WIC_CODEC_PNG:
-        return GUID_ContainerFormatPng;
-
-    case WIC_CODEC_TIFF:
-        return GUID_ContainerFormatTiff;
-
-    case WIC_CODEC_GIF:
-        return GUID_ContainerFormatGif;
-
-    case WIC_CODEC_WMP:
-        return GUID_ContainerFormatWmp;
-
-    case WIC_CODEC_ICO:
-        return GUID_ContainerFormatIco;
-
-#ifdef NTDDI_WIN10_RS4
-    case WIC_CODEC_HEIF:
-        // This requires installing https://aka.ms/heif
-        return GUID_ContainerFormatHeif;
-#endif
-
-    default:
-        return GUID_NULL;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Singleton function for WIC factory
-//-------------------------------------------------------------------------------------
-IWICImagingFactory* DirectX::GetWICFactory(bool& iswic2) noexcept
-{
-    if (g_Factory)
-    {
-        iswic2 = g_WIC2;
-        return g_Factory;
-    }
-
-    static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
-
-    if (!InitOnceExecuteOnce(&s_initOnce,
-        InitializeWICFactory,
-        nullptr,
-        reinterpret_cast<LPVOID*>(&g_Factory)))
-    {
-        return nullptr;
-    }
-
-    iswic2 = g_WIC2;
-    return g_Factory;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Optional initializer for WIC factory
-//-------------------------------------------------------------------------------------
-void DirectX::SetWICFactory(_In_opt_ IWICImagingFactory* pWIC) noexcept
-{
-    if (pWIC == g_Factory)
-        return;
-
-    bool iswic2 = false;
-    if (pWIC)
-    {
-    #if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
-        ComPtr<IWICImagingFactory2> wic2;
-        HRESULT hr = pWIC->QueryInterface(IID_PPV_ARGS(wic2.GetAddressOf()));
-        if (SUCCEEDED(hr))
-        {
-            iswic2 = true;
-        }
-    #endif
-        pWIC->AddRef();
-    }
-
-    g_WIC2 = iswic2;
-    std::swap(pWIC, g_Factory);
-    if (pWIC)
-        pWIC->Release();
-}
-#endif // WIN32
-
-
-//=====================================================================================
-// DXGI Format Utilities
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::IsPacked(DXGI_FORMAT fmt) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_R8G8_B8G8_UNORM:
-    case DXGI_FORMAT_G8R8_G8B8_UNORM:
-    case DXGI_FORMAT_YUY2: // 4:2:2 8-bit
-    case DXGI_FORMAT_Y210: // 4:2:2 10-bit
-    case DXGI_FORMAT_Y216: // 4:2:2 16-bit
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::IsVideo(DXGI_FORMAT fmt) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_AYUV:
-    case DXGI_FORMAT_Y410:
-    case DXGI_FORMAT_Y416:
-    case DXGI_FORMAT_NV12:
-    case DXGI_FORMAT_P010:
-    case DXGI_FORMAT_P016:
-    case DXGI_FORMAT_YUY2:
-    case DXGI_FORMAT_Y210:
-    case DXGI_FORMAT_Y216:
-    case DXGI_FORMAT_NV11:
-        // These video formats can be used with the 3D pipeline through special view mappings
-
-    case DXGI_FORMAT_420_OPAQUE:
-    case DXGI_FORMAT_AI44:
-    case DXGI_FORMAT_IA44:
-    case DXGI_FORMAT_P8:
-    case DXGI_FORMAT_A8P8:
-        // These are limited use video formats not usable in any way by the 3D pipeline
-
-    case WIN10_DXGI_FORMAT_P208:
-    case WIN10_DXGI_FORMAT_V208:
-    case WIN10_DXGI_FORMAT_V408:
-        // These video formats are for JPEG Hardware decode (DXGI 1.4)
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::IsPlanar(DXGI_FORMAT fmt) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_NV12:      // 4:2:0 8-bit
-    case DXGI_FORMAT_P010:      // 4:2:0 10-bit
-    case DXGI_FORMAT_P016:      // 4:2:0 16-bit
-    case DXGI_FORMAT_420_OPAQUE:// 4:2:0 8-bit
-    case DXGI_FORMAT_NV11:      // 4:1:1 8-bit
-
-    case WIN10_DXGI_FORMAT_P208: // 4:2:2 8-bit
-    case WIN10_DXGI_FORMAT_V208: // 4:4:0 8-bit
-    case WIN10_DXGI_FORMAT_V408: // 4:4:4 8-bit
-        // These are JPEG Hardware decode formats (DXGI 1.4)
-
-    case XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT:
-    case XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
-    case XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT:
-        // These are Xbox One platform specific types
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::IsDepthStencil(DXGI_FORMAT fmt) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_R32G8X24_TYPELESS:
-    case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
-    case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
-    case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
-    case DXGI_FORMAT_D32_FLOAT:
-    case DXGI_FORMAT_R24G8_TYPELESS:
-    case DXGI_FORMAT_D24_UNORM_S8_UINT:
-    case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
-    case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
-    case DXGI_FORMAT_D16_UNORM:
-    case XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT:
-    case XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
-    case XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT:
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::IsTypeless(DXGI_FORMAT fmt, bool partialTypeless) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_R32G32B32A32_TYPELESS:
-    case DXGI_FORMAT_R32G32B32_TYPELESS:
-    case DXGI_FORMAT_R16G16B16A16_TYPELESS:
-    case DXGI_FORMAT_R32G32_TYPELESS:
-    case DXGI_FORMAT_R32G8X24_TYPELESS:
-    case DXGI_FORMAT_R10G10B10A2_TYPELESS:
-    case DXGI_FORMAT_R8G8B8A8_TYPELESS:
-    case DXGI_FORMAT_R16G16_TYPELESS:
-    case DXGI_FORMAT_R32_TYPELESS:
-    case DXGI_FORMAT_R24G8_TYPELESS:
-    case DXGI_FORMAT_R8G8_TYPELESS:
-    case DXGI_FORMAT_R16_TYPELESS:
-    case DXGI_FORMAT_R8_TYPELESS:
-    case DXGI_FORMAT_BC1_TYPELESS:
-    case DXGI_FORMAT_BC2_TYPELESS:
-    case DXGI_FORMAT_BC3_TYPELESS:
-    case DXGI_FORMAT_BC4_TYPELESS:
-    case DXGI_FORMAT_BC5_TYPELESS:
-    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8X8_TYPELESS:
-    case DXGI_FORMAT_BC6H_TYPELESS:
-    case DXGI_FORMAT_BC7_TYPELESS:
-        return true;
-
-    case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
-    case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
-    case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
-    case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
-    case XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
-    case XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT:
-        return partialTypeless;
-
-    default:
-        return false;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-bool DirectX::HasAlpha(DXGI_FORMAT fmt) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_R32G32B32A32_TYPELESS:
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-    case DXGI_FORMAT_R32G32B32A32_UINT:
-    case DXGI_FORMAT_R32G32B32A32_SINT:
-    case DXGI_FORMAT_R16G16B16A16_TYPELESS:
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_UNORM:
-    case DXGI_FORMAT_R16G16B16A16_UINT:
-    case DXGI_FORMAT_R16G16B16A16_SNORM:
-    case DXGI_FORMAT_R16G16B16A16_SINT:
-    case DXGI_FORMAT_R10G10B10A2_TYPELESS:
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-    case DXGI_FORMAT_R10G10B10A2_UINT:
-    case DXGI_FORMAT_R8G8B8A8_TYPELESS:
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_R8G8B8A8_UINT:
-    case DXGI_FORMAT_R8G8B8A8_SNORM:
-    case DXGI_FORMAT_R8G8B8A8_SINT:
-    case DXGI_FORMAT_A8_UNORM:
-    case DXGI_FORMAT_BC1_TYPELESS:
-    case DXGI_FORMAT_BC1_UNORM:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-    case DXGI_FORMAT_BC2_TYPELESS:
-    case DXGI_FORMAT_BC2_UNORM:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-    case DXGI_FORMAT_BC3_TYPELESS:
-    case DXGI_FORMAT_BC3_UNORM:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_BC7_TYPELESS:
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-    case DXGI_FORMAT_AYUV:
-    case DXGI_FORMAT_Y410:
-    case DXGI_FORMAT_Y416:
-    case DXGI_FORMAT_AI44:
-    case DXGI_FORMAT_IA44:
-    case DXGI_FORMAT_A8P8:
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-    case XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT:
-    case XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT:
-    case XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM:
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Returns bits-per-pixel for a given DXGI format, or 0 on failure
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-size_t DirectX::BitsPerPixel(DXGI_FORMAT fmt) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_R32G32B32A32_TYPELESS:
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-    case DXGI_FORMAT_R32G32B32A32_UINT:
-    case DXGI_FORMAT_R32G32B32A32_SINT:
-        return 128;
-
-    case DXGI_FORMAT_R32G32B32_TYPELESS:
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-    case DXGI_FORMAT_R32G32B32_UINT:
-    case DXGI_FORMAT_R32G32B32_SINT:
-        return 96;
-
-    case DXGI_FORMAT_R16G16B16A16_TYPELESS:
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_UNORM:
-    case DXGI_FORMAT_R16G16B16A16_UINT:
-    case DXGI_FORMAT_R16G16B16A16_SNORM:
-    case DXGI_FORMAT_R16G16B16A16_SINT:
-    case DXGI_FORMAT_R32G32_TYPELESS:
-    case DXGI_FORMAT_R32G32_FLOAT:
-    case DXGI_FORMAT_R32G32_UINT:
-    case DXGI_FORMAT_R32G32_SINT:
-    case DXGI_FORMAT_R32G8X24_TYPELESS:
-    case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
-    case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
-    case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
-    case DXGI_FORMAT_Y416:
-    case DXGI_FORMAT_Y210:
-    case DXGI_FORMAT_Y216:
-        return 64;
-
-    case DXGI_FORMAT_R10G10B10A2_TYPELESS:
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-    case DXGI_FORMAT_R10G10B10A2_UINT:
-    case DXGI_FORMAT_R11G11B10_FLOAT:
-    case DXGI_FORMAT_R8G8B8A8_TYPELESS:
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_R8G8B8A8_UINT:
-    case DXGI_FORMAT_R8G8B8A8_SNORM:
-    case DXGI_FORMAT_R8G8B8A8_SINT:
-    case DXGI_FORMAT_R16G16_TYPELESS:
-    case DXGI_FORMAT_R16G16_FLOAT:
-    case DXGI_FORMAT_R16G16_UNORM:
-    case DXGI_FORMAT_R16G16_UINT:
-    case DXGI_FORMAT_R16G16_SNORM:
-    case DXGI_FORMAT_R16G16_SINT:
-    case DXGI_FORMAT_R32_TYPELESS:
-    case DXGI_FORMAT_D32_FLOAT:
-    case DXGI_FORMAT_R32_FLOAT:
-    case DXGI_FORMAT_R32_UINT:
-    case DXGI_FORMAT_R32_SINT:
-    case DXGI_FORMAT_R24G8_TYPELESS:
-    case DXGI_FORMAT_D24_UNORM_S8_UINT:
-    case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
-    case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
-    case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
-    case DXGI_FORMAT_R8G8_B8G8_UNORM:
-    case DXGI_FORMAT_G8R8_G8B8_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8X8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-    case DXGI_FORMAT_AYUV:
-    case DXGI_FORMAT_Y410:
-    case DXGI_FORMAT_YUY2:
-    case XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT:
-    case XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT:
-    case XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM:
-        return 32;
-
-    case DXGI_FORMAT_P010:
-    case DXGI_FORMAT_P016:
-    case XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT:
-    case XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
-    case XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT:
-    case WIN10_DXGI_FORMAT_V408:
-        return 24;
-
-    case DXGI_FORMAT_R8G8_TYPELESS:
-    case DXGI_FORMAT_R8G8_UNORM:
-    case DXGI_FORMAT_R8G8_UINT:
-    case DXGI_FORMAT_R8G8_SNORM:
-    case DXGI_FORMAT_R8G8_SINT:
-    case DXGI_FORMAT_R16_TYPELESS:
-    case DXGI_FORMAT_R16_FLOAT:
-    case DXGI_FORMAT_D16_UNORM:
-    case DXGI_FORMAT_R16_UNORM:
-    case DXGI_FORMAT_R16_UINT:
-    case DXGI_FORMAT_R16_SNORM:
-    case DXGI_FORMAT_R16_SINT:
-    case DXGI_FORMAT_B5G6R5_UNORM:
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-    case DXGI_FORMAT_A8P8:
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-    case WIN10_DXGI_FORMAT_P208:
-    case WIN10_DXGI_FORMAT_V208:
-        return 16;
-
-    case DXGI_FORMAT_NV12:
-    case DXGI_FORMAT_420_OPAQUE:
-    case DXGI_FORMAT_NV11:
-        return 12;
-
-    case DXGI_FORMAT_R8_TYPELESS:
-    case DXGI_FORMAT_R8_UNORM:
-    case DXGI_FORMAT_R8_UINT:
-    case DXGI_FORMAT_R8_SNORM:
-    case DXGI_FORMAT_R8_SINT:
-    case DXGI_FORMAT_A8_UNORM:
-    case DXGI_FORMAT_BC2_TYPELESS:
-    case DXGI_FORMAT_BC2_UNORM:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-    case DXGI_FORMAT_BC3_TYPELESS:
-    case DXGI_FORMAT_BC3_UNORM:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-    case DXGI_FORMAT_BC5_TYPELESS:
-    case DXGI_FORMAT_BC5_UNORM:
-    case DXGI_FORMAT_BC5_SNORM:
-    case DXGI_FORMAT_BC6H_TYPELESS:
-    case DXGI_FORMAT_BC6H_UF16:
-    case DXGI_FORMAT_BC6H_SF16:
-    case DXGI_FORMAT_BC7_TYPELESS:
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-    case DXGI_FORMAT_AI44:
-    case DXGI_FORMAT_IA44:
-    case DXGI_FORMAT_P8:
-    case XBOX_DXGI_FORMAT_R4G4_UNORM:
-        return 8;
-
-    case DXGI_FORMAT_R1_UNORM:
-        return 1;
-
-    case DXGI_FORMAT_BC1_TYPELESS:
-    case DXGI_FORMAT_BC1_UNORM:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-    case DXGI_FORMAT_BC4_TYPELESS:
-    case DXGI_FORMAT_BC4_UNORM:
-    case DXGI_FORMAT_BC4_SNORM:
-        return 4;
-
-    default:
-        return 0;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Returns bits-per-color-channel for a given DXGI format, or 0 on failure
-// For mixed formats, it returns the largest color-depth in the format
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-size_t DirectX::BitsPerColor(DXGI_FORMAT fmt) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_R32G32B32A32_TYPELESS:
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-    case DXGI_FORMAT_R32G32B32A32_UINT:
-    case DXGI_FORMAT_R32G32B32A32_SINT:
-    case DXGI_FORMAT_R32G32B32_TYPELESS:
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-    case DXGI_FORMAT_R32G32B32_UINT:
-    case DXGI_FORMAT_R32G32B32_SINT:
-    case DXGI_FORMAT_R32G32_TYPELESS:
-    case DXGI_FORMAT_R32G32_FLOAT:
-    case DXGI_FORMAT_R32G32_UINT:
-    case DXGI_FORMAT_R32G32_SINT:
-    case DXGI_FORMAT_R32G8X24_TYPELESS:
-    case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
-    case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
-    case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
-    case DXGI_FORMAT_R32_TYPELESS:
-    case DXGI_FORMAT_D32_FLOAT:
-    case DXGI_FORMAT_R32_FLOAT:
-    case DXGI_FORMAT_R32_UINT:
-    case DXGI_FORMAT_R32_SINT:
-        return 32;
-
-    case DXGI_FORMAT_R24G8_TYPELESS:
-    case DXGI_FORMAT_D24_UNORM_S8_UINT:
-    case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
-    case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
-        return 24;
-
-    case DXGI_FORMAT_R16G16B16A16_TYPELESS:
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_UNORM:
-    case DXGI_FORMAT_R16G16B16A16_UINT:
-    case DXGI_FORMAT_R16G16B16A16_SNORM:
-    case DXGI_FORMAT_R16G16B16A16_SINT:
-    case DXGI_FORMAT_R16G16_TYPELESS:
-    case DXGI_FORMAT_R16G16_FLOAT:
-    case DXGI_FORMAT_R16G16_UNORM:
-    case DXGI_FORMAT_R16G16_UINT:
-    case DXGI_FORMAT_R16G16_SNORM:
-    case DXGI_FORMAT_R16G16_SINT:
-    case DXGI_FORMAT_R16_TYPELESS:
-    case DXGI_FORMAT_R16_FLOAT:
-    case DXGI_FORMAT_D16_UNORM:
-    case DXGI_FORMAT_R16_UNORM:
-    case DXGI_FORMAT_R16_UINT:
-    case DXGI_FORMAT_R16_SNORM:
-    case DXGI_FORMAT_R16_SINT:
-    case DXGI_FORMAT_BC6H_TYPELESS:
-    case DXGI_FORMAT_BC6H_UF16:
-    case DXGI_FORMAT_BC6H_SF16:
-    case DXGI_FORMAT_Y416:
-    case DXGI_FORMAT_P016:
-    case DXGI_FORMAT_Y216:
-    case XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT:
-    case XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
-    case XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT:
-        return 16;
-
-    case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
-        return 14;
-
-    case DXGI_FORMAT_R11G11B10_FLOAT:
-        return 11;
-
-    case DXGI_FORMAT_R10G10B10A2_TYPELESS:
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-    case DXGI_FORMAT_R10G10B10A2_UINT:
-    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-    case DXGI_FORMAT_Y410:
-    case DXGI_FORMAT_P010:
-    case DXGI_FORMAT_Y210:
-    case XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT:
-    case XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT:
-    case XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM:
-        return 10;
-
-    case DXGI_FORMAT_R8G8B8A8_TYPELESS:
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_R8G8B8A8_UINT:
-    case DXGI_FORMAT_R8G8B8A8_SNORM:
-    case DXGI_FORMAT_R8G8B8A8_SINT:
-    case DXGI_FORMAT_R8G8_TYPELESS:
-    case DXGI_FORMAT_R8G8_UNORM:
-    case DXGI_FORMAT_R8G8_UINT:
-    case DXGI_FORMAT_R8G8_SNORM:
-    case DXGI_FORMAT_R8G8_SINT:
-    case DXGI_FORMAT_R8_TYPELESS:
-    case DXGI_FORMAT_R8_UNORM:
-    case DXGI_FORMAT_R8_UINT:
-    case DXGI_FORMAT_R8_SNORM:
-    case DXGI_FORMAT_R8_SINT:
-    case DXGI_FORMAT_A8_UNORM:
-    case DXGI_FORMAT_R8G8_B8G8_UNORM:
-    case DXGI_FORMAT_G8R8_G8B8_UNORM:
-    case DXGI_FORMAT_BC4_TYPELESS:
-    case DXGI_FORMAT_BC4_UNORM:
-    case DXGI_FORMAT_BC4_SNORM:
-    case DXGI_FORMAT_BC5_TYPELESS:
-    case DXGI_FORMAT_BC5_UNORM:
-    case DXGI_FORMAT_BC5_SNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-    case DXGI_FORMAT_B8G8R8X8_TYPELESS:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-    case DXGI_FORMAT_AYUV:
-    case DXGI_FORMAT_NV12:
-    case DXGI_FORMAT_420_OPAQUE:
-    case DXGI_FORMAT_YUY2:
-    case DXGI_FORMAT_NV11:
-    case WIN10_DXGI_FORMAT_P208:
-    case WIN10_DXGI_FORMAT_V208:
-    case WIN10_DXGI_FORMAT_V408:
-        return 8;
-
-    case DXGI_FORMAT_BC7_TYPELESS:
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        return 7;
-
-    case DXGI_FORMAT_BC1_TYPELESS:
-    case DXGI_FORMAT_BC1_UNORM:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-    case DXGI_FORMAT_BC2_TYPELESS:
-    case DXGI_FORMAT_BC2_UNORM:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-    case DXGI_FORMAT_BC3_TYPELESS:
-    case DXGI_FORMAT_BC3_UNORM:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-    case DXGI_FORMAT_B5G6R5_UNORM:
-        return 6;
-
-    case DXGI_FORMAT_B5G5R5A1_UNORM:
-        return 5;
-
-    case DXGI_FORMAT_B4G4R4A4_UNORM:
-    case XBOX_DXGI_FORMAT_R4G4_UNORM:
-        return 4;
-
-    case DXGI_FORMAT_R1_UNORM:
-        return 1;
-
-    case DXGI_FORMAT_AI44:
-    case DXGI_FORMAT_IA44:
-    case DXGI_FORMAT_P8:
-    case DXGI_FORMAT_A8P8:
-        // Palettized formats return 0 for this function
-
-    default:
-        return 0;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Computes the image row pitch in bytes, and the slice ptich (size in bytes of the image)
-// based on DXGI format, width, and height
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::ComputePitch(DXGI_FORMAT fmt, size_t width, size_t height,
-    size_t& rowPitch, size_t& slicePitch, CP_FLAGS flags) noexcept
-{
-    uint64_t pitch = 0;
-    uint64_t slice = 0;
-
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_BC1_TYPELESS:
-    case DXGI_FORMAT_BC1_UNORM:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-    case DXGI_FORMAT_BC4_TYPELESS:
-    case DXGI_FORMAT_BC4_UNORM:
-    case DXGI_FORMAT_BC4_SNORM:
-        assert(IsCompressed(fmt));
-        {
-            if (flags & CP_FLAGS_BAD_DXTN_TAILS)
-            {
-                const size_t nbw = width >> 2;
-                const size_t nbh = height >> 2;
-                pitch = std::max<uint64_t>(1u, uint64_t(nbw) * 8u);
-                slice = std::max<uint64_t>(1u, pitch * uint64_t(nbh));
-            }
-            else
-            {
-                const uint64_t nbw = std::max<uint64_t>(1u, (uint64_t(width) + 3u) / 4u);
-                const uint64_t nbh = std::max<uint64_t>(1u, (uint64_t(height) + 3u) / 4u);
-                pitch = nbw * 8u;
-                slice = pitch * nbh;
-            }
-        }
-        break;
-
-    case DXGI_FORMAT_BC2_TYPELESS:
-    case DXGI_FORMAT_BC2_UNORM:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-    case DXGI_FORMAT_BC3_TYPELESS:
-    case DXGI_FORMAT_BC3_UNORM:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-    case DXGI_FORMAT_BC5_TYPELESS:
-    case DXGI_FORMAT_BC5_UNORM:
-    case DXGI_FORMAT_BC5_SNORM:
-    case DXGI_FORMAT_BC6H_TYPELESS:
-    case DXGI_FORMAT_BC6H_UF16:
-    case DXGI_FORMAT_BC6H_SF16:
-    case DXGI_FORMAT_BC7_TYPELESS:
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        assert(IsCompressed(fmt));
-        {
-            if (flags & CP_FLAGS_BAD_DXTN_TAILS)
-            {
-                const size_t nbw = width >> 2;
-                const size_t nbh = height >> 2;
-                pitch = std::max<uint64_t>(1u, uint64_t(nbw) * 16u);
-                slice = std::max<uint64_t>(1u, pitch * uint64_t(nbh));
-            }
-            else
-            {
-                const uint64_t nbw = std::max<uint64_t>(1u, (uint64_t(width) + 3u) / 4u);
-                const uint64_t nbh = std::max<uint64_t>(1u, (uint64_t(height) + 3u) / 4u);
-                pitch = nbw * 16u;
-                slice = pitch * nbh;
-            }
-        }
-        break;
-
-    case DXGI_FORMAT_R8G8_B8G8_UNORM:
-    case DXGI_FORMAT_G8R8_G8B8_UNORM:
-    case DXGI_FORMAT_YUY2:
-        assert(IsPacked(fmt));
-        pitch = ((uint64_t(width) + 1u) >> 1) * 4u;
-        slice = pitch * uint64_t(height);
-        break;
-
-    case DXGI_FORMAT_Y210:
-    case DXGI_FORMAT_Y216:
-        assert(IsPacked(fmt));
-        pitch = ((uint64_t(width) + 1u) >> 1) * 8u;
-        slice = pitch * uint64_t(height);
-        break;
-
-    case DXGI_FORMAT_NV12:
-    case DXGI_FORMAT_420_OPAQUE:
-        assert(IsPlanar(fmt));
-        pitch = ((uint64_t(width) + 1u) >> 1) * 2u;
-        slice = pitch * (uint64_t(height) + ((uint64_t(height) + 1u) >> 1));
-        break;
-
-    case DXGI_FORMAT_P010:
-    case DXGI_FORMAT_P016:
-    case XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT:
-    case XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
-    case XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT:
-        assert(IsPlanar(fmt));
-        pitch = ((uint64_t(width) + 1u) >> 1) * 4u;
-        slice = pitch * (uint64_t(height) + ((uint64_t(height) + 1u) >> 1));
-        break;
-
-    case DXGI_FORMAT_NV11:
-        assert(IsPlanar(fmt));
-        pitch = ((uint64_t(width) + 3u) >> 2) * 4u;
-        slice = pitch * uint64_t(height) * 2u;
-        break;
-
-    case WIN10_DXGI_FORMAT_P208:
-        assert(IsPlanar(fmt));
-        pitch = ((uint64_t(width) + 1u) >> 1) * 2u;
-        slice = pitch * uint64_t(height) * 2u;
-        break;
-
-    case WIN10_DXGI_FORMAT_V208:
-        assert(IsPlanar(fmt));
-        pitch = uint64_t(width);
-        slice = pitch * (uint64_t(height) + (((uint64_t(height) + 1u) >> 1) * 2u));
-        break;
-
-    case WIN10_DXGI_FORMAT_V408:
-        assert(IsPlanar(fmt));
-        pitch = uint64_t(width);
-        slice = pitch * (uint64_t(height) + (uint64_t(height >> 1) * 4u));
-        break;
-
-    default:
-        assert(!IsCompressed(fmt) && !IsPacked(fmt) && !IsPlanar(fmt));
-        {
-            size_t bpp;
-
-            if (flags & CP_FLAGS_24BPP)
-                bpp = 24;
-            else if (flags & CP_FLAGS_16BPP)
-                bpp = 16;
-            else if (flags & CP_FLAGS_8BPP)
-                bpp = 8;
-            else
-                bpp = BitsPerPixel(fmt);
-
-            if (!bpp)
-                return E_INVALIDARG;
-
-            if (flags & (CP_FLAGS_LEGACY_DWORD | CP_FLAGS_PARAGRAPH | CP_FLAGS_YMM | CP_FLAGS_ZMM | CP_FLAGS_PAGE4K))
-            {
-                if (flags & CP_FLAGS_PAGE4K)
-                {
-                    pitch = ((uint64_t(width) * bpp + 32767u) / 32768u) * 4096u;
-                    slice = pitch * uint64_t(height);
-                }
-                else if (flags & CP_FLAGS_ZMM)
-                {
-                    pitch = ((uint64_t(width) * bpp + 511u) / 512u) * 64u;
-                    slice = pitch * uint64_t(height);
-                }
-                else if (flags & CP_FLAGS_YMM)
-                {
-                    pitch = ((uint64_t(width) * bpp + 255u) / 256u) * 32u;
-                    slice = pitch * uint64_t(height);
-                }
-                else if (flags & CP_FLAGS_PARAGRAPH)
-                {
-                    pitch = ((uint64_t(width) * bpp + 127u) / 128u) * 16u;
-                    slice = pitch * uint64_t(height);
-                }
-                else // DWORD alignment
-                {
-                    // Special computation for some incorrectly created DDS files based on
-                    // legacy DirectDraw assumptions about pitch alignment
-                    pitch = ((uint64_t(width) * bpp + 31u) / 32u) * sizeof(uint32_t);
-                    slice = pitch * uint64_t(height);
-                }
-            }
-            else
-            {
-                // Default byte alignment
-                pitch = (uint64_t(width) * bpp + 7u) / 8u;
-                slice = pitch * uint64_t(height);
-            }
-        }
-        break;
-    }
-
-#if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
-    static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!");
-    if (pitch > UINT32_MAX || slice > UINT32_MAX)
-    {
-        rowPitch = slicePitch = 0;
-        return HRESULT_E_ARITHMETIC_OVERFLOW;
-    }
-#else
-    static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
-#endif
-
-    rowPitch = static_cast<size_t>(pitch);
-    slicePitch = static_cast<size_t>(slice);
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-size_t DirectX::ComputeScanlines(DXGI_FORMAT fmt, size_t height) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_BC1_TYPELESS:
-    case DXGI_FORMAT_BC1_UNORM:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-    case DXGI_FORMAT_BC2_TYPELESS:
-    case DXGI_FORMAT_BC2_UNORM:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-    case DXGI_FORMAT_BC3_TYPELESS:
-    case DXGI_FORMAT_BC3_UNORM:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-    case DXGI_FORMAT_BC4_TYPELESS:
-    case DXGI_FORMAT_BC4_UNORM:
-    case DXGI_FORMAT_BC4_SNORM:
-    case DXGI_FORMAT_BC5_TYPELESS:
-    case DXGI_FORMAT_BC5_UNORM:
-    case DXGI_FORMAT_BC5_SNORM:
-    case DXGI_FORMAT_BC6H_TYPELESS:
-    case DXGI_FORMAT_BC6H_UF16:
-    case DXGI_FORMAT_BC6H_SF16:
-    case DXGI_FORMAT_BC7_TYPELESS:
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        assert(IsCompressed(fmt));
-        return std::max<size_t>(1, (height + 3) / 4);
-
-    case DXGI_FORMAT_NV11:
-    case WIN10_DXGI_FORMAT_P208:
-        assert(IsPlanar(fmt));
-        return height * 2;
-
-    case WIN10_DXGI_FORMAT_V208:
-        assert(IsPlanar(fmt));
-        return height + (((height + 1) >> 1) * 2);
-
-    case WIN10_DXGI_FORMAT_V408:
-        assert(IsPlanar(fmt));
-        return height + ((height >> 1) * 4);
-
-    case DXGI_FORMAT_NV12:
-    case DXGI_FORMAT_P010:
-    case DXGI_FORMAT_P016:
-    case DXGI_FORMAT_420_OPAQUE:
-    case XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT:
-    case XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
-    case XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT:
-        assert(IsPlanar(fmt));
-        return height + ((height + 1) >> 1);
-
-    default:
-        assert(IsValid(fmt));
-        assert(!IsCompressed(fmt) && !IsPlanar(fmt));
-        return height;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Converts to an SRGB equivalent type if available
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-DXGI_FORMAT DirectX::MakeSRGB(DXGI_FORMAT fmt) noexcept
-{
-    switch (fmt)
-    {
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-        return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
-
-    case DXGI_FORMAT_BC1_UNORM:
-        return DXGI_FORMAT_BC1_UNORM_SRGB;
-
-    case DXGI_FORMAT_BC2_UNORM:
-        return DXGI_FORMAT_BC2_UNORM_SRGB;
-
-    case DXGI_FORMAT_BC3_UNORM:
-        return DXGI_FORMAT_BC3_UNORM_SRGB;
-
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-        return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
-
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-        return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
-
-    case DXGI_FORMAT_BC7_UNORM:
-        return DXGI_FORMAT_BC7_UNORM_SRGB;
-
-    default:
-        return fmt;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Converts to an non-SRGB equivalent type
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-DXGI_FORMAT DirectX::MakeLinear(DXGI_FORMAT fmt) noexcept
-{
-    switch (fmt)
-    {
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-        return DXGI_FORMAT_R8G8B8A8_UNORM;
-
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-        return DXGI_FORMAT_BC1_UNORM;
-
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-        return DXGI_FORMAT_BC2_UNORM;
-
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-        return DXGI_FORMAT_BC3_UNORM;
-
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        return DXGI_FORMAT_B8G8R8A8_UNORM;
-
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        return DXGI_FORMAT_B8G8R8X8_UNORM;
-
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        return DXGI_FORMAT_BC7_UNORM;
-
-    default:
-        return fmt;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Converts to a format to an equivalent TYPELESS format if available
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-DXGI_FORMAT DirectX::MakeTypeless(DXGI_FORMAT fmt) noexcept
-{
-    switch (static_cast<int>(fmt))
-    {
-    case DXGI_FORMAT_R32G32B32A32_FLOAT:
-    case DXGI_FORMAT_R32G32B32A32_UINT:
-    case DXGI_FORMAT_R32G32B32A32_SINT:
-        return DXGI_FORMAT_R32G32B32A32_TYPELESS;
-
-    case DXGI_FORMAT_R32G32B32_FLOAT:
-    case DXGI_FORMAT_R32G32B32_UINT:
-    case DXGI_FORMAT_R32G32B32_SINT:
-        return DXGI_FORMAT_R32G32B32_TYPELESS;
-
-    case DXGI_FORMAT_R16G16B16A16_FLOAT:
-    case DXGI_FORMAT_R16G16B16A16_UNORM:
-    case DXGI_FORMAT_R16G16B16A16_UINT:
-    case DXGI_FORMAT_R16G16B16A16_SNORM:
-    case DXGI_FORMAT_R16G16B16A16_SINT:
-        return DXGI_FORMAT_R16G16B16A16_TYPELESS;
-
-    case DXGI_FORMAT_R32G32_FLOAT:
-    case DXGI_FORMAT_R32G32_UINT:
-    case DXGI_FORMAT_R32G32_SINT:
-        return DXGI_FORMAT_R32G32_TYPELESS;
-
-    case DXGI_FORMAT_R10G10B10A2_UNORM:
-    case DXGI_FORMAT_R10G10B10A2_UINT:
-    case XBOX_DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT:
-    case XBOX_DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT:
-    case XBOX_DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM:
-        return DXGI_FORMAT_R10G10B10A2_TYPELESS;
-
-    case DXGI_FORMAT_R8G8B8A8_UNORM:
-    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-    case DXGI_FORMAT_R8G8B8A8_UINT:
-    case DXGI_FORMAT_R8G8B8A8_SNORM:
-    case DXGI_FORMAT_R8G8B8A8_SINT:
-        return DXGI_FORMAT_R8G8B8A8_TYPELESS;
-
-    case DXGI_FORMAT_R16G16_FLOAT:
-    case DXGI_FORMAT_R16G16_UNORM:
-    case DXGI_FORMAT_R16G16_UINT:
-    case DXGI_FORMAT_R16G16_SNORM:
-    case DXGI_FORMAT_R16G16_SINT:
-        return DXGI_FORMAT_R16G16_TYPELESS;
-
-    case DXGI_FORMAT_D32_FLOAT:
-    case DXGI_FORMAT_R32_FLOAT:
-    case DXGI_FORMAT_R32_UINT:
-    case DXGI_FORMAT_R32_SINT:
-        return DXGI_FORMAT_R32_TYPELESS;
-
-    case DXGI_FORMAT_R8G8_UNORM:
-    case DXGI_FORMAT_R8G8_UINT:
-    case DXGI_FORMAT_R8G8_SNORM:
-    case DXGI_FORMAT_R8G8_SINT:
-        return DXGI_FORMAT_R8G8_TYPELESS;
-
-    case DXGI_FORMAT_R16_FLOAT:
-    case DXGI_FORMAT_D16_UNORM:
-    case DXGI_FORMAT_R16_UNORM:
-    case DXGI_FORMAT_R16_UINT:
-    case DXGI_FORMAT_R16_SNORM:
-    case DXGI_FORMAT_R16_SINT:
-        return DXGI_FORMAT_R16_TYPELESS;
-
-    case DXGI_FORMAT_R8_UNORM:
-    case DXGI_FORMAT_R8_UINT:
-    case DXGI_FORMAT_R8_SNORM:
-    case DXGI_FORMAT_R8_SINT:
-    case XBOX_DXGI_FORMAT_R4G4_UNORM:
-        return DXGI_FORMAT_R8_TYPELESS;
-
-    case DXGI_FORMAT_BC1_UNORM:
-    case DXGI_FORMAT_BC1_UNORM_SRGB:
-        return DXGI_FORMAT_BC1_TYPELESS;
-
-    case DXGI_FORMAT_BC2_UNORM:
-    case DXGI_FORMAT_BC2_UNORM_SRGB:
-        return DXGI_FORMAT_BC2_TYPELESS;
-
-    case DXGI_FORMAT_BC3_UNORM:
-    case DXGI_FORMAT_BC3_UNORM_SRGB:
-        return DXGI_FORMAT_BC3_TYPELESS;
-
-    case DXGI_FORMAT_BC4_UNORM:
-    case DXGI_FORMAT_BC4_SNORM:
-        return DXGI_FORMAT_BC4_TYPELESS;
-
-    case DXGI_FORMAT_BC5_UNORM:
-    case DXGI_FORMAT_BC5_SNORM:
-        return DXGI_FORMAT_BC5_TYPELESS;
-
-    case DXGI_FORMAT_B8G8R8A8_UNORM:
-    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        return DXGI_FORMAT_B8G8R8A8_TYPELESS;
-
-    case DXGI_FORMAT_B8G8R8X8_UNORM:
-    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        return DXGI_FORMAT_B8G8R8X8_TYPELESS;
-
-    case DXGI_FORMAT_BC6H_UF16:
-    case DXGI_FORMAT_BC6H_SF16:
-        return DXGI_FORMAT_BC6H_TYPELESS;
-
-    case DXGI_FORMAT_BC7_UNORM:
-    case DXGI_FORMAT_BC7_UNORM_SRGB:
-        return DXGI_FORMAT_BC7_TYPELESS;
-
-    default:
-        return fmt;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Converts to a TYPELESS format to an equivalent UNORM format if available
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-DXGI_FORMAT DirectX::MakeTypelessUNORM(DXGI_FORMAT fmt) noexcept
-{
-    switch (fmt)
-    {
-    case DXGI_FORMAT_R16G16B16A16_TYPELESS:
-        return DXGI_FORMAT_R16G16B16A16_UNORM;
-
-    case DXGI_FORMAT_R10G10B10A2_TYPELESS:
-        return DXGI_FORMAT_R10G10B10A2_UNORM;
-
-    case DXGI_FORMAT_R8G8B8A8_TYPELESS:
-        return DXGI_FORMAT_R8G8B8A8_UNORM;
-
-    case DXGI_FORMAT_R16G16_TYPELESS:
-        return DXGI_FORMAT_R16G16_UNORM;
-
-    case DXGI_FORMAT_R8G8_TYPELESS:
-        return DXGI_FORMAT_R8G8_UNORM;
-
-    case DXGI_FORMAT_R16_TYPELESS:
-        return DXGI_FORMAT_R16_UNORM;
-
-    case DXGI_FORMAT_R8_TYPELESS:
-        return DXGI_FORMAT_R8_UNORM;
-
-    case DXGI_FORMAT_BC1_TYPELESS:
-        return DXGI_FORMAT_BC1_UNORM;
-
-    case DXGI_FORMAT_BC2_TYPELESS:
-        return DXGI_FORMAT_BC2_UNORM;
-
-    case DXGI_FORMAT_BC3_TYPELESS:
-        return DXGI_FORMAT_BC3_UNORM;
-
-    case DXGI_FORMAT_BC4_TYPELESS:
-        return DXGI_FORMAT_BC4_UNORM;
-
-    case DXGI_FORMAT_BC5_TYPELESS:
-        return DXGI_FORMAT_BC5_UNORM;
-
-    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-        return DXGI_FORMAT_B8G8R8A8_UNORM;
-
-    case DXGI_FORMAT_B8G8R8X8_TYPELESS:
-        return DXGI_FORMAT_B8G8R8X8_UNORM;
-
-    case DXGI_FORMAT_BC7_TYPELESS:
-        return DXGI_FORMAT_BC7_UNORM;
-
-    default:
-        return fmt;
-    }
-}
-
-
-//-------------------------------------------------------------------------------------
-// Converts to a TYPELESS format to an equivalent FLOAT format if available
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-DXGI_FORMAT DirectX::MakeTypelessFLOAT(DXGI_FORMAT fmt) noexcept
-{
-    switch (fmt)
-    {
-    case DXGI_FORMAT_R32G32B32A32_TYPELESS:
-        return DXGI_FORMAT_R32G32B32A32_FLOAT;
-
-    case DXGI_FORMAT_R32G32B32_TYPELESS:
-        return DXGI_FORMAT_R32G32B32_FLOAT;
-
-    case DXGI_FORMAT_R16G16B16A16_TYPELESS:
-        return DXGI_FORMAT_R16G16B16A16_FLOAT;
-
-    case DXGI_FORMAT_R32G32_TYPELESS:
-        return DXGI_FORMAT_R32G32_FLOAT;
-
-    case DXGI_FORMAT_R16G16_TYPELESS:
-        return DXGI_FORMAT_R16G16_FLOAT;
-
-    case DXGI_FORMAT_R32_TYPELESS:
-        return DXGI_FORMAT_R32_FLOAT;
-
-    case DXGI_FORMAT_R16_TYPELESS:
-        return DXGI_FORMAT_R16_FLOAT;
-
-    default:
-        return fmt;
-    }
-}
-
-
-//=====================================================================================
-// TexMetadata
-//=====================================================================================
-
-_Use_decl_annotations_
-size_t TexMetadata::ComputeIndex(size_t mip, size_t item, size_t slice) const noexcept
-{
-    if (mip >= mipLevels)
-        return size_t(-1);
-
-    switch (dimension)
-    {
-    case TEX_DIMENSION_TEXTURE1D:
-    case TEX_DIMENSION_TEXTURE2D:
-        if (slice > 0)
-            return size_t(-1);
-
-        if (item >= arraySize)
-            return size_t(-1);
-
-        return (item*(mipLevels)+mip);
-
-    case TEX_DIMENSION_TEXTURE3D:
-        if (item > 0)
-        {
-            // No support for arrays of volumes
-            return size_t(-1);
-        }
-        else
-        {
-            size_t index = 0;
-            size_t d = depth;
-
-            for (size_t level = 0; level < mip; ++level)
-            {
-                index += d;
-                if (d > 1)
-                    d >>= 1;
-            }
-
-            if (slice >= d)
-                return size_t(-1);
-
-            index += slice;
-
-            return index;
-        }
-
-    default:
-        return size_t(-1);
-    }
-}
-
-
-//=====================================================================================
-// Blob - Bitmap image container
-//=====================================================================================
-
-Blob& Blob::operator= (Blob&& moveFrom) noexcept
-{
-    if (this != &moveFrom)
-    {
-        Release();
-
-        m_buffer = moveFrom.m_buffer;
-        m_size = moveFrom.m_size;
-
-        moveFrom.m_buffer = nullptr;
-        moveFrom.m_size = 0;
-    }
-    return *this;
-}
-
-void Blob::Release() noexcept
-{
-    if (m_buffer)
-    {
-        _aligned_free(m_buffer);
-        m_buffer = nullptr;
-    }
-
-    m_size = 0;
-}
-
-_Use_decl_annotations_
-HRESULT Blob::Initialize(size_t size) noexcept
-{
-    if (!size)
-        return E_INVALIDARG;
-
-    Release();
-
-    m_buffer = _aligned_malloc(size, 16);
-    if (!m_buffer)
-    {
-        Release();
-        return E_OUTOFMEMORY;
-    }
-
-    m_size = size;
-
-    return S_OK;
-}
-
-HRESULT Blob::Trim(size_t size) noexcept
-{
-    if (!size)
-        return E_INVALIDARG;
-
-    if (!m_buffer)
-        return E_UNEXPECTED;
-
-    if (size > m_size)
-        return E_INVALIDARG;
-
-    m_size = size;
-
-    return S_OK;
-}
-
-HRESULT Blob::Resize(size_t size) noexcept
-{
-    if (!size)
-        return E_INVALIDARG;
-
-    if (!m_buffer || !m_size)
-        return E_UNEXPECTED;
-
-    void *tbuffer = _aligned_malloc(size, 16);
-    if (!tbuffer)
-        return E_OUTOFMEMORY;
-
-    memcpy(tbuffer, m_buffer, std::min(m_size, size));
-
-    Release();
-
-    m_buffer = tbuffer;
-    m_size = size;
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/DirectXTexWIC.cpp b/thirdparty/directxtex/DirectXTexWIC.cpp
deleted file mode 100644
index fc1ebac..0000000
--- a/thirdparty/directxtex/DirectXTexWIC.cpp
+++ /dev/null
@@ -1,1619 +0,0 @@
-//-------------------------------------------------------------------------------------
-// DirectXTexWIC.cpp
-//
-// DirectX Texture Library - WIC-based file reader/writer
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//
-// http://go.microsoft.com/fwlink/?LinkId=248926
-//-------------------------------------------------------------------------------------
-
-#include "DirectXTexP.h"
-
-using namespace DirectX;
-using namespace DirectX::Internal;
-using Microsoft::WRL::ComPtr;
-
-namespace
-{
-    //-------------------------------------------------------------------------------------
-    // WIC Pixel Format nearest conversion table
-    //-------------------------------------------------------------------------------------
-    struct WICConvert
-    {
-        const GUID&     source;
-        const GUID&     target;
-        TEX_ALPHA_MODE  alphaMode;
-    };
-
-    constexpr WICConvert g_WICConvert[] =
-    {
-        // Directly support the formats listed in XnaTexUtil::g_WICFormats, so no conversion required
-        // Note target GUID in this conversion table must be one of those directly supported formats.
-
-        { GUID_WICPixelFormat1bppIndexed,           GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R8G8B8A8_UNORM
-        { GUID_WICPixelFormat2bppIndexed,           GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R8G8B8A8_UNORM
-        { GUID_WICPixelFormat4bppIndexed,           GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R8G8B8A8_UNORM
-        { GUID_WICPixelFormat8bppIndexed,           GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R8G8B8A8_UNORM
-
-        { GUID_WICPixelFormat2bppGray,              GUID_WICPixelFormat8bppGray, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R8_UNORM
-        { GUID_WICPixelFormat4bppGray,              GUID_WICPixelFormat8bppGray, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R8_UNORM
-
-        { GUID_WICPixelFormat16bppGrayFixedPoint,   GUID_WICPixelFormat16bppGrayHalf, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R16_FLOAT
-        { GUID_WICPixelFormat32bppGrayFixedPoint,   GUID_WICPixelFormat32bppGrayFloat, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R32_FLOAT
-
-        { GUID_WICPixelFormat16bppBGR555,           GUID_WICPixelFormat16bppBGRA5551, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_B5G5R5A1_UNORM
-        { GUID_WICPixelFormat32bppBGR101010,        GUID_WICPixelFormat32bppRGBA1010102, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R10G10B10A2_UNORM
-
-        { GUID_WICPixelFormat24bppBGR,              GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R8G8B8A8_UNORM
-        { GUID_WICPixelFormat24bppRGB,              GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R8G8B8A8_UNORM
-        { GUID_WICPixelFormat32bppPBGRA,            GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R8G8B8A8_UNORM
-        { GUID_WICPixelFormat32bppPRGBA,            GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R8G8B8A8_UNORM
-
-        { GUID_WICPixelFormat48bppRGB,              GUID_WICPixelFormat64bppRGBA, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R16G16B16A16_UNORM
-        { GUID_WICPixelFormat48bppBGR,              GUID_WICPixelFormat64bppRGBA, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R16G16B16A16_UNORM
-        { GUID_WICPixelFormat64bppBGRA,             GUID_WICPixelFormat64bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R16G16B16A16_UNORM
-        { GUID_WICPixelFormat64bppPRGBA,            GUID_WICPixelFormat64bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R16G16B16A16_UNORM
-        { GUID_WICPixelFormat64bppPBGRA,            GUID_WICPixelFormat64bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R16G16B16A16_UNORM
-
-        { GUID_WICPixelFormat48bppRGBFixedPoint,    GUID_WICPixelFormat64bppRGBAHalf, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R16G16B16A16_FLOAT
-        { GUID_WICPixelFormat48bppBGRFixedPoint,    GUID_WICPixelFormat64bppRGBAHalf, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R16G16B16A16_FLOAT
-        { GUID_WICPixelFormat64bppRGBAFixedPoint,   GUID_WICPixelFormat64bppRGBAHalf, TEX_ALPHA_MODE_UNKNOWN  }, // DXGI_FORMAT_R16G16B16A16_FLOAT
-        { GUID_WICPixelFormat64bppBGRAFixedPoint,   GUID_WICPixelFormat64bppRGBAHalf, TEX_ALPHA_MODE_UNKNOWN  }, // DXGI_FORMAT_R16G16B16A16_FLOAT
-        { GUID_WICPixelFormat64bppRGBFixedPoint,    GUID_WICPixelFormat64bppRGBAHalf, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R16G16B16A16_FLOAT
-        { GUID_WICPixelFormat64bppRGBHalf,          GUID_WICPixelFormat64bppRGBAHalf, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R16G16B16A16_FLOAT
-        { GUID_WICPixelFormat48bppRGBHalf,          GUID_WICPixelFormat64bppRGBAHalf, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R16G16B16A16_FLOAT
-
-        { GUID_WICPixelFormat128bppPRGBAFloat,      GUID_WICPixelFormat128bppRGBAFloat, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R32G32B32A32_FLOAT
-        { GUID_WICPixelFormat128bppRGBFloat,        GUID_WICPixelFormat128bppRGBAFloat, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R32G32B32A32_FLOAT
-        { GUID_WICPixelFormat128bppRGBAFixedPoint,  GUID_WICPixelFormat128bppRGBAFloat, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R32G32B32A32_FLOAT
-        { GUID_WICPixelFormat128bppRGBFixedPoint,   GUID_WICPixelFormat128bppRGBAFloat, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R32G32B32A32_FLOAT
-        { GUID_WICPixelFormat32bppRGBE,             GUID_WICPixelFormat128bppRGBAFloat, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R32G32B32A32_FLOAT
-
-        { GUID_WICPixelFormat32bppCMYK,             GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R8G8B8A8_UNORM
-        { GUID_WICPixelFormat64bppCMYK,             GUID_WICPixelFormat64bppRGBA, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R16G16B16A16_UNORM
-        { GUID_WICPixelFormat40bppCMYKAlpha,        GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R8G8B8A8_UNORM
-        { GUID_WICPixelFormat80bppCMYKAlpha,        GUID_WICPixelFormat64bppRGBA, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R16G16B16A16_UNORM
-
-    #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
-        { GUID_WICPixelFormat32bppRGB,              GUID_WICPixelFormat32bppRGBA, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R8G8B8A8_UNORM
-        { GUID_WICPixelFormat64bppRGB,              GUID_WICPixelFormat64bppRGBA, TEX_ALPHA_MODE_OPAQUE }, // DXGI_FORMAT_R16G16B16A16_UNORM
-        { GUID_WICPixelFormat64bppPRGBAHalf,        GUID_WICPixelFormat64bppRGBAHalf, TEX_ALPHA_MODE_UNKNOWN }, // DXGI_FORMAT_R16G16B16A16_FLOAT
-    #endif
-
-        // We don't support n-channel formats
-    };
-
-    //-------------------------------------------------------------------------------------
-    // Returns the DXGI format and optionally the WIC pixel GUID to convert to
-    //-------------------------------------------------------------------------------------
-    DXGI_FORMAT DetermineFormat(
-        _In_ const WICPixelFormatGUID& pixelFormat,
-        WIC_FLAGS flags,
-        bool iswic2,
-        _Out_opt_ WICPixelFormatGUID* pConvert,
-        _Out_ TEX_ALPHA_MODE* alphaMode) noexcept
-    {
-        if (pConvert)
-            memset(pConvert, 0, sizeof(WICPixelFormatGUID));
-
-        *alphaMode = TEX_ALPHA_MODE_UNKNOWN;
-
-        DXGI_FORMAT format = WICToDXGI(pixelFormat);
-
-        if (format == DXGI_FORMAT_UNKNOWN)
-        {
-            if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0)
-            {
-            #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
-                if (iswic2)
-                {
-                    if (pConvert)
-                        memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat96bppRGBFloat, sizeof(GUID));
-                    format = DXGI_FORMAT_R32G32B32_FLOAT;
-                }
-                else
-                #else
-                UNREFERENCED_PARAMETER(iswic2);
-            #endif
-                {
-                    if (pConvert)
-                        memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat128bppRGBAFloat, sizeof(GUID));
-                    format = DXGI_FORMAT_R32G32B32A32_FLOAT;
-                    *alphaMode = TEX_ALPHA_MODE_OPAQUE;
-                }
-            }
-            else
-            {
-                for (size_t i = 0; i < std::size(g_WICConvert); ++i)
-                {
-                    if (memcmp(&g_WICConvert[i].source, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0)
-                    {
-                        if (pConvert)
-                            memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID));
-
-                        format = WICToDXGI(g_WICConvert[i].target);
-                        assert(format != DXGI_FORMAT_UNKNOWN);
-                        *alphaMode = g_WICConvert[i].alphaMode;
-                        break;
-                    }
-                }
-            }
-        }
-
-        // Handle special cases based on flags
-        switch (format)
-        {
-        case DXGI_FORMAT_B8G8R8A8_UNORM:    // BGRA
-        case DXGI_FORMAT_B8G8R8X8_UNORM:    // BGRX
-            if (flags & WIC_FLAGS_FORCE_RGB)
-            {
-                format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                if (pConvert)
-                    memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat32bppRGBA, sizeof(GUID));
-            }
-            break;
-
-        case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
-            if (flags & WIC_FLAGS_NO_X2_BIAS)
-            {
-                format = DXGI_FORMAT_R10G10B10A2_UNORM;
-                if (pConvert)
-                    memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat32bppRGBA1010102, sizeof(GUID));
-            }
-            break;
-
-        case DXGI_FORMAT_B5G5R5A1_UNORM:
-        case DXGI_FORMAT_B5G6R5_UNORM:
-            if (flags & WIC_FLAGS_NO_16BPP)
-            {
-                format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                if (pConvert)
-                    memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat32bppRGBA, sizeof(GUID));
-            }
-            break;
-
-        case DXGI_FORMAT_R1_UNORM:
-            if (!(flags & WIC_FLAGS_ALLOW_MONO))
-            {
-                // By default we want to promote a black & white to gresycale since R1 is not a generally supported D3D format
-                format = DXGI_FORMAT_R8_UNORM;
-                if (pConvert)
-                    memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat8bppGray, sizeof(GUID));
-            }
-            break;
-
-        default:
-            break;
-        }
-
-        return format;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // IStream over a Blob for WIC in-memory write functions
-    //-------------------------------------------------------------------------------------
-    class MemoryStreamOnBlob : public IStream
-    {
-        MemoryStreamOnBlob(Blob& blob) noexcept :
-            mBlob(blob),
-            m_streamPosition(0),
-            m_streamEOF(0),
-            mRefCount(1)
-        {
-            assert(mBlob.GetBufferPointer() && mBlob.GetBufferSize() > 0);
-        }
-
-    public:
-        virtual ~MemoryStreamOnBlob() = default;
-
-        MemoryStreamOnBlob(MemoryStreamOnBlob&&) = delete;
-        MemoryStreamOnBlob& operator= (MemoryStreamOnBlob&&) = delete;
-
-        MemoryStreamOnBlob(MemoryStreamOnBlob const&) = delete;
-        MemoryStreamOnBlob& operator= (MemoryStreamOnBlob const&) = delete;
-
-        // IUnknown
-        HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void** ppvObject) override
-        {
-            if (iid == __uuidof(IUnknown)
-                || iid == __uuidof(IStream)
-                || iid == __uuidof(ISequentialStream))
-            {
-                *ppvObject = static_cast<IStream*>(this);
-                AddRef();
-                return S_OK;
-            }
-            else
-                return E_NOINTERFACE;
-        }
-
-        ULONG STDMETHODCALLTYPE AddRef() override
-        {
-            return InterlockedIncrement(&mRefCount);
-        }
-
-        ULONG STDMETHODCALLTYPE Release() override
-        {
-            const ULONG res = InterlockedDecrement(&mRefCount);
-            if (res == 0)
-            {
-                delete this;
-            }
-            return res;
-        }
-
-        // ISequentialStream
-        HRESULT STDMETHODCALLTYPE Read(void* pv, ULONG cb, ULONG* pcbRead) override
-        {
-            size_t maxRead = m_streamEOF - m_streamPosition;
-            auto ptr = static_cast<const uint8_t*>(mBlob.GetBufferPointer());
-            if (cb > maxRead)
-            {
-                const uint64_t pos = uint64_t(m_streamPosition) + uint64_t(maxRead);
-                if (pos > UINT32_MAX)
-                    return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-                memcpy(pv, &ptr[m_streamPosition], maxRead);
-
-                m_streamPosition = static_cast<size_t>(pos);
-
-                if (pcbRead)
-                {
-                    *pcbRead = static_cast<ULONG>(maxRead);
-                }
-                return E_BOUNDS;
-            }
-            else
-            {
-                const uint64_t pos = uint64_t(m_streamPosition) + uint64_t(cb);
-                if (pos > UINT32_MAX)
-                    return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-                memcpy(pv, &ptr[m_streamPosition], cb);
-
-                m_streamPosition = static_cast<size_t>(pos);
-
-                if (pcbRead)
-                {
-                    *pcbRead = cb;
-                }
-                return S_OK;
-            }
-        }
-
-        HRESULT STDMETHODCALLTYPE Write(void const* pv, ULONG cb, ULONG* pcbWritten) override
-        {
-            const size_t blobSize = mBlob.GetBufferSize();
-            const size_t spaceAvailable = blobSize - m_streamPosition;
-            size_t growAmount = cb;
-
-            if (spaceAvailable > 0)
-            {
-                if (spaceAvailable >= growAmount)
-                {
-                    growAmount = 0;
-                }
-                else
-                {
-                    growAmount -= spaceAvailable;
-                }
-            }
-
-            if (growAmount > 0)
-            {
-                uint64_t newSize = uint64_t(blobSize);
-                const uint64_t targetSize = uint64_t(blobSize) + growAmount;
-                HRESULT hr = ComputeGrowSize(newSize, targetSize);
-                if (FAILED(hr))
-                    return hr;
-
-                hr = mBlob.Resize(static_cast<size_t>(newSize));
-                if (FAILED(hr))
-                    return hr;
-            }
-
-            const uint64_t pos = uint64_t(m_streamPosition) + uint64_t(cb);
-            if (pos > UINT32_MAX)
-                return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-            auto ptr = static_cast<uint8_t*>(mBlob.GetBufferPointer());
-            memcpy(&ptr[m_streamPosition], pv, cb);
-
-            m_streamPosition = static_cast<size_t>(pos);
-            m_streamEOF = std::max(m_streamEOF, m_streamPosition);
-
-            if (pcbWritten)
-            {
-                *pcbWritten = cb;
-            }
-            return S_OK;
-        }
-
-        // IStream
-        HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER size) override
-        {
-            if (size.HighPart > 0)
-                return E_OUTOFMEMORY;
-
-            const size_t blobSize = mBlob.GetBufferSize();
-
-            if (blobSize >= size.LowPart)
-            {
-                auto ptr = static_cast<uint8_t*>(mBlob.GetBufferPointer());
-                if (m_streamEOF < size.LowPart)
-                {
-                    memset(&ptr[m_streamEOF], 0, size.LowPart - m_streamEOF);
-                }
-
-                m_streamEOF = static_cast<size_t>(size.LowPart);
-            }
-            else
-            {
-                uint64_t newSize = uint64_t(blobSize);
-                const uint64_t targetSize = uint64_t(size.QuadPart);
-                HRESULT hr = ComputeGrowSize(newSize, targetSize);
-                if (FAILED(hr))
-                    return hr;
-
-                hr = mBlob.Resize(static_cast<size_t>(newSize));
-                if (FAILED(hr))
-                    return hr;
-
-                auto ptr = static_cast<uint8_t*>(mBlob.GetBufferPointer());
-                if (m_streamEOF < size.LowPart)
-                {
-                    memset(&ptr[m_streamEOF], 0, size.LowPart - m_streamEOF);
-                }
-
-                m_streamEOF = static_cast<size_t>(size.LowPart);
-            }
-
-            if (m_streamPosition > m_streamEOF)
-            {
-                m_streamPosition = m_streamEOF;
-            }
-
-            return S_OK;
-        }
-
-        HRESULT STDMETHODCALLTYPE CopyTo(IStream*, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*) override
-        {
-            return E_NOTIMPL;
-        }
-
-        HRESULT STDMETHODCALLTYPE Commit(DWORD) override
-        {
-            return E_NOTIMPL;
-        }
-
-        HRESULT STDMETHODCALLTYPE Revert() override
-        {
-            return E_NOTIMPL;
-        }
-
-        HRESULT STDMETHODCALLTYPE LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) override
-        {
-            return E_NOTIMPL;
-        }
-
-        HRESULT STDMETHODCALLTYPE UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) override
-        {
-            return E_NOTIMPL;
-        }
-
-        HRESULT STDMETHODCALLTYPE Clone(IStream**) override
-        {
-            return E_NOTIMPL;
-        }
-
-        HRESULT STDMETHODCALLTYPE Seek(LARGE_INTEGER liDistanceToMove, DWORD dwOrigin, ULARGE_INTEGER* lpNewFilePointer) override
-        {
-            LONGLONG newPosition = 0;
-
-            switch (dwOrigin)
-            {
-            case STREAM_SEEK_SET:
-                newPosition = liDistanceToMove.QuadPart;
-                break;
-
-            case STREAM_SEEK_CUR:
-                newPosition = static_cast<LONGLONG>(m_streamPosition) + liDistanceToMove.QuadPart;
-                break;
-
-            case STREAM_SEEK_END:
-                newPosition = static_cast<LONGLONG>(m_streamEOF) + liDistanceToMove.QuadPart;
-                break;
-
-            default:
-                return STG_E_INVALIDFUNCTION;
-            }
-
-            HRESULT result = S_OK;
-
-            if (newPosition > static_cast<LONGLONG>(m_streamEOF))
-            {
-                m_streamPosition = m_streamEOF;
-                result = E_BOUNDS;
-            }
-            else if (newPosition < 0)
-            {
-                m_streamPosition = 0;
-                result = E_BOUNDS;
-            }
-            else
-            {
-                m_streamPosition = static_cast<size_t>(newPosition);
-            }
-
-            if (lpNewFilePointer)
-            {
-                lpNewFilePointer->QuadPart = static_cast<ULONGLONG>(m_streamPosition);
-            }
-
-            return result;
-        }
-
-        HRESULT STDMETHODCALLTYPE Stat(STATSTG* pStatstg, DWORD) override
-        {
-            if (!pStatstg)
-                return E_INVALIDARG;
-            pStatstg->cbSize.QuadPart = static_cast<ULONGLONG>(m_streamEOF);
-            return S_OK;
-        }
-
-        HRESULT Finialize() noexcept
-        {
-            if (mRefCount > 1)
-                return E_FAIL;
-
-            return mBlob.Trim(m_streamEOF);
-        }
-
-        static HRESULT CreateMemoryStream(_Outptr_ MemoryStreamOnBlob** stream, Blob& blob) noexcept
-        {
-            if (!stream)
-                return E_INVALIDARG;
-
-            *stream = nullptr;
-
-            auto ptr = new (std::nothrow) MemoryStreamOnBlob(blob);
-            if (!ptr)
-                return E_OUTOFMEMORY;
-
-            *stream = ptr;
-
-            return S_OK;
-        }
-
-    private:
-        Blob& mBlob;
-        size_t m_streamPosition;
-        size_t m_streamEOF;
-        ULONG mRefCount;
-
-        static HRESULT ComputeGrowSize(uint64_t& newSize, const uint64_t targetSize) noexcept
-        {
-            // We grow by doubling until we hit 256MB, then we add 16MB at a time.
-            while (newSize < targetSize)
-            {
-                if (newSize < (256 * 1024 * 1024))
-                {
-                    newSize <<= 1;
-                }
-                else
-                {
-                    newSize += 16 * 1024 * 1024;
-                }
-                if (newSize > UINT32_MAX)
-                    return E_OUTOFMEMORY;
-            }
-
-            return S_OK;
-        }
-    };
-
-    //-------------------------------------------------------------------------------------
-    // Determines metadata for image
-    //-------------------------------------------------------------------------------------
-    HRESULT DecodeMetadata(
-        WIC_FLAGS flags,
-        bool iswic2,
-        _In_ IWICBitmapDecoder *decoder,
-        _In_ IWICBitmapFrameDecode *frame,
-        _Out_ TexMetadata& metadata,
-        _Out_opt_ WICPixelFormatGUID* pConvert,
-        _In_opt_ std::function<void(IWICMetadataQueryReader*)> getMQR)
-    {
-        if (!decoder || !frame)
-            return E_POINTER;
-
-        memset(&metadata, 0, sizeof(TexMetadata));
-        metadata.depth = 1;
-        metadata.mipLevels = 1;
-        metadata.dimension = TEX_DIMENSION_TEXTURE2D;
-
-        UINT w, h;
-        HRESULT hr = frame->GetSize(&w, &h);
-        if (FAILED(hr))
-            return hr;
-
-        metadata.width = w;
-        metadata.height = h;
-
-        if (flags & WIC_FLAGS_ALL_FRAMES)
-        {
-            UINT fcount;
-            hr = decoder->GetFrameCount(&fcount);
-            if (FAILED(hr))
-                return hr;
-
-            metadata.arraySize = fcount;
-        }
-        else
-            metadata.arraySize = 1;
-
-        WICPixelFormatGUID pixelFormat;
-        hr = frame->GetPixelFormat(&pixelFormat);
-        if (FAILED(hr))
-            return hr;
-
-        TEX_ALPHA_MODE alphaMode;
-        metadata.format = DetermineFormat(pixelFormat, flags, iswic2, pConvert, &alphaMode);
-        if (metadata.format == DXGI_FORMAT_UNKNOWN)
-            return HRESULT_E_NOT_SUPPORTED;
-
-        metadata.SetAlphaMode(alphaMode);
-
-        if (!(flags & WIC_FLAGS_IGNORE_SRGB))
-        {
-            GUID containerFormat;
-            hr = decoder->GetContainerFormat(&containerFormat);
-            if (FAILED(hr))
-                return hr;
-
-            ComPtr<IWICMetadataQueryReader> metareader;
-            hr = frame->GetMetadataQueryReader(metareader.GetAddressOf());
-            if (SUCCEEDED(hr))
-            {
-                // Check for sRGB colorspace metadata
-                bool sRGB = false;
-
-                PROPVARIANT value;
-                PropVariantInit(&value);
-
-                // Check for colorspace chunks
-                if (memcmp(&containerFormat, &GUID_ContainerFormatPng, sizeof(GUID)) == 0)
-                {
-                    if (SUCCEEDED(metareader->GetMetadataByName(L"/sRGB/RenderingIntent", &value)) && value.vt == VT_UI1)
-                    {
-                        sRGB = true;
-                    }
-                    else if (SUCCEEDED(metareader->GetMetadataByName(L"/gAMA/ImageGamma", &value)) && value.vt == VT_UI4)
-                    {
-                        sRGB = (value.uintVal == 45455);
-                    }
-                    else
-                    {
-                        sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
-                    }
-                }
-            #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
-                else if (memcmp(&containerFormat, &GUID_ContainerFormatJpeg, sizeof(GUID)) == 0)
-                {
-                    if (SUCCEEDED(metareader->GetMetadataByName(L"/app1/ifd/exif/{ushort=40961}", &value)) && value.vt == VT_UI2)
-                    {
-                        sRGB = (value.uiVal == 1);
-                    }
-                    else
-                    {
-                        sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
-                    }
-                }
-                else if (memcmp(&containerFormat, &GUID_ContainerFormatTiff, sizeof(GUID)) == 0)
-                {
-                    if (SUCCEEDED(metareader->GetMetadataByName(L"/ifd/exif/{ushort=40961}", &value)) && value.vt == VT_UI2)
-                    {
-                        sRGB = (value.uiVal == 1);
-                    }
-                    else
-                    {
-                        sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
-                    }
-                }
-            #else
-                else if (SUCCEEDED(metareader->GetMetadataByName(L"System.Image.ColorSpace", &value)) && value.vt == VT_UI2)
-                {
-                    sRGB = (value.uiVal == 1);
-                }
-                else
-                {
-                    sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
-                }
-            #endif
-
-                std::ignore = PropVariantClear(&value);
-
-                if (sRGB)
-                    metadata.format = MakeSRGB(metadata.format);
-            }
-            else if (hr == WINCODEC_ERR_UNSUPPORTEDOPERATION)
-            {
-                // Some formats just don't support metadata (BMP, ICO, etc.), so ignore this failure
-                hr = S_OK;
-            }
-        }
-
-        if (getMQR)
-        {
-            ComPtr<IWICMetadataQueryReader> metareader;
-            if (SUCCEEDED(frame->GetMetadataQueryReader(metareader.GetAddressOf())))
-            {
-                getMQR(metareader.Get());
-            }
-        }
-
-        return hr;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Decodes a single frame
-    //-------------------------------------------------------------------------------------
-    HRESULT DecodeSingleFrame(
-        WIC_FLAGS flags,
-        const TexMetadata& metadata,
-        const WICPixelFormatGUID& convertGUID,
-        _In_ IWICBitmapFrameDecode *frame,
-        _Inout_ ScratchImage& image)
-    {
-        if (!frame)
-            return E_POINTER;
-
-        HRESULT hr = image.Initialize2D(metadata.format, metadata.width, metadata.height, 1, 1);
-        if (FAILED(hr))
-            return hr;
-
-        const Image *img = image.GetImage(0, 0, 0);
-        if (!img)
-            return E_POINTER;
-
-        bool iswic2 = false;
-        auto pWIC = GetWICFactory(iswic2);
-        if (!pWIC)
-            return E_NOINTERFACE;
-
-        if (img->rowPitch > UINT32_MAX || img->slicePitch > UINT32_MAX)
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-        if (memcmp(&convertGUID, &GUID_NULL, sizeof(GUID)) == 0)
-        {
-            hr = frame->CopyPixels(nullptr, static_cast<UINT>(img->rowPitch), static_cast<UINT>(img->slicePitch), img->pixels);
-            if (FAILED(hr))
-                return hr;
-        }
-        else
-        {
-            ComPtr<IWICFormatConverter> FC;
-            hr = pWIC->CreateFormatConverter(FC.GetAddressOf());
-            if (FAILED(hr))
-                return hr;
-
-            WICPixelFormatGUID pixelFormat;
-            hr = frame->GetPixelFormat(&pixelFormat);
-            if (FAILED(hr))
-                return hr;
-
-            BOOL canConvert = FALSE;
-            hr = FC->CanConvert(pixelFormat, convertGUID, &canConvert);
-            if (FAILED(hr) || !canConvert)
-            {
-                return E_UNEXPECTED;
-            }
-
-            hr = FC->Initialize(frame, convertGUID, GetWICDither(flags), nullptr,
-                0, WICBitmapPaletteTypeMedianCut);
-            if (FAILED(hr))
-                return hr;
-
-            hr = FC->CopyPixels(nullptr, static_cast<UINT>(img->rowPitch), static_cast<UINT>(img->slicePitch), img->pixels);
-            if (FAILED(hr))
-                return hr;
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Decodes an image array, resizing/format converting as needed
-    //-------------------------------------------------------------------------------------
-    HRESULT DecodeMultiframe(
-        WIC_FLAGS flags,
-        const TexMetadata& metadata,
-        _In_ IWICBitmapDecoder *decoder,
-        _Inout_ ScratchImage& image)
-    {
-        if (!decoder)
-            return E_POINTER;
-
-        HRESULT hr = image.Initialize2D(metadata.format, metadata.width, metadata.height, metadata.arraySize, 1);
-        if (FAILED(hr))
-            return hr;
-
-        bool iswic2 = false;
-        auto pWIC = GetWICFactory(iswic2);
-        if (!pWIC)
-            return E_NOINTERFACE;
-
-        WICPixelFormatGUID sourceGUID;
-        if (!DXGIToWIC(metadata.format, sourceGUID))
-            return E_FAIL;
-
-        for (size_t index = 0; index < metadata.arraySize; ++index)
-        {
-            const Image* img = image.GetImage(0, index, 0);
-            if (!img)
-                return E_POINTER;
-
-            if (img->rowPitch > UINT32_MAX || img->slicePitch > UINT32_MAX)
-                return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-            ComPtr<IWICBitmapFrameDecode> frame;
-            hr = decoder->GetFrame(static_cast<UINT>(index), frame.GetAddressOf());
-            if (FAILED(hr))
-                return hr;
-
-            WICPixelFormatGUID pfGuid;
-            hr = frame->GetPixelFormat(&pfGuid);
-            if (FAILED(hr))
-                return hr;
-
-            UINT w, h;
-            hr = frame->GetSize(&w, &h);
-            if (FAILED(hr))
-                return hr;
-
-            if (w == metadata.width && h == metadata.height)
-            {
-                // This frame does not need resized
-                if (memcmp(&pfGuid, &sourceGUID, sizeof(WICPixelFormatGUID)) == 0)
-                {
-                    hr = frame->CopyPixels(nullptr, static_cast<UINT>(img->rowPitch), static_cast<UINT>(img->slicePitch), img->pixels);
-                    if (FAILED(hr))
-                        return hr;
-                }
-                else
-                {
-                    ComPtr<IWICFormatConverter> FC;
-                    hr = pWIC->CreateFormatConverter(FC.GetAddressOf());
-                    if (FAILED(hr))
-                        return hr;
-
-                    BOOL canConvert = FALSE;
-                    hr = FC->CanConvert(pfGuid, sourceGUID, &canConvert);
-                    if (FAILED(hr) || !canConvert)
-                    {
-                        return E_UNEXPECTED;
-                    }
-
-                    hr = FC->Initialize(frame.Get(), sourceGUID, GetWICDither(flags), nullptr,
-                        0, WICBitmapPaletteTypeMedianCut);
-                    if (FAILED(hr))
-                        return hr;
-
-                    hr = FC->CopyPixels(nullptr, static_cast<UINT>(img->rowPitch), static_cast<UINT>(img->slicePitch), img->pixels);
-                    if (FAILED(hr))
-                        return hr;
-                }
-            }
-            else
-            {
-                // This frame needs resizing
-                ComPtr<IWICBitmapScaler> scaler;
-                hr = pWIC->CreateBitmapScaler(scaler.GetAddressOf());
-                if (FAILED(hr))
-                    return hr;
-
-                hr = scaler->Initialize(frame.Get(),
-                    static_cast<UINT>(metadata.width), static_cast<UINT>(metadata.height),
-                    GetWICInterp(flags));
-                if (FAILED(hr))
-                    return hr;
-
-                WICPixelFormatGUID pfScaler;
-                hr = scaler->GetPixelFormat(&pfScaler);
-                if (FAILED(hr))
-                    return hr;
-
-                if (memcmp(&pfScaler, &sourceGUID, sizeof(WICPixelFormatGUID)) == 0)
-                {
-                    hr = scaler->CopyPixels(nullptr, static_cast<UINT>(img->rowPitch), static_cast<UINT>(img->slicePitch), img->pixels);
-                    if (FAILED(hr))
-                        return hr;
-                }
-                else
-                {
-                    // The WIC bitmap scaler is free to return a different pixel format than the source image, so here we
-                    // convert it to our desired format
-                    ComPtr<IWICFormatConverter> FC;
-                    hr = pWIC->CreateFormatConverter(FC.GetAddressOf());
-                    if (FAILED(hr))
-                        return hr;
-
-                    BOOL canConvert = FALSE;
-                    hr = FC->CanConvert(pfScaler, sourceGUID, &canConvert);
-                    if (FAILED(hr) || !canConvert)
-                    {
-                        return E_UNEXPECTED;
-                    }
-
-                    hr = FC->Initialize(scaler.Get(), sourceGUID, GetWICDither(flags), nullptr,
-                        0, WICBitmapPaletteTypeMedianCut);
-                    if (FAILED(hr))
-                        return hr;
-
-                    hr = FC->CopyPixels(nullptr, static_cast<UINT>(img->rowPitch), static_cast<UINT>(img->slicePitch), img->pixels);
-                    if (FAILED(hr))
-                        return hr;
-                }
-            }
-        }
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Encodes image metadata
-    //-------------------------------------------------------------------------------------
-    HRESULT EncodeMetadata(
-        WIC_FLAGS flags,
-        _In_ IWICBitmapFrameEncode* frame,
-        const GUID& containerFormat,
-        DXGI_FORMAT format)
-    {
-        if (!frame)
-            return E_POINTER;
-
-        ComPtr<IWICMetadataQueryWriter> metawriter;
-        HRESULT hr = frame->GetMetadataQueryWriter(metawriter.GetAddressOf());
-        if (SUCCEEDED(hr))
-        {
-            PROPVARIANT value;
-            PropVariantInit(&value);
-
-            const bool sRGB = ((flags & WIC_FLAGS_FORCE_LINEAR) == 0) && ((flags & WIC_FLAGS_FORCE_SRGB) != 0 || IsSRGB(format));
-
-            value.vt = VT_LPSTR;
-            value.pszVal = const_cast<char*>("DirectXTex");
-
-            if (memcmp(&containerFormat, &GUID_ContainerFormatPng, sizeof(GUID)) == 0)
-            {
-                // Set Software name
-                std::ignore = metawriter->SetMetadataByName(L"/tEXt/{str=Software}", &value);
-
-                // Set sRGB chunk
-                if (sRGB)
-                {
-                    value.vt = VT_UI1;
-                    value.bVal = 0;
-                    std::ignore = metawriter->SetMetadataByName(L"/sRGB/RenderingIntent", &value);
-                }
-                else
-                {
-                    // add gAMA chunk with gamma 1.0
-                    value.vt = VT_UI4;
-                    value.uintVal = 100000; // gama value * 100,000 -- i.e. gamma 1.0
-                    std::ignore = metawriter->SetMetadataByName(L"/gAMA/ImageGamma", &value);
-
-                    // remove sRGB chunk which is added by default.
-                    std::ignore = metawriter->RemoveMetadataByName(L"/sRGB/RenderingIntent");
-                }
-            }
-        #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
-            else if (memcmp(&containerFormat, &GUID_ContainerFormatJpeg, sizeof(GUID)) == 0)
-            {
-                // Set Software name
-                std::ignore = metawriter->SetMetadataByName(L"/app1/ifd/{ushort=305}", &value);
-
-                if (sRGB)
-                {
-                    // Set EXIF Colorspace of sRGB
-                    value.vt = VT_UI2;
-                    value.uiVal = 1;
-                    std::ignore = metawriter->SetMetadataByName(L"/app1/ifd/exif/{ushort=40961}", &value);
-                }
-            }
-            else if (memcmp(&containerFormat, &GUID_ContainerFormatTiff, sizeof(GUID)) == 0)
-            {
-                // Set Software name
-                std::ignore = metawriter->SetMetadataByName(L"/ifd/{ushort=305}", &value);
-
-                if (sRGB)
-                {
-                    // Set EXIF Colorspace of sRGB
-                    value.vt = VT_UI2;
-                    value.uiVal = 1;
-                    std::ignore = metawriter->SetMetadataByName(L"/ifd/exif/{ushort=40961}", &value);
-                }
-            }
-        #else
-            else
-            {
-                // Set Software name
-                std::ignore = metawriter->SetMetadataByName(L"System.ApplicationName", &value);
-
-                if (sRGB)
-                {
-                    // Set EXIF Colorspace of sRGB
-                    value.vt = VT_UI2;
-                    value.uiVal = 1;
-                    std::ignore = metawriter->SetMetadataByName(L"System.Image.ColorSpace", &value);
-                }
-            }
-        #endif
-        }
-        else if (hr == WINCODEC_ERR_UNSUPPORTEDOPERATION)
-        {
-            // Some formats just don't support metadata (BMP, ICO, etc.), so ignore this failure
-            hr = S_OK;
-        }
-
-        return hr;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Encodes a single frame
-    //-------------------------------------------------------------------------------------
-    HRESULT EncodeImage(
-        const Image& image,
-        WIC_FLAGS flags,
-        _In_ REFGUID containerFormat,
-        _In_ IWICBitmapFrameEncode* frame,
-        _In_opt_ IPropertyBag2* props,
-        _In_opt_ const GUID* targetFormat)
-    {
-        if (!frame)
-            return E_INVALIDARG;
-
-        if (!image.pixels)
-            return E_POINTER;
-
-        WICPixelFormatGUID pfGuid;
-        if (!DXGIToWIC(image.format, pfGuid))
-            return HRESULT_E_NOT_SUPPORTED;
-
-        HRESULT hr = frame->Initialize(props);
-        if (FAILED(hr))
-            return hr;
-
-        if ((image.width > UINT32_MAX) || (image.height > UINT32_MAX))
-            return E_INVALIDARG;
-
-        if (image.rowPitch > UINT32_MAX || image.slicePitch > UINT32_MAX)
-            return HRESULT_E_ARITHMETIC_OVERFLOW;
-
-        hr = frame->SetSize(static_cast<UINT>(image.width), static_cast<UINT>(image.height));
-        if (FAILED(hr))
-            return hr;
-
-        hr = frame->SetResolution(72, 72);
-        if (FAILED(hr))
-            return hr;
-
-        WICPixelFormatGUID targetGuid = (targetFormat) ? (*targetFormat) : pfGuid;
-        hr = frame->SetPixelFormat(&targetGuid);
-        if (FAILED(hr))
-            return hr;
-
-        if (targetFormat && memcmp(targetFormat, &targetGuid, sizeof(WICPixelFormatGUID)) != 0)
-        {
-            // Requested output pixel format is not supported by the WIC codec
-            return E_FAIL;
-        }
-
-        hr = EncodeMetadata(flags, frame, containerFormat, image.format);
-        if (FAILED(hr))
-            return hr;
-
-        if (memcmp(&targetGuid, &pfGuid, sizeof(WICPixelFormatGUID)) != 0)
-        {
-            // Conversion required to write
-            bool iswic2 = false;
-            auto pWIC = GetWICFactory(iswic2);
-            if (!pWIC)
-                return E_NOINTERFACE;
-
-            ComPtr<IWICBitmap> source;
-            hr = pWIC->CreateBitmapFromMemory(static_cast<UINT>(image.width), static_cast<UINT>(image.height), pfGuid,
-                static_cast<UINT>(image.rowPitch), static_cast<UINT>(image.slicePitch),
-                image.pixels, source.GetAddressOf());
-            if (FAILED(hr))
-                return hr;
-
-            ComPtr<IWICFormatConverter> FC;
-            hr = pWIC->CreateFormatConverter(FC.GetAddressOf());
-            if (FAILED(hr))
-                return hr;
-
-            BOOL canConvert = FALSE;
-            hr = FC->CanConvert(pfGuid, targetGuid, &canConvert);
-            if (FAILED(hr) || !canConvert)
-            {
-                return E_UNEXPECTED;
-            }
-
-            hr = FC->Initialize(source.Get(), targetGuid, GetWICDither(flags), nullptr,
-                0, WICBitmapPaletteTypeMedianCut);
-            if (FAILED(hr))
-                return hr;
-
-            WICRect rect = { 0, 0, static_cast<INT>(image.width), static_cast<INT>(image.height) };
-            hr = frame->WriteSource(FC.Get(), &rect);
-            if (FAILED(hr))
-                return hr;
-        }
-        else
-        {
-            // No conversion required
-            hr = frame->WritePixels(static_cast<UINT>(image.height), static_cast<UINT>(image.rowPitch), static_cast<UINT>(image.slicePitch),
-                reinterpret_cast<uint8_t*>(image.pixels));
-            if (FAILED(hr))
-                return hr;
-        }
-
-        hr = frame->Commit();
-        if (FAILED(hr))
-            return hr;
-
-        return S_OK;
-    }
-
-    HRESULT EncodeSingleFrame(
-        const Image& image,
-        WIC_FLAGS flags,
-        _In_ REFGUID containerFormat,
-        _Inout_ IStream* stream,
-        _In_opt_ const GUID* targetFormat,
-        _In_opt_ std::function<void(IPropertyBag2*)> setCustomProps)
-    {
-        if (!stream)
-            return E_INVALIDARG;
-
-        // Initialize WIC
-        bool iswic2 = false;
-        auto pWIC = GetWICFactory(iswic2);
-        if (!pWIC)
-            return E_NOINTERFACE;
-
-        ComPtr<IWICBitmapEncoder> encoder;
-        HRESULT hr = pWIC->CreateEncoder(containerFormat, nullptr, encoder.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        hr = encoder->Initialize(stream, WICBitmapEncoderNoCache);
-        if (FAILED(hr))
-            return hr;
-
-        ComPtr<IWICBitmapFrameEncode> frame;
-        ComPtr<IPropertyBag2> props;
-        hr = encoder->CreateNewFrame(frame.GetAddressOf(), props.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        if (memcmp(&containerFormat, &GUID_ContainerFormatBmp, sizeof(WICPixelFormatGUID)) == 0 && iswic2)
-        {
-            // Opt-in to the WIC2 support for writing 32-bit Windows BMP files with an alpha channel
-            PROPBAG2 option = {};
-            option.pstrName = const_cast<wchar_t*>(L"EnableV5Header32bppBGRA");
-
-            VARIANT varValue;
-            varValue.vt = VT_BOOL;
-            varValue.boolVal = VARIANT_TRUE;
-            std::ignore = props->Write(1, &option, &varValue);
-        }
-
-        if (setCustomProps)
-        {
-            setCustomProps(props.Get());
-        }
-
-        hr = EncodeImage(image, flags, containerFormat, frame.Get(), props.Get(), targetFormat);
-        if (FAILED(hr))
-            return hr;
-
-        hr = encoder->Commit();
-        if (FAILED(hr))
-            return hr;
-
-        return S_OK;
-    }
-
-
-    //-------------------------------------------------------------------------------------
-    // Encodes an image array
-    //-------------------------------------------------------------------------------------
-    HRESULT EncodeMultiframe(
-        _In_reads_(nimages) const Image* images,
-        size_t nimages,
-        WIC_FLAGS flags,
-        _In_ REFGUID containerFormat,
-        _Inout_ IStream* stream,
-        _In_opt_ const GUID* targetFormat,
-        _In_opt_ std::function<void(IPropertyBag2*)> setCustomProps)
-    {
-        if (!stream || nimages < 2)
-            return E_INVALIDARG;
-
-        if (!images)
-            return E_POINTER;
-
-        // Initialize WIC
-        bool iswic2 = false;
-        auto pWIC = GetWICFactory(iswic2);
-        if (!pWIC)
-            return E_NOINTERFACE;
-
-        ComPtr<IWICBitmapEncoder> encoder;
-        HRESULT hr = pWIC->CreateEncoder(containerFormat, nullptr, encoder.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        ComPtr<IWICBitmapEncoderInfo> einfo;
-        hr = encoder->GetEncoderInfo(einfo.GetAddressOf());
-        if (FAILED(hr))
-            return hr;
-
-        BOOL mframe = FALSE;
-        hr = einfo->DoesSupportMultiframe(&mframe);
-        if (FAILED(hr))
-            return hr;
-
-        if (!mframe)
-            return HRESULT_E_NOT_SUPPORTED;
-
-        hr = encoder->Initialize(stream, WICBitmapEncoderNoCache);
-        if (FAILED(hr))
-            return hr;
-
-        for (size_t index = 0; index < nimages; ++index)
-        {
-            ComPtr<IWICBitmapFrameEncode> frame;
-            ComPtr<IPropertyBag2> props;
-            hr = encoder->CreateNewFrame(frame.GetAddressOf(), props.GetAddressOf());
-            if (FAILED(hr))
-                return hr;
-
-            if (setCustomProps)
-            {
-                setCustomProps(props.Get());
-            }
-
-            hr = EncodeImage(images[index], flags, containerFormat, frame.Get(), props.Get(), targetFormat);
-            if (FAILED(hr))
-                return hr;
-        }
-
-        hr = encoder->Commit();
-        if (FAILED(hr))
-            return hr;
-
-        return S_OK;
-    }
-}
-
-
-//=====================================================================================
-// Entry-points
-//=====================================================================================
-
-//-------------------------------------------------------------------------------------
-// Obtain metadata from WIC-supported file in memory
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::GetMetadataFromWICMemory(
-    const void* pSource,
-    size_t size,
-    WIC_FLAGS flags,
-    TexMetadata& metadata,
-    std::function<void(IWICMetadataQueryReader*)> getMQR)
-{
-    if (!pSource || size == 0)
-        return E_INVALIDARG;
-
-    if (size > UINT32_MAX)
-        return HRESULT_E_FILE_TOO_LARGE;
-
-    bool iswic2 = false;
-    auto pWIC = GetWICFactory(iswic2);
-    if (!pWIC)
-        return E_NOINTERFACE;
-
-    // Create input stream for memory
-    ComPtr<IWICStream> stream;
-    HRESULT hr = pWIC->CreateStream(stream.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    hr = stream->InitializeFromMemory(static_cast<BYTE*>(const_cast<void*>(pSource)),
-        static_cast<UINT>(size));
-    if (FAILED(hr))
-        return hr;
-
-    // Initialize WIC
-    ComPtr<IWICBitmapDecoder> decoder;
-    hr = pWIC->CreateDecoderFromStream(stream.Get(), nullptr, WICDecodeMetadataCacheOnDemand, decoder.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    ComPtr<IWICBitmapFrameDecode> frame;
-    hr = decoder->GetFrame(0, frame.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    // Get metadata
-    hr = DecodeMetadata(flags, iswic2, decoder.Get(), frame.Get(), metadata, nullptr, getMQR);
-    if (FAILED(hr))
-        return hr;
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Obtain metadata from WIC-supported file on disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::GetMetadataFromWICFile(
-    const wchar_t* szFile,
-    WIC_FLAGS flags,
-    TexMetadata& metadata,
-    std::function<void(IWICMetadataQueryReader*)> getMQR)
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-    bool iswic2 = false;
-    auto pWIC = GetWICFactory(iswic2);
-    if (!pWIC)
-        return E_NOINTERFACE;
-
-    // Initialize WIC
-    ComPtr<IWICBitmapDecoder> decoder;
-    HRESULT hr = pWIC->CreateDecoderFromFilename(szFile, nullptr, GENERIC_READ, WICDecodeMetadataCacheOnDemand, decoder.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    ComPtr<IWICBitmapFrameDecode> frame;
-    hr = decoder->GetFrame(0, frame.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    // Get metadata
-    hr = DecodeMetadata(flags, iswic2, decoder.Get(), frame.Get(), metadata, nullptr, getMQR);
-    if (FAILED(hr))
-        return hr;
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Load a WIC-supported file in memory
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::LoadFromWICMemory(
-    const void* pSource,
-    size_t size,
-    WIC_FLAGS flags,
-    TexMetadata* metadata,
-    ScratchImage& image,
-    std::function<void(IWICMetadataQueryReader*)> getMQR)
-{
-    if (!pSource || size == 0)
-        return E_INVALIDARG;
-
-    if (size > UINT32_MAX)
-        return HRESULT_E_FILE_TOO_LARGE;
-
-    bool iswic2 = false;
-    auto pWIC = GetWICFactory(iswic2);
-    if (!pWIC)
-        return E_NOINTERFACE;
-
-    image.Release();
-
-    // Create input stream for memory
-    ComPtr<IWICStream> stream;
-    HRESULT hr = pWIC->CreateStream(stream.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    hr = stream->InitializeFromMemory(static_cast<uint8_t*>(const_cast<void*>(pSource)), static_cast<DWORD>(size));
-    if (FAILED(hr))
-        return hr;
-
-    // Initialize WIC
-    ComPtr<IWICBitmapDecoder> decoder;
-    hr = pWIC->CreateDecoderFromStream(stream.Get(), nullptr, WICDecodeMetadataCacheOnDemand, decoder.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    ComPtr<IWICBitmapFrameDecode> frame;
-    hr = decoder->GetFrame(0, frame.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    // Get metadata
-    TexMetadata mdata = {};
-    WICPixelFormatGUID convertGUID = {};
-    hr = DecodeMetadata(flags, iswic2, decoder.Get(), frame.Get(), mdata, &convertGUID, getMQR);
-    if (FAILED(hr))
-        return hr;
-
-    if ((mdata.arraySize > 1) && (flags & WIC_FLAGS_ALL_FRAMES))
-    {
-        hr = DecodeMultiframe(flags, mdata, decoder.Get(), image);
-    }
-    else
-    {
-        hr = DecodeSingleFrame(flags, mdata, convertGUID, frame.Get(), image);
-    }
-
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-
-    if (metadata)
-        memcpy(metadata, &mdata, sizeof(TexMetadata));
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Load a WIC-supported file from disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::LoadFromWICFile(
-    const wchar_t* szFile,
-    WIC_FLAGS flags,
-    TexMetadata* metadata,
-    ScratchImage& image,
-    std::function<void(IWICMetadataQueryReader*)> getMQR)
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-    bool iswic2 = false;
-    auto pWIC = GetWICFactory(iswic2);
-    if (!pWIC)
-        return E_NOINTERFACE;
-
-    image.Release();
-
-    // Initialize WIC
-    ComPtr<IWICBitmapDecoder> decoder;
-    HRESULT hr = pWIC->CreateDecoderFromFilename(szFile, nullptr, GENERIC_READ, WICDecodeMetadataCacheOnDemand, decoder.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    ComPtr<IWICBitmapFrameDecode> frame;
-    hr = decoder->GetFrame(0, frame.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    // Get metadata
-    TexMetadata mdata = {};
-    WICPixelFormatGUID convertGUID = {};
-    hr = DecodeMetadata(flags, iswic2, decoder.Get(), frame.Get(), mdata, &convertGUID, getMQR);
-    if (FAILED(hr))
-        return hr;
-
-    if ((mdata.arraySize > 1) && (flags & WIC_FLAGS_ALL_FRAMES))
-    {
-        hr = DecodeMultiframe(flags, mdata, decoder.Get(), image);
-    }
-    else
-    {
-        hr = DecodeSingleFrame(flags, mdata, convertGUID, frame.Get(), image);
-    }
-
-    if (FAILED(hr))
-    {
-        image.Release();
-        return hr;
-    }
-
-    if (metadata)
-        memcpy(metadata, &mdata, sizeof(TexMetadata));
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a WIC-supported file to memory
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::SaveToWICMemory(
-    const Image& image,
-    WIC_FLAGS flags,
-    REFGUID containerFormat,
-    Blob& blob,
-    const GUID* targetFormat,
-    std::function<void(IPropertyBag2*)> setCustomProps)
-{
-    if (!image.pixels)
-        return E_POINTER;
-
-    HRESULT hr = blob.Initialize(65535u);
-    if (FAILED(hr))
-        return hr;
-
-    ComPtr<MemoryStreamOnBlob> stream;
-    hr = MemoryStreamOnBlob::CreateMemoryStream(&stream, blob);
-    if (FAILED(hr))
-    {
-        blob.Release();
-        return hr;
-    }
-
-    hr = EncodeSingleFrame(image, flags, containerFormat, stream.Get(), targetFormat, setCustomProps);
-    if (FAILED(hr))
-    {
-        blob.Release();
-        return hr;
-    }
-
-    hr = stream->Finialize();
-    if (FAILED(hr))
-    {
-        blob.Release();
-        return hr;
-    }
-
-    stream.Reset();
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::SaveToWICMemory(
-    const Image* images,
-    size_t nimages,
-    WIC_FLAGS flags,
-    REFGUID containerFormat,
-    Blob& blob,
-    const GUID* targetFormat,
-    std::function<void(IPropertyBag2*)> setCustomProps)
-{
-    if (!images || nimages == 0)
-        return E_INVALIDARG;
-
-    HRESULT hr = blob.Initialize(65535u);
-    if (FAILED(hr))
-        return hr;
-
-    ComPtr<MemoryStreamOnBlob> stream;
-    hr = MemoryStreamOnBlob::CreateMemoryStream(&stream, blob);
-    if (FAILED(hr))
-    {
-        blob.Release();
-        return hr;
-    }
-
-    if (nimages > 1)
-        hr = EncodeMultiframe(images, nimages, flags, containerFormat, stream.Get(), targetFormat, setCustomProps);
-    else
-        hr = EncodeSingleFrame(images[0], flags, containerFormat, stream.Get(), targetFormat, setCustomProps);
-
-    if (FAILED(hr))
-    {
-        blob.Release();
-        return hr;
-    }
-
-    hr = stream->Finialize();
-    if (FAILED(hr))
-    {
-        blob.Release();
-        return hr;
-    }
-
-    stream.Reset();
-
-    return S_OK;
-}
-
-
-//-------------------------------------------------------------------------------------
-// Save a WIC-supported file to disk
-//-------------------------------------------------------------------------------------
-_Use_decl_annotations_
-HRESULT DirectX::SaveToWICFile(
-    const Image& image,
-    WIC_FLAGS flags,
-    REFGUID containerFormat,
-    const wchar_t* szFile,
-    const GUID* targetFormat,
-    std::function<void(IPropertyBag2*)> setCustomProps)
-{
-    if (!szFile)
-        return E_INVALIDARG;
-
-    if (!image.pixels)
-        return E_POINTER;
-
-    bool iswic2 = false;
-    auto pWIC = GetWICFactory(iswic2);
-    if (!pWIC)
-        return E_NOINTERFACE;
-
-    ComPtr<IWICStream> stream;
-    HRESULT hr = pWIC->CreateStream(stream.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    hr = stream->InitializeFromFilename(szFile, GENERIC_WRITE);
-    if (FAILED(hr))
-        return hr;
-
-    hr = EncodeSingleFrame(image, flags, containerFormat, stream.Get(), targetFormat, setCustomProps);
-    if (FAILED(hr))
-    {
-        stream.Reset();
-        std::ignore = DeleteFileW(szFile);
-        return hr;
-    }
-
-    return S_OK;
-}
-
-_Use_decl_annotations_
-HRESULT DirectX::SaveToWICFile(
-    const Image* images,
-    size_t nimages,
-    WIC_FLAGS flags,
-    REFGUID containerFormat,
-    const wchar_t* szFile,
-    const GUID* targetFormat,
-    std::function<void(IPropertyBag2*)> setCustomProps)
-{
-    if (!szFile || !images || nimages == 0)
-        return E_INVALIDARG;
-
-    bool iswic2 = false;
-    auto pWIC = GetWICFactory(iswic2);
-    if (!pWIC)
-        return E_NOINTERFACE;
-
-    ComPtr<IWICStream> stream;
-    HRESULT hr = pWIC->CreateStream(stream.GetAddressOf());
-    if (FAILED(hr))
-        return hr;
-
-    hr = stream->InitializeFromFilename(szFile, GENERIC_WRITE);
-    if (FAILED(hr))
-        return hr;
-
-    if (nimages > 1)
-        hr = EncodeMultiframe(images, nimages, flags, containerFormat, stream.Get(), targetFormat, setCustomProps);
-    else
-        hr = EncodeSingleFrame(images[0], flags, containerFormat, stream.Get(), targetFormat, setCustomProps);
-
-    if (FAILED(hr))
-    {
-        stream.Reset();
-        std::ignore = DeleteFileW(szFile);
-        return hr;
-    }
-
-    return S_OK;
-}
diff --git a/thirdparty/directxtex/LICENSE b/thirdparty/directxtex/LICENSE
deleted file mode 100644
index 74684a0..0000000
--- a/thirdparty/directxtex/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-                               The MIT License (MIT)
-
-Copyright (c) 2011-2021 Microsoft Corp
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this
-software and associated documentation files (the "Software"), to deal in the Software
-without restriction, including without limitation the rights to use, copy, modify,
-merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be included in all copies
-or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
-CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
-OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/thirdparty/directxtex/Shaders/BC6HEncode.hlsl b/thirdparty/directxtex/Shaders/BC6HEncode.hlsl
deleted file mode 100644
index 7daea76..0000000
--- a/thirdparty/directxtex/Shaders/BC6HEncode.hlsl
+++ /dev/null
@@ -1,2567 +0,0 @@
-//--------------------------------------------------------------------------------------
-// File: BC6HEncode.hlsl
-//
-// The Compute Shader for BC6H Encoder
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//--------------------------------------------------------------------------------------
-
-#define REF_DEVICE
-
-#define UINTLENGTH            32
-#define NCHANNELS             3
-#define SIGNED_F16            96
-#define UNSIGNED_F16          95
-#define MAX_FLOAT             asfloat(0x7F7FFFFF)
-#define MIN_FLOAT             asfloat(0xFF7FFFFF)
-#define MAX_INT               asint(0x7FFFFFFF)
-#define MIN_INT               asint(0x80000000)
-
-cbuffer cbCS : register(b0)
-{
-    uint g_tex_width;
-    uint g_num_block_x;
-    uint g_format;            //either SIGNED_F16 for DXGI_FORMAT_BC6H_SF16 or UNSIGNED_F16 for DXGI_FORMAT_BC6H_UF16
-    uint g_mode_id;
-    uint g_start_block_id;
-    uint g_num_total_blocks;
-};
-
-static const uint candidateModeMemory[14] = { 0x00, 0x01, 0x02, 0x06, 0x0A, 0x0E, 0x12, 0x16, 0x1A, 0x1E, 0x03, 0x07, 0x0B, 0x0F };
-static const uint candidateModeFlag[14] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
-static const bool candidateModeTransformed[14] = { true, true, true, true, true, true, true, true, true, false, false, true, true, true };
-static const uint4 candidateModePrec[14] = { uint4(10,5,5,5), uint4(7,6,6,6),
-    uint4(11,5,4,4), uint4(11,4,5,4), uint4(11,4,4,5), uint4(9,5,5,5),
-    uint4(8,6,5,5), uint4(8,5,6,5), uint4(8,5,5,6), uint4(6,6,6,6),
-    uint4(10,10,10,10), uint4(11,9,9,9), uint4(12,8,8,8), uint4(16,4,4,4) };
-
-/*static const uint4x4 candidateSection[32] =
-{
-    {0,0,1,1, 0,0,1,1, 0,0,1,1, 0,0,1,1}, {0,0,0,1, 0,0,0,1, 0,0,0,1, 0,0,0,1}, {0,1,1,1, 0,1,1,1, 0,1,1,1, 0,1,1,1}, {0,0,0,1, 0,0,1,1, 0,0,1,1, 0,1,1,1},
-    {0,0,0,0, 0,0,0,1, 0,0,0,1, 0,0,1,1}, {0,0,1,1, 0,1,1,1, 0,1,1,1, 1,1,1,1}, {0,0,0,1, 0,0,1,1, 0,1,1,1, 1,1,1,1}, {0,0,0,0, 0,0,0,1, 0,0,1,1, 0,1,1,1},
-    {0,0,0,0, 0,0,0,0, 0,0,0,1, 0,0,1,1}, {0,0,1,1, 0,1,1,1, 1,1,1,1, 1,1,1,1}, {0,0,0,0, 0,0,0,1, 0,1,1,1, 1,1,1,1}, {0,0,0,0, 0,0,0,0, 0,0,0,1, 0,1,1,1},
-    {0,0,0,1, 0,1,1,1, 1,1,1,1, 1,1,1,1}, {0,0,0,0, 0,0,0,0, 1,1,1,1, 1,1,1,1}, {0,0,0,0, 1,1,1,1, 1,1,1,1, 1,1,1,1}, {0,0,0,0, 0,0,0,0, 0,0,0,0, 1,1,1,1},
-    {0,0,0,0, 1,0,0,0, 1,1,1,0, 1,1,1,1}, {0,1,1,1, 0,0,0,1, 0,0,0,0, 0,0,0,0}, {0,0,0,0, 0,0,0,0, 1,0,0,0, 1,1,1,0}, {0,1,1,1, 0,0,1,1, 0,0,0,1, 0,0,0,0},
-    {0,0,1,1, 0,0,0,1, 0,0,0,0, 0,0,0,0}, {0,0,0,0, 1,0,0,0, 1,1,0,0, 1,1,1,0}, {0,0,0,0, 0,0,0,0, 1,0,0,0, 1,1,0,0}, {0,1,1,1, 0,0,1,1, 0,0,1,1, 0,0,0,1},
-    {0,0,1,1, 0,0,0,1, 0,0,0,1, 0,0,0,0}, {0,0,0,0, 1,0,0,0, 1,0,0,0, 1,1,0,0}, {0,1,1,0, 0,1,1,0, 0,1,1,0, 0,1,1,0}, {0,0,1,1, 0,1,1,0, 0,1,1,0, 1,1,0,0},
-    {0,0,0,1, 0,1,1,1, 1,1,1,0, 1,0,0,0}, {0,0,0,0, 1,1,1,1, 1,1,1,1, 0,0,0,0}, {0,1,1,1, 0,0,0,1, 1,0,0,0, 1,1,1,0}, {0,0,1,1, 1,0,0,1, 1,0,0,1, 1,1,0,0}
-};*/
-
-static const uint candidateSectionBit[32] =
-{
-    0xCCCC, 0x8888, 0xEEEE, 0xECC8,
-    0xC880, 0xFEEC, 0xFEC8, 0xEC80,
-    0xC800, 0xFFEC, 0xFE80, 0xE800,
-    0xFFE8, 0xFF00, 0xFFF0, 0xF000,
-    0xF710, 0x008E, 0x7100, 0x08CE,
-    0x008C, 0x7310, 0x3100, 0x8CCE,
-    0x088C, 0x3110, 0x6666, 0x366C,
-    0x17E8, 0x0FF0, 0x718E, 0x399C
-};
-
-static const uint candidateFixUpIndex1D[32] =
-{
-    15,15,15,15,
-    15,15,15,15,
-    15,15,15,15,
-    15,15,15,15,
-    15, 2, 8, 2,
-     2, 8, 8,15,
-     2, 8, 2, 2,
-     8, 8, 2, 2
-};
-
-//0, 9, 18, 27, 37, 46, 55, 64
-static const uint aStep1[64] = { 0,0,0,0,0,1,1,1,
-                              1,1,1,1,1,1,2,2,
-                              2,2,2,2,2,2,2,3,
-                              3,3,3,3,3,3,3,3,
-                              3,4,4,4,4,4,4,4,
-                              4,4,5,5,5,5,5,5,
-                              5,5,5,6,6,6,6,6,
-                              6,6,6,6,7,7,7,7 };
-
-//0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64
-static const uint aStep2[64] = { 0, 0, 0, 1, 1, 1, 1, 2,
-                               2, 2, 2, 2, 3, 3, 3, 3,
-                               4, 4, 4, 4, 5, 5, 5, 5,
-                               6, 6, 6, 6, 6, 7, 7, 7,
-                               7, 8, 8, 8, 8, 9, 9, 9,
-                               9,10,10,10,10,10,11,11,
-                              11,11,12,12,12,12,13,13,
-                              13,13,14,14,14,14,15,15 };
-
-static const float3 RGB2LUM = float3(0.2126f, 0.7152f, 0.0722f);
-
-#define THREAD_GROUP_SIZE    64
-#define BLOCK_SIZE_Y         4
-#define BLOCK_SIZE_X         4
-#define BLOCK_SIZE           (BLOCK_SIZE_Y * BLOCK_SIZE_X)
-
-
-//Forward declaration
-uint3 float2half(float3 pixel_f);
-int3 start_quantize(uint3 pixel_h);
-void quantize(inout int2x3 endPoint, uint prec);
-void finish_quantize_0(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed);
-void finish_quantize_1(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed);
-void finish_quantize(out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed);
-
-void start_unquantize(inout int2x3 endPoint[2], uint4 prec, bool transformed);
-void start_unquantize(inout int2x3 endPoint, uint4 prec, bool transformed);
-void unquantize(inout int2x3 color, uint prec);
-uint3 finish_unquantize(int3 color);
-void generate_palette_unquantized8(out uint3 palette, int3 low, int3 high, int i);
-void generate_palette_unquantized16(out uint3 palette, int3 low, int3 high, int i);
-float3 half2float(uint3 color_h);
-
-void block_package(inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index);
-void block_package(inout uint4 block, int2x3 endPoint, uint mode_type);
-
-void swap(inout int3 lhs, inout int3 rhs)
-{
-    int3 tmp = lhs;
-    lhs = rhs;
-    rhs = tmp;
-}
-
-Texture2D<float4> g_Input : register(t0);
-StructuredBuffer<uint4> g_InBuff : register(t1);
-
-RWStructuredBuffer<uint4> g_OutBuff : register(u0);
-
-struct SharedData
-{
-    float3 pixel;
-    int3 pixel_ph;
-    float3 pixel_hr;
-    float pixel_lum;
-    float error;
-    uint best_mode;
-    uint best_partition;
-    int3 endPoint_low;
-    int3 endPoint_high;
-    float endPoint_lum_low;
-    float endPoint_lum_high;
-};
-
-groupshared SharedData shared_temp[THREAD_GROUP_SIZE];
-
-[numthreads(THREAD_GROUP_SIZE, 1, 1)]
-void TryModeG10CS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
-{
-    const uint MAX_USED_THREAD = 16;
-    uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
-    uint blockInGroup = GI / MAX_USED_THREAD;
-    uint blockID = g_start_block_id + groupID.x * BLOCK_IN_GROUP + blockInGroup;
-    uint threadBase = blockInGroup * MAX_USED_THREAD;
-    uint threadInBlock = GI - threadBase;
-
-#ifndef REF_DEVICE
-    if (blockID >= g_num_total_blocks)
-    {
-        return;
-    }
-#endif
-
-    uint block_y = blockID / g_num_block_x;
-    uint block_x = blockID - block_y * g_num_block_x;
-    uint base_x = block_x * BLOCK_SIZE_X;
-    uint base_y = block_y * BLOCK_SIZE_Y;
-
-    if (threadInBlock < 16)
-    {
-        shared_temp[GI].pixel = g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)).rgb;
-        uint3 pixel_h = float2half(shared_temp[GI].pixel);
-        shared_temp[GI].pixel_hr = half2float(pixel_h);
-        shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel_hr, RGB2LUM);
-        shared_temp[GI].pixel_ph = start_quantize(pixel_h);
-
-        shared_temp[GI].endPoint_low = shared_temp[GI].pixel_ph;
-        shared_temp[GI].endPoint_high = shared_temp[GI].pixel_ph;
-        shared_temp[GI].endPoint_lum_low = shared_temp[GI].pixel_lum;
-        shared_temp[GI].endPoint_lum_high = shared_temp[GI].pixel_lum;
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 8)
-    {
-        if (shared_temp[GI].endPoint_lum_low > shared_temp[GI + 8].endPoint_lum_low)
-        {
-            shared_temp[GI].endPoint_low = shared_temp[GI + 8].endPoint_low;
-            shared_temp[GI].endPoint_lum_low = shared_temp[GI + 8].endPoint_lum_low;
-        }
-        if (shared_temp[GI].endPoint_lum_high < shared_temp[GI + 8].endPoint_lum_high)
-        {
-            shared_temp[GI].endPoint_high = shared_temp[GI + 8].endPoint_high;
-            shared_temp[GI].endPoint_lum_high = shared_temp[GI + 8].endPoint_lum_high;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 4)
-    {
-        if (shared_temp[GI].endPoint_lum_low > shared_temp[GI + 4].endPoint_lum_low)
-        {
-            shared_temp[GI].endPoint_low = shared_temp[GI + 4].endPoint_low;
-            shared_temp[GI].endPoint_lum_low = shared_temp[GI + 4].endPoint_lum_low;
-        }
-        if (shared_temp[GI].endPoint_lum_high < shared_temp[GI + 4].endPoint_lum_high)
-        {
-            shared_temp[GI].endPoint_high = shared_temp[GI + 4].endPoint_high;
-            shared_temp[GI].endPoint_lum_high = shared_temp[GI + 4].endPoint_lum_high;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 2)
-    {
-        if (shared_temp[GI].endPoint_lum_low > shared_temp[GI + 2].endPoint_lum_low)
-        {
-            shared_temp[GI].endPoint_low = shared_temp[GI + 2].endPoint_low;
-            shared_temp[GI].endPoint_lum_low = shared_temp[GI + 2].endPoint_lum_low;
-        }
-        if (shared_temp[GI].endPoint_lum_high < shared_temp[GI + 2].endPoint_lum_high)
-        {
-            shared_temp[GI].endPoint_high = shared_temp[GI + 2].endPoint_high;
-            shared_temp[GI].endPoint_lum_high = shared_temp[GI + 2].endPoint_lum_high;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 1)
-    {
-        if (shared_temp[GI].endPoint_lum_low > shared_temp[GI + 1].endPoint_lum_low)
-        {
-            shared_temp[GI].endPoint_low = shared_temp[GI + 1].endPoint_low;
-            shared_temp[GI].endPoint_lum_low = shared_temp[GI + 1].endPoint_lum_low;
-        }
-        if (shared_temp[GI].endPoint_lum_high < shared_temp[GI + 1].endPoint_lum_high)
-        {
-            shared_temp[GI].endPoint_high = shared_temp[GI + 1].endPoint_high;
-            shared_temp[GI].endPoint_lum_high = shared_temp[GI + 1].endPoint_lum_high;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    //ergod mode_type 11:14
-    if (threadInBlock == 0)
-    {
-        int2x3 endPoint;
-        // find_axis
-        endPoint[0] = shared_temp[threadBase + 0].endPoint_low;
-        endPoint[1] = shared_temp[threadBase + 0].endPoint_high;
-
-        //compute_index
-        float3 span = endPoint[1] - endPoint[0];// fixed a bug in v0.2
-        float span_norm_sqr = dot(span, span);// fixed a bug in v0.2
-        float dotProduct = dot(span, shared_temp[threadBase + 0].pixel_ph - endPoint[0]);// fixed a bug in v0.2
-        if (span_norm_sqr > 0 && dotProduct >= 0 && uint(dotProduct * 63.49999 / span_norm_sqr) > 32)
-        {
-            swap(endPoint[0], endPoint[1]);
-
-            shared_temp[GI].endPoint_low = endPoint[0];
-            shared_temp[GI].endPoint_high = endPoint[1];
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 4)
-    {
-        int2x3 endPoint;
-        endPoint[0] = shared_temp[threadBase + 0].endPoint_low;
-        endPoint[1] = shared_temp[threadBase + 0].endPoint_high;
-
-        float3 span = endPoint[1] - endPoint[0];
-        float span_norm_sqr = dot(span, span);
-
-        uint4 prec = candidateModePrec[threadInBlock + 10];
-        int2x3 endPoint_q = endPoint;
-        quantize(endPoint_q, prec.x);
-
-        bool transformed = candidateModeTransformed[threadInBlock + 10];
-        if (transformed)
-        {
-            endPoint_q[1] -= endPoint_q[0];
-        }
-
-        bool bBadQuantize;
-        finish_quantize(bBadQuantize, endPoint_q, prec, transformed);
-
-        start_unquantize(endPoint_q, prec, transformed);
-
-        unquantize(endPoint_q, prec.x);
-
-        float error = 0;
-        [loop] for (uint j = 0; j < 16; j++)
-        {
-            float dotProduct = dot(span, shared_temp[threadBase + j].pixel_ph - endPoint[0]);// fixed a bug in v0.2
-            uint index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
-                : ((dotProduct < span_norm_sqr) ? aStep2[uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep2[63]);
-
-            uint3 pixel_rh;
-            generate_palette_unquantized16(pixel_rh, endPoint_q[0], endPoint_q[1], index);
-            float3 pixel_r = half2float(pixel_rh);
-            pixel_r -= shared_temp[threadBase + j].pixel_hr;
-            error += dot(pixel_r, pixel_r);
-        }
-        if (bBadQuantize)
-            error = 1e20f;
-
-        shared_temp[GI].error = error;
-        shared_temp[GI].best_mode = candidateModeFlag[threadInBlock + 10];
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 2)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 2].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 2].error;
-            shared_temp[GI].best_mode = shared_temp[GI + 2].best_mode;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 1)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 1].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 1].error;
-            shared_temp[GI].best_mode = shared_temp[GI + 1].best_mode;
-        }
-
-        g_OutBuff[blockID] = uint4(asuint(shared_temp[GI].error), shared_temp[GI].best_mode, 0, 0);
-    }
-}
-
-[numthreads(THREAD_GROUP_SIZE, 1, 1)]
-void TryModeLE10CS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
-{
-    const uint MAX_USED_THREAD = 32;
-    uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
-    uint blockInGroup = GI / MAX_USED_THREAD;
-    uint blockID = g_start_block_id + groupID.x * BLOCK_IN_GROUP + blockInGroup;
-    uint threadBase = blockInGroup * MAX_USED_THREAD;
-    uint threadInBlock = GI - threadBase;
-
-#ifndef REF_DEVICE
-    if (blockID >= g_num_total_blocks)
-    {
-        return;
-    }
-
-    if (asfloat(g_InBuff[blockID].x) < 1e-6f)
-    {
-        g_OutBuff[blockID] = g_InBuff[blockID];
-        return;
-    }
-#endif
-
-    uint block_y = blockID / g_num_block_x;
-    uint block_x = blockID - block_y * g_num_block_x;
-    uint base_x = block_x * BLOCK_SIZE_X;
-    uint base_y = block_y * BLOCK_SIZE_Y;
-
-    if (threadInBlock < 16)
-    {
-        shared_temp[GI].pixel = g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)).rgb;
-        uint3 pixel_h = float2half(shared_temp[GI].pixel);
-        shared_temp[GI].pixel_hr = half2float(pixel_h);
-        shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel_hr, RGB2LUM);
-        shared_temp[GI].pixel_ph = start_quantize(pixel_h);
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    //ergod mode_type 1:10
-    if (threadInBlock < 32)
-    {
-        // find_axis
-        int2x3 endPoint[2];
-        endPoint[0][0] = MAX_INT;
-        endPoint[0][1] = MIN_INT;
-        endPoint[1][0] = MAX_INT;
-        endPoint[1][1] = MIN_INT;
-
-        float2 endPoint_lum[2];
-        endPoint_lum[0][0] = MAX_FLOAT;
-        endPoint_lum[0][1] = MIN_FLOAT;
-        endPoint_lum[1][0] = MAX_FLOAT;
-        endPoint_lum[1][1] = MIN_FLOAT;
-
-        uint bit = candidateSectionBit[threadInBlock];
-        for (uint i = 0; i < 16; i++)
-        {
-            int3 pixel_ph = shared_temp[threadBase + i].pixel_ph;
-            float pixel_lum = shared_temp[threadBase + i].pixel_lum;
-            if ((bit >> i) & 1) //It gets error when using "candidateSection" as "endPoint_ph" index
-            {
-                if (endPoint_lum[1][0] > pixel_lum)
-                {
-                    endPoint[1][0] = pixel_ph;
-                    endPoint_lum[1][0] = pixel_lum;
-                }
-                if (endPoint_lum[1][1] < pixel_lum)
-                {
-                    endPoint[1][1] = pixel_ph;
-                    endPoint_lum[1][1] = pixel_lum;
-                }
-            }
-            else
-            {
-                if (endPoint_lum[0][0] > pixel_lum)
-                {
-                    endPoint[0][0] = pixel_ph;
-                    endPoint_lum[0][0] = pixel_lum;
-                }
-                if (endPoint_lum[0][1] < pixel_lum)
-                {
-                    endPoint[0][1] = pixel_ph;
-                    endPoint_lum[0][1] = pixel_lum;
-                }
-            }
-        }
-
-        //compute_index
-        float3 span[2];// fixed a bug in v0.2
-        float span_norm_sqr[2];// fixed a bug in v0.2
-        [unroll]
-        for (uint p = 0; p < 2; ++p)
-        {
-            span[p] = endPoint[p][1] - endPoint[p][0];
-            span_norm_sqr[p] = dot(span[p], span[p]);
-
-            float dotProduct = dot(span[p], shared_temp[threadBase + (0 == p ? 0 : candidateFixUpIndex1D[threadInBlock])].pixel_ph - endPoint[p][0]);// fixed a bug in v0.2
-            if (span_norm_sqr[p] > 0 && dotProduct >= 0 && uint(dotProduct * 63.49999 / span_norm_sqr[p]) > 32)
-            {
-                span[p] = -span[p];
-                swap(endPoint[p][0], endPoint[p][1]);
-            }
-        }
-
-        uint4 prec = candidateModePrec[g_mode_id];
-        int2x3 endPoint_q[2] = endPoint;
-        quantize(endPoint_q[0], prec.x);
-        quantize(endPoint_q[1], prec.x);
-
-        bool transformed = candidateModeTransformed[g_mode_id];
-        if (transformed)
-        {
-            endPoint_q[0][1] -= endPoint_q[0][0];
-            endPoint_q[1][0] -= endPoint_q[0][0];
-            endPoint_q[1][1] -= endPoint_q[0][0];
-        }
-
-        int bBadQuantize = 0;
-        finish_quantize_0(bBadQuantize, endPoint_q[0], prec, transformed);
-        finish_quantize_1(bBadQuantize, endPoint_q[1], prec, transformed);
-
-        start_unquantize(endPoint_q, prec, transformed);
-
-        unquantize(endPoint_q[0], prec.x);
-        unquantize(endPoint_q[1], prec.x);
-
-        float error = 0;
-        for (uint j = 0; j < 16; j++)
-        {
-            uint3 pixel_rh;
-            if ((bit >> j) & 1)
-            {
-                float dotProduct = dot(span[1], shared_temp[threadBase + j].pixel_ph - endPoint[1][0]);// fixed a bug in v0.2
-                uint index = (span_norm_sqr[1] <= 0 || dotProduct <= 0) ? 0
-                    : ((dotProduct < span_norm_sqr[1]) ? aStep1[uint(dotProduct * 63.49999 / span_norm_sqr[1])] : aStep1[63]);
-                generate_palette_unquantized8(pixel_rh, endPoint_q[1][0], endPoint_q[1][1], index);
-            }
-            else
-            {
-                float dotProduct = dot(span[0], shared_temp[threadBase + j].pixel_ph - endPoint[0][0]);// fixed a bug in v0.2
-                uint index = (span_norm_sqr[0] <= 0 || dotProduct <= 0) ? 0
-                    : ((dotProduct < span_norm_sqr[0]) ? aStep1[uint(dotProduct * 63.49999 / span_norm_sqr[0])] : aStep1[63]);
-                generate_palette_unquantized8(pixel_rh, endPoint_q[0][0], endPoint_q[0][1], index);
-            }
-
-            float3 pixel_r = half2float(pixel_rh);
-            pixel_r -= shared_temp[threadBase + j].pixel_hr;
-            error += dot(pixel_r, pixel_r);
-        }
-        if (bBadQuantize)
-            error = 1e20f;
-
-        shared_temp[GI].error = error;
-        shared_temp[GI].best_mode = candidateModeFlag[g_mode_id];
-        shared_temp[GI].best_partition = threadInBlock;
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 16)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 16].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 16].error;
-            shared_temp[GI].best_mode = shared_temp[GI + 16].best_mode;
-            shared_temp[GI].best_partition = shared_temp[GI + 16].best_partition;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 8)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 8].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 8].error;
-            shared_temp[GI].best_mode = shared_temp[GI + 8].best_mode;
-            shared_temp[GI].best_partition = shared_temp[GI + 8].best_partition;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 4)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 4].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 4].error;
-            shared_temp[GI].best_mode = shared_temp[GI + 4].best_mode;
-            shared_temp[GI].best_partition = shared_temp[GI + 4].best_partition;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 2)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 2].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 2].error;
-            shared_temp[GI].best_mode = shared_temp[GI + 2].best_mode;
-            shared_temp[GI].best_partition = shared_temp[GI + 2].best_partition;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 1)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 1].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 1].error;
-            shared_temp[GI].best_mode = shared_temp[GI + 1].best_mode;
-            shared_temp[GI].best_partition = shared_temp[GI + 1].best_partition;
-        }
-
-        if (asfloat(g_InBuff[blockID].x) > shared_temp[GI].error)
-        {
-            g_OutBuff[blockID] = uint4(asuint(shared_temp[GI].error), shared_temp[GI].best_mode, shared_temp[GI].best_partition, 0);
-        }
-        else
-        {
-            g_OutBuff[blockID] = g_InBuff[blockID];
-        }
-    }
-}
-
-[numthreads(THREAD_GROUP_SIZE, 1, 1)]
-void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
-{
-    const uint MAX_USED_THREAD = 32;
-    uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
-    uint blockInGroup = GI / MAX_USED_THREAD;
-    uint blockID = g_start_block_id + groupID.x * BLOCK_IN_GROUP + blockInGroup;
-    uint threadBase = blockInGroup * MAX_USED_THREAD;
-    uint threadInBlock = GI - threadBase;
-
-#ifndef REF_DEVICE
-    if (blockID >= g_num_total_blocks)
-    {
-        return;
-    }
-#endif
-
-    uint block_y = blockID / g_num_block_x;
-    uint block_x = blockID - block_y * g_num_block_x;
-    uint base_x = block_x * BLOCK_SIZE_X;
-    uint base_y = block_y * BLOCK_SIZE_Y;
-
-    if (threadInBlock < 16)
-    {
-        shared_temp[GI].pixel = g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)).rgb;
-        shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel, RGB2LUM);
-        uint3 pixel_h = float2half(shared_temp[GI].pixel);
-        shared_temp[GI].pixel_ph = start_quantize(pixel_h);
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    uint best_mode = g_InBuff[blockID].y;
-    uint best_partition = g_InBuff[blockID].z;
-
-    uint4 block = 0;
-
-    if (threadInBlock < 32)
-    {
-        int2x3 endPoint;
-        endPoint[0] = MAX_INT;
-        endPoint[1] = MIN_INT;
-
-        float2 endPoint_lum;
-        endPoint_lum[0] = MAX_FLOAT;
-        endPoint_lum[1] = MIN_FLOAT;
-
-        int2 endPoint_lum_index;
-        endPoint_lum_index[0] = -1;
-        endPoint_lum_index[1] = -1;
-
-        int3 pixel_ph = shared_temp[threadBase + (threadInBlock & 0xF)].pixel_ph;
-        float pixel_lum = shared_temp[threadBase + (threadInBlock & 0xF)].pixel_lum;
-        if (threadInBlock < 16)
-        {
-            if (best_mode > 10)
-            {
-                endPoint[0] = endPoint[1] = pixel_ph;
-                endPoint_lum[0] = endPoint_lum[1] = pixel_lum;
-            }
-            else
-            {
-                uint bits = candidateSectionBit[best_partition];
-                if (0 == ((bits >> threadInBlock) & 1))
-                {
-                    endPoint[0] = endPoint[1] = pixel_ph;
-                    endPoint_lum[0] = endPoint_lum[1] = pixel_lum;
-                }
-            }
-        }
-        else
-        {
-            if (best_mode <= 10)
-            {
-                uint bits = candidateSectionBit[best_partition];
-                if (1 == ((bits >> (threadInBlock & 0xF)) & 1))
-                {
-                    endPoint[0] = endPoint[1] = pixel_ph;
-                    endPoint_lum[0] = endPoint_lum[1] = pixel_lum;
-                }
-            }
-        }
-
-        shared_temp[GI].endPoint_low = endPoint[0];
-        shared_temp[GI].endPoint_high = endPoint[1];
-
-        shared_temp[GI].endPoint_lum_low = endPoint_lum[0];
-        shared_temp[GI].endPoint_lum_high = endPoint_lum[1];
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if ((threadInBlock & 0xF) < 8)
-    {
-        if (shared_temp[GI].endPoint_lum_low > shared_temp[GI + 8].endPoint_lum_low)
-        {
-            shared_temp[GI].endPoint_low = shared_temp[GI + 8].endPoint_low;
-            shared_temp[GI].endPoint_lum_low = shared_temp[GI + 8].endPoint_lum_low;
-        }
-        if (shared_temp[GI].endPoint_lum_high < shared_temp[GI + 8].endPoint_lum_high)
-        {
-            shared_temp[GI].endPoint_high = shared_temp[GI + 8].endPoint_high;
-            shared_temp[GI].endPoint_lum_high = shared_temp[GI + 8].endPoint_lum_high;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if ((threadInBlock & 0xF) < 4)
-    {
-        if (shared_temp[GI].endPoint_lum_low > shared_temp[GI + 4].endPoint_lum_low)
-        {
-            shared_temp[GI].endPoint_low = shared_temp[GI + 4].endPoint_low;
-            shared_temp[GI].endPoint_lum_low = shared_temp[GI + 4].endPoint_lum_low;
-        }
-        if (shared_temp[GI].endPoint_lum_high < shared_temp[GI + 4].endPoint_lum_high)
-        {
-            shared_temp[GI].endPoint_high = shared_temp[GI + 4].endPoint_high;
-            shared_temp[GI].endPoint_lum_high = shared_temp[GI + 4].endPoint_lum_high;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if ((threadInBlock & 0xF) < 2)
-    {
-        if (shared_temp[GI].endPoint_lum_low > shared_temp[GI + 2].endPoint_lum_low)
-        {
-            shared_temp[GI].endPoint_low = shared_temp[GI + 2].endPoint_low;
-            shared_temp[GI].endPoint_lum_low = shared_temp[GI + 2].endPoint_lum_low;
-        }
-        if (shared_temp[GI].endPoint_lum_high < shared_temp[GI + 2].endPoint_lum_high)
-        {
-            shared_temp[GI].endPoint_high = shared_temp[GI + 2].endPoint_high;
-            shared_temp[GI].endPoint_lum_high = shared_temp[GI + 2].endPoint_lum_high;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if ((threadInBlock & 0xF) < 1)
-    {
-        if (shared_temp[GI].endPoint_lum_low > shared_temp[GI + 1].endPoint_lum_low)
-        {
-            shared_temp[GI].endPoint_low = shared_temp[GI + 1].endPoint_low;
-            shared_temp[GI].endPoint_lum_low = shared_temp[GI + 1].endPoint_lum_low;
-        }
-        if (shared_temp[GI].endPoint_lum_high < shared_temp[GI + 1].endPoint_lum_high)
-        {
-            shared_temp[GI].endPoint_high = shared_temp[GI + 1].endPoint_high;
-            shared_temp[GI].endPoint_lum_high = shared_temp[GI + 1].endPoint_lum_high;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 2)
-    {
-        // find_axis
-        int2x3 endPoint;
-        endPoint[0] = shared_temp[threadBase + threadInBlock * 16].endPoint_low;
-        endPoint[1] = shared_temp[threadBase + threadInBlock * 16].endPoint_high;
-
-        uint fixup = 0;
-        if ((1 == threadInBlock) && (best_mode <= 10))
-        {
-            fixup = candidateFixUpIndex1D[best_partition];
-        }
-
-        float3 span = endPoint[1] - endPoint[0];
-        float span_norm_sqr = dot(span, span);
-        float dotProduct = dot(span, shared_temp[threadBase + fixup].pixel_ph - endPoint[0]);
-        if (span_norm_sqr > 0 && dotProduct >= 0 && uint(dotProduct * 63.49999 / span_norm_sqr) > 32)
-        {
-            swap(endPoint[0], endPoint[1]);
-        }
-
-        shared_temp[GI].endPoint_low = endPoint[0];
-        shared_temp[GI].endPoint_high = endPoint[1];
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 16)
-    {
-        uint bits;
-        if (best_mode > 10)
-        {
-            bits = 0;
-        }
-        else
-        {
-            bits = candidateSectionBit[best_partition];
-        }
-
-        float3 span;
-        float dotProduct;
-        if ((bits >> threadInBlock) & 1)
-        {
-            span = shared_temp[threadBase + 1].endPoint_high - shared_temp[threadBase + 1].endPoint_low;
-            dotProduct = dot(span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 1].endPoint_low);
-        }
-        else
-        {
-            span = shared_temp[threadBase + 0].endPoint_high - shared_temp[threadBase + 0].endPoint_low;
-            dotProduct = dot(span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 0].endPoint_low);
-        }
-        float span_norm_sqr = dot(span, span);
-
-        if (best_mode > 10)
-        {
-            uint index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
-                : ((dotProduct < span_norm_sqr) ? aStep2[uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep2[63]);
-            if (threadInBlock == 0)
-            {
-                block.z |= index << 1;
-            }
-            else if (threadInBlock < 8)
-            {
-                block.z |= index << (threadInBlock * 4);
-            }
-            else
-            {
-                block.w |= index << ((threadInBlock - 8) * 4);
-            }
-        }
-        else
-        {
-            uint index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
-                : ((dotProduct < span_norm_sqr) ? aStep1[uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep1[63]);
-
-            uint fixup = candidateFixUpIndex1D[best_partition];
-            int2 offset = int2((fixup != 2), (fixup == 15));
-
-            if (threadInBlock == 0)
-            {
-                block.z |= index << 18;
-            }
-            else if (threadInBlock < 3)
-            {
-                block.z |= index << (20 + (threadInBlock - 1) * 3);
-            }
-            else if (threadInBlock < 5)
-            {
-                block.z |= index << (25 + (threadInBlock - 3) * 3 + offset.x);
-            }
-            else if (threadInBlock == 5)
-            {
-                block.w |= index >> !offset.x;
-                if (!offset.x)
-                {
-                    block.z |= index << 31;
-                }
-            }
-            else if (threadInBlock < 9)
-            {
-                block.w |= index << (2 + (threadInBlock - 6) * 3 + offset.x);
-            }
-            else
-            {
-                block.w |= index << (11 + (threadInBlock - 9) * 3 + offset.y);
-            }
-        }
-
-        shared_temp[GI].pixel_hr.xy = asfloat(block.zw);
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 8)
-    {
-        shared_temp[GI].pixel_hr.xy = asfloat(asuint(shared_temp[GI].pixel_hr.xy) | asuint(shared_temp[GI + 8].pixel_hr.xy));
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 4)
-    {
-        shared_temp[GI].pixel_hr.xy = asfloat(asuint(shared_temp[GI].pixel_hr.xy) | asuint(shared_temp[GI + 4].pixel_hr.xy));
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 2)
-    {
-        shared_temp[GI].pixel_hr.xy = asfloat(asuint(shared_temp[GI].pixel_hr.xy) | asuint(shared_temp[GI + 2].pixel_hr.xy));
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 1)
-    {
-        shared_temp[GI].pixel_hr.xy = asfloat(asuint(shared_temp[GI].pixel_hr.xy) | asuint(shared_temp[GI + 1].pixel_hr.xy));
-
-        block.zw = asuint(shared_temp[GI].pixel_hr.xy);
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    bool transformed = candidateModeTransformed[best_mode - 1];
-    uint4 prec = candidateModePrec[best_mode - 1];
-    if (threadInBlock == 2)
-    {
-        int2x3 endPoint_q;
-        endPoint_q[0] = shared_temp[threadBase + 0].endPoint_low;
-        endPoint_q[1] = shared_temp[threadBase + 0].endPoint_high;
-
-        quantize(endPoint_q, prec.x);
-        if (transformed)
-        {
-            endPoint_q[1] -= endPoint_q[0];
-        }
-
-        shared_temp[GI].endPoint_low = endPoint_q[0];
-        shared_temp[GI].endPoint_high = endPoint_q[1];
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock == 3)
-    {
-        int3 ep0 = shared_temp[threadBase + 2].endPoint_low;
-        int2x3 endPoint_q;
-        endPoint_q[0] = shared_temp[threadBase + 1].endPoint_low;
-        endPoint_q[1] = shared_temp[threadBase + 1].endPoint_high;
-
-        if (best_mode <= 10)
-        {
-            quantize(endPoint_q, prec.x);
-            if (transformed)
-            {
-                endPoint_q[0] -= ep0;
-                endPoint_q[1] -= ep0;
-            }
-
-            shared_temp[GI].endPoint_low = endPoint_q[0];
-            shared_temp[GI].endPoint_high = endPoint_q[1];
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 2)
-    {
-        int2x3 endPoint_q;
-        endPoint_q[0] = shared_temp[threadBase + threadInBlock + 2].endPoint_low;
-        endPoint_q[1] = shared_temp[threadBase + threadInBlock + 2].endPoint_high;
-
-        int bBadQuantize = 0;
-        if (threadInBlock == 0)
-        {
-            if (best_mode > 10)
-            {
-                finish_quantize(bBadQuantize, endPoint_q, prec, transformed);
-            }
-            else
-            {
-                finish_quantize_0(bBadQuantize, endPoint_q, prec, transformed);
-            }
-        }
-        else // if (threadInBlock == 1)
-        {
-            if (best_mode <= 10)
-            {
-                finish_quantize_1(bBadQuantize, endPoint_q, prec, transformed);
-            }
-        }
-
-        shared_temp[GI].endPoint_low = endPoint_q[0];
-        shared_temp[GI].endPoint_high = endPoint_q[1];
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock == 0)
-    {
-        int2x3 endPoint_q[2];
-        endPoint_q[0][0] = shared_temp[threadBase + 0].endPoint_low;
-        endPoint_q[0][1] = shared_temp[threadBase + 0].endPoint_high;
-        endPoint_q[1][0] = shared_temp[threadBase + 1].endPoint_low;
-        endPoint_q[1][1] = shared_temp[threadBase + 1].endPoint_high;
-
-        if (best_mode > 10)
-        {
-            block_package(block, endPoint_q[0], best_mode);
-        }
-        else
-        {
-            block_package(block, endPoint_q, best_mode, best_partition);
-        }
-
-        g_OutBuff[blockID] = block;
-    }
-}
-
-uint float2half1(float f)
-{
-    uint Result;
-
-    uint IValue = asuint(f);
-    uint Sign = (IValue & 0x80000000U) >> 16U;
-    IValue = IValue & 0x7FFFFFFFU;
-
-    if (IValue > 0x47FFEFFFU)
-    {
-        // The number is too large to be represented as a half.  Saturate to infinity.
-        Result = 0x7FFFU;
-    }
-    else
-    {
-        if (IValue < 0x38800000U)
-        {
-            // The number is too small to be represented as a normalized half.
-            // Convert it to a denormalized value.
-            uint Shift = 113U - (IValue >> 23U);
-            IValue = (0x800000U | (IValue & 0x7FFFFFU)) >> Shift;
-        }
-        else
-        {
-            // Rebias the exponent to represent the value as a normalized half.
-            IValue += 0xC8000000U;
-        }
-
-        Result = ((IValue + 0x0FFFU + ((IValue >> 13U) & 1U)) >> 13U)&0x7FFFU;
-    }
-    return (Result|Sign);
-}
-
-uint3 float2half(float3 endPoint_f)
-{
-    //uint3 sign = asuint(endPoint_f) & 0x80000000;
-    //uint3 expo = asuint(endPoint_f) & 0x7F800000;
-    //uint3 base = asuint(endPoint_f) & 0x007FFFFF;
-    //return ( expo < 0x33800000 ) ? 0 
-    //                    //0x33800000 indicating 2^-24, which is minimal denormalized number that half can present 
-    //    : ( ( expo < 0x38800000 ) ? ( sign >> 16 ) | ( ( base + 0x00800000 ) >> ( 23 - ( ( expo - 0x33800000 ) >> 23 ) ) )//fixed a bug in v0.2
-    //                    //0x38800000 indicating 2^-14, which is minimal normalized number that half can present, so need to use denormalized half presentation
-    //    : ( ( expo == 0x7F800000 || expo > 0x47000000 ) ? ( ( sign >> 16 ) | 0x7bff )
-    //                    // treat NaN as INF, treat INF (including NaN) as the maximum/minimum number that half can present
-    //                    // 0x47000000 indicating 2^15, which is maximum exponent that half can present, so cut to 0x7bff which is the maximum half number
-    //    : ( ( sign >> 16 ) | ( ( ( expo - 0x38000000 ) | base ) >> 13 ) ) ) );
-
-
-    return uint3(float2half1(endPoint_f.x), float2half1(endPoint_f.y), float2half1(endPoint_f.z));
-}
-int3 start_quantize(uint3 pixel_h)
-{
-    if (g_format == UNSIGNED_F16)
-    {
-        return asint((pixel_h << 6) / 31);
-    }
-    else
-    {
-        return (pixel_h < 0x8000) ? ((pixel_h == 0x7bff) ? 0x7fff : asint((pixel_h << 5) / 31))// fixed a bug in v0.2
-            : ((pixel_h == 0x7bff) ? 0xffff8001 : -asint(((0x00007fff & pixel_h) << 5) / 31));// fixed a bug in v0.2
-    }
-}
-void quantize(inout int2x3 endPoint, uint prec)
-{
-    int iprec = asint(prec);
-    if (g_format == UNSIGNED_F16)
-    {
-        endPoint = ((iprec >= 15) | (endPoint == 0)) ? endPoint
-            : ((endPoint == asint(0xFFFF)) ? ((1 << iprec) - 1)
-                : (((endPoint << iprec) + asint(0x0000)) >> 16));
-    }
-    else
-    {
-        endPoint = ((iprec >= 16) | (endPoint == 0)) ? endPoint
-            : ((endPoint >= 0) ? ((endPoint == asint(0x7FFF)) ? ((1 << (iprec - 1)) - 1) : (((endPoint << (iprec - 1)) + asint(0x0000)) >> 15))
-                : ((-endPoint == asint(0x7FFF)) ? -((1 << (iprec - 1)) - 1) : -(((-endPoint << (iprec - 1)) + asint(0x0000)) >> 15)));
-    }
-}
-void finish_quantize_0(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed)
-{
-    if (transformed)
-    {
-        bool3 bBadComponent = (endPoint[1] >= 0) ? (endPoint[1] >= (1 << (prec.yzw - 1)))
-            : (-endPoint[1] > (1 << (prec.yzw - 1)));
-        bBadQuantize |= any(bBadComponent);
-
-        endPoint[0] = endPoint[0] & ((1 << prec.x) - 1);
-        endPoint[1] = (endPoint[1] >= 0) ? ((endPoint[1] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[1])
-            : ((-endPoint[1] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[1] & ((1 << prec.yzw) - 1)));
-    }
-    else
-    {
-        endPoint &= ((1 << prec.x) - 1);
-    }
-}
-void finish_quantize_1(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed)
-{
-    if (transformed)
-    {
-        bool2x3 bBadComponent;
-        bBadComponent[0] = (endPoint[0] >= 0) ? (endPoint[0] >= (1 << (prec.yzw - 1)))
-            : (-endPoint[0] > (1 << (prec.yzw - 1)));
-        bBadComponent[1] = (endPoint[1] >= 0) ? (endPoint[1] >= (1 << (prec.yzw - 1)))
-            : (-endPoint[1] > (1 << (prec.yzw - 1)));
-        bBadQuantize |= any(bBadComponent);
-
-        endPoint[0] = (endPoint[0] >= 0) ? ((endPoint[0] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[0])
-            : ((-endPoint[0] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[0] & ((1 << prec.yzw) - 1)));
-        endPoint[1] = (endPoint[1] >= 0) ? ((endPoint[1] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[1])
-            : ((-endPoint[1] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[1] & ((1 << prec.yzw) - 1)));
-    }
-    else
-    {
-        endPoint &= ((1 << prec.x) - 1);
-    }
-}
-void finish_quantize(out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed)
-{
-    if (transformed)
-    {
-        bool3 bBadComponent;
-        bBadComponent = (endPoint[1] >= 0) ? (endPoint[1] >= (1 << (prec.yzw - 1)))
-            : (-endPoint[1] > (1 << (prec.yzw - 1)));
-        bBadQuantize = any(bBadComponent);
-
-        endPoint[0] = endPoint[0] & ((1 << prec.x) - 1);
-        endPoint[1] = (endPoint[1] >= 0) ? ((endPoint[1] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[1])
-            : ((-endPoint[1] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[1] & ((1 << prec.yzw) - 1)));
-    }
-    else
-    {
-        endPoint &= ((1 << prec.x) - 1);
-
-        bBadQuantize = 0;
-    }
-}
-
-void SIGN_EXTEND(uint3 prec, inout int3 color)
-{
-    uint3 p = 1 << (prec - 1);
-    color = (color & p) ? (color & (p - 1)) - p : color;
-}
-
-void sign_extend(bool transformed, uint4 prec, inout int2x3 endPoint)
-{
-    if (g_format == SIGNED_F16)
-        SIGN_EXTEND(prec.x, endPoint[0]);
-    if (g_format == SIGNED_F16 || transformed)
-        SIGN_EXTEND(prec.yzw, endPoint[1]);
-}
-
-void sign_extend(bool transformed, uint4 prec, inout int2x3 endPoint[2])
-{
-    if (g_format == SIGNED_F16)
-        SIGN_EXTEND(prec.x, endPoint[0][0]);
-    if (g_format == SIGNED_F16 || transformed)
-    {
-        SIGN_EXTEND(prec.yzw, endPoint[0][1]);
-        SIGN_EXTEND(prec.yzw, endPoint[1][0]);
-        SIGN_EXTEND(prec.yzw, endPoint[1][1]);
-    }
-}
-void start_unquantize(inout int2x3 endPoint[2], uint4 prec, bool transformed)
-{
-    sign_extend(transformed, prec, endPoint);
-    if (transformed)
-    {
-        endPoint[0][1] += endPoint[0][0];
-        endPoint[1][0] += endPoint[0][0];
-        endPoint[1][1] += endPoint[0][0];
-    }
-}
-void start_unquantize(inout int2x3 endPoint, uint4 prec, bool transformed)
-{
-    sign_extend(transformed, prec, endPoint);
-    if (transformed)
-        endPoint[1] += endPoint[0];
-}
-void unquantize(inout int2x3 color, uint prec)
-{
-    int iprec = asint(prec);
-    if (g_format == UNSIGNED_F16)
-    {
-        if (prec < 15)
-        {
-            color = (color != 0) ? (color == ((1 << iprec) - 1) ? 0xFFFF : (((color << 16) + 0x8000) >> iprec)) : color;
-        }
-    }
-    else
-    {
-        if (prec < 16)
-        {
-            uint2x3 s = color >= 0 ? 0 : 1;
-            color = abs(color);
-            color = (color != 0) ? (color >= ((1 << (iprec - 1)) - 1) ? 0x7FFF : (((color << 15) + 0x4000) >> (iprec - 1))) : color;
-            color = s > 0 ? -color : color;
-        }
-    }
-}
-uint3 finish_unquantize(int3 color)
-{
-    if (g_format == UNSIGNED_F16)
-        color = (color * 31) >> 6;
-    else
-    {
-        color = (color < 0) ? -((-color * 31) >> 5) : (color * 31) >> 5;
-        color = (color < 0) ? ((-color) | 0x8000) : color;
-    }
-    return asuint(color);
-}
-void generate_palette_unquantized8(out uint3 palette, int3 low, int3 high, int i)
-{
-    static const int aWeight3[] = { 0, 9, 18, 27, 37, 46, 55, 64 };
-
-    int3 tmp = (low * (64 - aWeight3[i]) + high * aWeight3[i] + 32) >> 6;
-    palette = finish_unquantize(tmp);
-}
-void generate_palette_unquantized16(out uint3 palette, int3 low, int3 high, int i)
-{
-    static const int aWeight4[] = { 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64 };
-
-    int3 tmp = (low * (64 - aWeight4[i]) + high * aWeight4[i] + 32) >> 6;
-    palette = finish_unquantize(tmp);
-}
-
-float half2float1(uint Value)
-{
-    uint Mantissa = (uint)(Value & 0x03FF);
-
-    uint Exponent;
-    if ((Value & 0x7C00) != 0)  // The value is normalized
-    {
-        Exponent = (uint)((Value >> 10) & 0x1F);
-    }
-    else if (Mantissa != 0)     // The value is denormalized
-    {
-        // Normalize the value in the resulting float
-        Exponent = 1;
-
-        do
-        {
-            Exponent--;
-            Mantissa <<= 1;
-        } while ((Mantissa & 0x0400) == 0);
-
-        Mantissa &= 0x03FF;
-    }
-    else                        // The value is zero
-    {
-        Exponent = (uint)(-112);
-    }
-
-    uint Result = ((Value & 0x8000) << 16) | // Sign
-        ((Exponent + 112) << 23) | // Exponent
-        (Mantissa << 13);          // Mantissa
-
-    return asfloat(Result);
-}
-
-float3 half2float(uint3 color_h)
-{
-    //uint3 sign = color_h & 0x8000;
-    //uint3 expo = color_h & 0x7C00;
-    //uint3 base = color_h & 0x03FF;
-    //return ( expo == 0 ) ? asfloat( ( sign << 16 ) | asuint( float3(base) / 16777216 ) ) //16777216 = 2^24
-    //    : asfloat( ( sign << 16 ) | ( ( ( expo + 0x1C000 ) | base ) << 13 ) ); //0x1C000 = 0x1FC00 - 0x3C00
-
-    return float3(half2float1(color_h.x), half2float1(color_h.y), half2float1(color_h.z));
-}
-
-void block_package(inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index) // for mode 1 - 10
-{
-    block.xy = 0;
-    block.z &= 0xFFFC0000;
-
-    //block.z |= (partition_index & 0x1f) << 13;
-
-    if (mode_type == candidateModeFlag[0])
-    {
-        /*block.x = candidateModeMemory[0];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
-        block.x |= ( endPoint[1][0].g >> 2 ) & 0x00000004;
-        block.x |= ( endPoint[1][0].b >> 1 ) & 0x00000008;
-        block.x |= endPoint[1][1].b & 0x00000010;
-        block.y |= ( ( endPoint[0][0].b >> 7 ) & 0x00000007 );
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x000000F8 ) | ( ( endPoint[0][1].g << 13 ) & 0x0003E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x0F800000 );
-        block.yz |= ( endPoint[1][0].gr << uint2(9, 1) ) & uint2(0x00001E00, 0x0000003E);
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.y |= ( ( endPoint[1][1].g << 4 ) & 0x00000100 );
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00000F80);
-        block.yz |= ( ( endPoint[1][1].b << uint2(27, 9) ) & uint2(0x10000000, 0x00001000) ) | ( ( endPoint[1][1].b << uint2(18, 4) ) & uint2(0x00040000, 0x00000040) );
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;*/
-
-        block.x |= ((candidateModeMemory[0] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[0] >> 1) & 1) << 1;
-        block.x |= ((endPoint[1][0].g >> 4) & 1) << 2;
-        block.x |= ((endPoint[1][0].b >> 4) & 1) << 3;
-        block.x |= ((endPoint[1][1].b >> 4) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0][0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0][0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[0][0].r >> 8) & 1) << 13;
-        block.x |= ((endPoint[0][0].r >> 9) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0][0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0][0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[0][0].g >> 8) & 1) << 23;
-        block.x |= ((endPoint[0][0].g >> 9) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0][0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0][0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[0][0].b >> 8) & 1) << 1;
-        block.y |= ((endPoint[0][0].b >> 9) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[1][1].g >> 4) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[1][1].b >> 0) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[1][1].b >> 1) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][0].r >> 4) & 1) << 5;
-        block.z |= ((endPoint[1][1].b >> 2) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][1].r >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].b >> 3) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-    else if (mode_type == candidateModeFlag[1])
-    {
-        /*block.x = candidateModeMemory[1];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00000FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x003F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x000001F8 ) | ( ( endPoint[0][1].g << 13 ) & 0x0007E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x1F800000 );
-        block.x |= ( ( endPoint[1][0].g >> 3 ) & 0x00000004 ) | ( ( endPoint[1][0].g << 20 ) & 0x01000000 );
-        block.x |= ( endPoint[1][1].g >> 1 ) & 0x00000018;
-        block.x |= ( ( endPoint[1][1].b << 21 ) & 0x00800000 ) | ( ( endPoint[1][1].b << 12 ) & 0x00003000 );
-        block.x |= ( ( endPoint[1][0].b << 17 ) & 0x00400000 ) | ( ( endPoint[1][0].b << 10 ) & 0x00004000 );
-        block.yz |= ( endPoint[1][0].gr << uint2(9, 1) ) & uint2(0x00001E00, 0x0000007E);
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00001F80);
-        block.y |= ( ( endPoint[1][1].b >> 4 ) & 0x00000002 ) | ( ( endPoint[1][1].b >> 2 ) & 0x00000004 ) | ( ( endPoint[1][1].b >> 3 ) & 0x00000001 );
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;*/
-
-        block.x |= ((candidateModeMemory[1] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[1] >> 1) & 1) << 1;
-        block.x |= ((endPoint[1][0].g >> 5) & 1) << 2;
-        block.x |= ((endPoint[1][1].g >> 4) & 1) << 3;
-        block.x |= ((endPoint[1][1].g >> 5) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0][0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[1][1].b >> 0) & 1) << 12;
-        block.x |= ((endPoint[1][1].b >> 1) & 1) << 13;
-        block.x |= ((endPoint[1][0].b >> 4) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0][0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[1][0].b >> 5) & 1) << 22;
-        block.x |= ((endPoint[1][1].b >> 2) & 1) << 23;
-        block.x |= ((endPoint[1][0].g >> 4) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0][0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[1][1].b >> 3) & 1) << 0;
-        block.y |= ((endPoint[1][1].b >> 5) & 1) << 1;
-        block.y |= ((endPoint[1][1].b >> 4) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[0][1].r >> 5) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[0][1].g >> 5) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[0][1].b >> 5) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][0].r >> 4) & 1) << 5;
-        block.z |= ((endPoint[1][0].r >> 5) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][1].r >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].r >> 5) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-    else if (mode_type == candidateModeFlag[2])
-    {
-        /*block.x = candidateModeMemory[2];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
-        block.y |= ( endPoint[0][0].r >> 2 ) & 0x00000100;
-        block.y |= ( endPoint[0][0].g << 7 ) & 0x00020000;
-        block.y |= ( ( endPoint[0][0].b << 17 ) & 0x08000000 ) | ( ( endPoint[0][0].b >> 7 ) & 0x00000007 );
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x000000F8 ) | ( ( endPoint[0][1].g << 13 ) & 0x0001E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x07800000 );
-        block.yz |= ( endPoint[1][0].gr << uint2(9, 1) ) & uint2(0x00001E00, 0x0000003E);
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00000F80);
-        block.yz |= ( ( endPoint[1][1].b << uint2(27, 9) ) & uint2(0x10000000, 0x00001000) ) | ( ( endPoint[1][1].b << uint2(18, 4) ) & uint2(0x00040000, 0x00000040) );
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;*/
-
-        block.x |= ((candidateModeMemory[2] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[2] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[2] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[2] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[2] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0][0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0][0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[0][0].r >> 8) & 1) << 13;
-        block.x |= ((endPoint[0][0].r >> 9) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0][0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0][0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[0][0].g >> 8) & 1) << 23;
-        block.x |= ((endPoint[0][0].g >> 9) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0][0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0][0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[0][0].b >> 8) & 1) << 1;
-        block.y |= ((endPoint[0][0].b >> 9) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[0][0].r >> 10) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][0].g >> 10) & 1) << 17;
-        block.y |= ((endPoint[1][1].b >> 0) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][0].b >> 10) & 1) << 27;
-        block.y |= ((endPoint[1][1].b >> 1) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][0].r >> 4) & 1) << 5;
-        block.z |= ((endPoint[1][1].b >> 2) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][1].r >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].b >> 3) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-    else if (mode_type == candidateModeFlag[3])
-    {
-        /*block.x = candidateModeMemory[3];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
-        block.y |= ( endPoint[0][0].r >> 3 ) & 0x00000080;
-        block.y |= ( endPoint[0][0].g << 8 ) & 0x00040000;
-        block.y |= ( ( endPoint[0][0].b << 17 ) & 0x08000000 ) | ( ( endPoint[0][0].b >> 7 ) & 0x00000007 );
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x00000078 ) | ( ( endPoint[0][1].g << 13 ) & 0x0003E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x07800000 );
-        block.yz |= ( endPoint[1][0].gr << uint2(9, 1) ) & uint2(0x00001E00, 0x0000001E);
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.y |= ( ( endPoint[1][1].g << 4 ) & 0x00000100 );
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00000780);
-        block.yz |= ( endPoint[1][1].b << uint2(27, 9) ) & uint2(0x10000000, 0x00001000);
-        block.z |= ( ( endPoint[1][0].g << 7 ) & 0x00000800 );
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;
-        block.z |= ( endPoint[1][1].b << 4 ) & 0x00000040;
-        block.z |= ( endPoint[1][1].b << 5 ) & 0x00000020;*/
-
-        block.x |= ((candidateModeMemory[3] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[3] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[3] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[3] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[3] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0][0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0][0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[0][0].r >> 8) & 1) << 13;
-        block.x |= ((endPoint[0][0].r >> 9) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0][0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0][0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[0][0].g >> 8) & 1) << 23;
-        block.x |= ((endPoint[0][0].g >> 9) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0][0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0][0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[0][0].b >> 8) & 1) << 1;
-        block.y |= ((endPoint[0][0].b >> 9) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][0].r >> 10) & 1) << 7;
-        block.y |= ((endPoint[1][1].g >> 4) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[0][0].g >> 10) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][0].b >> 10) & 1) << 27;
-        block.y |= ((endPoint[1][1].b >> 1) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][1].b >> 0) & 1) << 5;
-        block.z |= ((endPoint[1][1].b >> 2) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][0].g >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].b >> 3) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-    else if (mode_type == candidateModeFlag[4])
-    {
-        /*block.x = candidateModeMemory[4];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
-        block.y |= ( endPoint[0][0].r >> 3 ) & 0x00000080;
-        block.y |= ( endPoint[0][0].g << 7 ) & 0x00020000;
-        block.y |= ( ( endPoint[0][0].b << 18 ) & 0x10000000 ) | ( ( endPoint[0][0].b >> 7 ) & 0x00000007 );
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x00000078 ) | ( ( endPoint[0][1].g << 13 ) & 0x0001E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x0F800000 );
-        block.y |= ( ( endPoint[1][0].g << 9 ) & 0x00001E00 ) | ( ( endPoint[1][0].b << 4 ) & 0x00000100 );
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00000780);
-        block.yz |= ( endPoint[1][1].b << uint2(18, 4) ) & uint2(0x00040000, 0x00000060);
-        block.z |= ( endPoint[1][0].r << 1 ) & 0x0000001E;
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;
-        block.z |= ( ( endPoint[1][1].b << 7 ) & 0x00000800 ) | ( ( endPoint[1][1].b << 9 ) & 0x00001000 );*/
-
-        block.x |= ((candidateModeMemory[4] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[4] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[4] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[4] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[4] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0][0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0][0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[0][0].r >> 8) & 1) << 13;
-        block.x |= ((endPoint[0][0].r >> 9) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0][0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0][0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[0][0].g >> 8) & 1) << 23;
-        block.x |= ((endPoint[0][0].g >> 9) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0][0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0][0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[0][0].b >> 8) & 1) << 1;
-        block.y |= ((endPoint[0][0].b >> 9) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][0].r >> 10) & 1) << 7;
-        block.y |= ((endPoint[1][0].b >> 4) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][0].g >> 10) & 1) << 17;
-        block.y |= ((endPoint[1][1].b >> 0) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[0][0].b >> 10) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][1].b >> 1) & 1) << 5;
-        block.z |= ((endPoint[1][1].b >> 2) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][1].b >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].b >> 3) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-    else if (mode_type == candidateModeFlag[5])
-    {
-        /*block.x = candidateModeMemory[5];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00003FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x00FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000);
-        block.y |= ( endPoint[0][0].b >> 7 ) & 0x00000003;
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x000000F8 ) | ( ( endPoint[0][1].g << 13 ) & 0x0003E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x0F800000 );
-        block.x |= ( ( endPoint[1][0].g << 20 ) & 0x01000000 ) | ( ( endPoint[1][0].b << 10 ) & 0x00004000 );
-        block.yz |= ( endPoint[1][0].gr << uint2(9, 1) ) & uint2(0x00001E00, 0x0000003E);
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.y |= ( ( endPoint[1][1].g << 4 ) & 0x00000100 ) | ( ( endPoint[1][1].b >> 2 ) & 0x00000004 );
-        block.y |= ( ( endPoint[1][1].b << 27 ) & 0x10000000 );
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00000F80);
-        block.yz |= ( endPoint[1][1].b << uint2(18, 4) ) & uint2(0x00040000, 0x00000040);
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;
-        block.z |= ( ( endPoint[1][1].b << 9 ) & 0x00001000 );*/
-
-        block.x |= ((candidateModeMemory[5] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[5] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[5] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[5] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[5] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0][0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0][0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[0][0].r >> 8) & 1) << 13;
-        block.x |= ((endPoint[1][0].b >> 4) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0][0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0][0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[0][0].g >> 8) & 1) << 23;
-        block.x |= ((endPoint[1][0].g >> 4) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0][0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0][0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[0][0].b >> 8) & 1) << 1;
-        block.y |= ((endPoint[1][1].b >> 4) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[1][1].g >> 4) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[1][1].b >> 0) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[1][1].b >> 1) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][0].r >> 4) & 1) << 5;
-        block.z |= ((endPoint[1][1].b >> 2) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][1].r >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].b >> 3) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-    else if (mode_type == candidateModeFlag[6])
-    {
-        /*block.x = candidateModeMemory[6];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
-        block.y |= ( endPoint[0][0].b >> 7 ) & 0x00000001;
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x000001F8 ) | ( ( endPoint[0][1].g << 13 ) & 0x0003E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x0F800000 );
-        block.x |= ( ( endPoint[1][0].g << 20 ) & 0x01000000 ) | ( ( endPoint[1][0].b << 10 ) & 0x00004000);
-        block.x |= ( ( endPoint[1][1].g << 9 ) & 0x00002000 ) | ( ( endPoint[1][1].b << 21 ) & 0x00800000);
-        block.yz |= ( endPoint[1][0].gr << uint2(9, 1) ) & uint2(0x00001E00, 0x0000007E);
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00001F80);
-        block.y |= ( ( endPoint[1][1].b >> 2 ) & 0x00000006 );
-        block.y |= ( ( endPoint[1][1].b << 27 ) & 0x10000000 ) | ( ( endPoint[1][1].b << 18 ) & 0x00040000 );
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;*/
-
-        block.x |= ((candidateModeMemory[6] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[6] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[6] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[6] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[6] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0][0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0][0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[1][1].g >> 4) & 1) << 13;
-        block.x |= ((endPoint[1][0].b >> 4) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0][0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0][0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[1][1].b >> 2) & 1) << 23;
-        block.x |= ((endPoint[1][0].g >> 4) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0][0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0][0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[1][1].b >> 3) & 1) << 1;
-        block.y |= ((endPoint[1][1].b >> 4) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[0][1].r >> 5) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[1][1].b >> 0) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[1][1].b >> 1) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][0].r >> 4) & 1) << 5;
-        block.z |= ((endPoint[1][0].r >> 5) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][1].r >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].r >> 5) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-    else if (mode_type == candidateModeFlag[7])
-    {
-        /*block.x = candidateModeMemory[7];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
-        block.y |= ( endPoint[0][0].b >> 7 ) & 0x00000001;
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x000000F8 ) | ( ( endPoint[0][1].g << 13 ) & 0x0007E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x0F800000 );
-        block.x |= ( ( endPoint[1][0].g << 20 ) & 0x01000000 ) | ( ( endPoint[1][0].b << 10 ) & 0x00004000 );
-        block.x |= ( ( endPoint[1][0].g << 18 ) & 0x00800000 );
-        block.x |= ( ( endPoint[1][1].b << 13 ) & 0x00002000 );
-        block.yz |= ( endPoint[1][0].gr << uint2(9, 1) ) & uint2(0x00001E00, 0x0000003E);
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00000F80);
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.y |= ( ( endPoint[1][1].g >> 4 ) & 0x00000002 ) | ( ( endPoint[1][1].g << 4 ) & 0x00000100 ) | ( ( endPoint[1][1].b >> 2 ) & 0x00000004 );
-        block.y |= ( endPoint[1][1].b << 27 ) & 0x10000000;
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;
-        block.z |= ( ( endPoint[1][1].b << 9 ) & 0x00001000 ) | ( ( endPoint[1][1].b << 4 ) & 0x00000040 );*/
-
-        block.x |= ((candidateModeMemory[7] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[7] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[7] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[7] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[7] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0][0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0][0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[1][1].b >> 0) & 1) << 13;
-        block.x |= ((endPoint[1][0].b >> 4) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0][0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0][0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[1][0].g >> 5) & 1) << 23;
-        block.x |= ((endPoint[1][0].g >> 4) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0][0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0][0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[1][1].g >> 5) & 1) << 1;
-        block.y |= ((endPoint[1][1].b >> 4) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[1][1].g >> 4) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[0][1].g >> 5) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[1][1].b >> 1) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][0].r >> 4) & 1) << 5;
-        block.z |= ((endPoint[1][1].b >> 2) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][1].r >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].b >> 3) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-    else if (mode_type == candidateModeFlag[8])
-    {
-        /*block.x = candidateModeMemory[8];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
-        block.y |= ( endPoint[0][0].b >> 7 ) & 0x00000001;
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x000000F8 ) | ( ( endPoint[0][1].g << 13 ) & 0x0003E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x1F800000 );
-        block.x |= ( ( endPoint[1][0].g << 20 ) & 0x01000000 ) | ( ( endPoint[1][0].b << 10 ) & 0x00004000 );
-        block.x |= ( ( endPoint[1][0].b << 18 ) & 0x00800000 );
-        block.x |= ( endPoint[1][1].b << 12 ) & 0x00002000;
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.y |= ( ( endPoint[1][1].g << 4 ) & 0x00000100 ) | ( ( endPoint[1][1].b >> 4 ) & 0x00000002 ) | ( ( endPoint[1][1].b >> 2 ) & 0x00000004 );
-        block.yz |= ( endPoint[1][0].gr << uint2(9, 1) ) & uint2(0x00001E00, 0x0000003E);
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00000F80);
-        block.y |= ( endPoint[1][1].b << 18 ) & 0x00040000;
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;
-        block.z |= ( ( endPoint[1][1].b << 9 ) & 0x00001000 ) | ( ( endPoint[1][1].b << 4 ) & 0x00000040 );*/
-
-        block.x |= ((candidateModeMemory[8] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[8] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[8] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[8] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[8] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0][0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0][0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[1][1].b >> 1) & 1) << 13;
-        block.x |= ((endPoint[1][0].b >> 4) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0][0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0][0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[1][0].b >> 5) & 1) << 23;
-        block.x |= ((endPoint[1][0].g >> 4) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0][0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0][0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[1][1].b >> 5) & 1) << 1;
-        block.y |= ((endPoint[1][1].b >> 4) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[1][1].g >> 4) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[1][1].b >> 0) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[0][1].b >> 5) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][0].r >> 4) & 1) << 5;
-        block.z |= ((endPoint[1][1].b >> 2) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][1].r >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].b >> 3) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-    else if (mode_type == candidateModeFlag[9])
-    {
-        /*block.x = candidateModeMemory[9];
-        block.x |= ( ( endPoint[0][0].r << 5 ) & 0x000007E0 ) | ( ( endPoint[0][0].g << 15 ) & 0x001F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0x7E000000 );
-        block.y |= ( ( endPoint[0][1].r << 3 ) & 0x000001F8 ) | ( ( endPoint[0][1].g << 13 ) & 0x0007E000 ) | ( ( endPoint[0][1].b << 23 ) & 0x1F800000 );
-        block.x |= ( ( endPoint[1][0].g << 16 ) & 0x00200000 ) | ( ( endPoint[1][0].g << 20 ) & 0x01000000 );
-        block.x |= ( ( endPoint[1][0].b << 17 ) & 0x00400000 ) | ( ( endPoint[1][0].b << 10 ) & 0x00004000 );
-        block.x |= ( ( endPoint[1][1].b << 21 ) & 0x00800000 ) | ( ( endPoint[1][1].b << 12 ) & 0x00003000 );
-        block.x |= ( ( endPoint[1][1].g << 26 ) & 0x80000000 ) | ( ( endPoint[1][1].g << 7 ) & 0x00000800 );
-        block.yz |= ( endPoint[1][0].gr << uint2(9, 1) ) & uint2(0x00001E00, 0x0000007E);
-        block.yz |= ( endPoint[1][1].gr << uint2(19, 7) ) & uint2(0x00780000, 0x00001F80);
-        block.y |= ( endPoint[1][0].b << 29 ) & 0xE0000000;
-        block.y |= ( ( endPoint[1][1].b >> 4 ) & 0x00000002 ) | ( ( endPoint[1][1].b >> 2 ) & 0x00000004 ) | ( ( endPoint[1][1].b >> 3 ) & 0x00000001 );
-        block.z |= ( endPoint[1][0].b >> 3 ) & 0x00000001;*/
-
-        block.x |= ((candidateModeMemory[9] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[9] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[9] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[9] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[9] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0][0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0][0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0][0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0][0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0][0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0][0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[1][1].g >> 4) & 1) << 11;
-        block.x |= ((endPoint[1][1].b >> 0) & 1) << 12;
-        block.x |= ((endPoint[1][1].b >> 1) & 1) << 13;
-        block.x |= ((endPoint[1][0].b >> 4) & 1) << 14;
-        block.x |= ((endPoint[0][0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0][0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0][0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0][0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0][0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0][0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[1][0].g >> 5) & 1) << 21;
-        block.x |= ((endPoint[1][0].b >> 5) & 1) << 22;
-        block.x |= ((endPoint[1][1].b >> 2) & 1) << 23;
-        block.x |= ((endPoint[1][0].g >> 4) & 1) << 24;
-        block.x |= ((endPoint[0][0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0][0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0][0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0][0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0][0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0][0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[1][1].g >> 5) & 1) << 31;
-        block.y |= ((endPoint[1][1].b >> 3) & 1) << 0;
-        block.y |= ((endPoint[1][1].b >> 5) & 1) << 1;
-        block.y |= ((endPoint[1][1].b >> 4) & 1) << 2;
-        block.y |= ((endPoint[0][1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[0][1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[0][1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[0][1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0][1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[0][1].r >> 5) & 1) << 8;
-        block.y |= ((endPoint[1][0].g >> 0) & 1) << 9;
-        block.y |= ((endPoint[1][0].g >> 1) & 1) << 10;
-        block.y |= ((endPoint[1][0].g >> 2) & 1) << 11;
-        block.y |= ((endPoint[1][0].g >> 3) & 1) << 12;
-        block.y |= ((endPoint[0][1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[0][1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[0][1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[0][1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0][1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[0][1].g >> 5) & 1) << 18;
-        block.y |= ((endPoint[1][1].g >> 0) & 1) << 19;
-        block.y |= ((endPoint[1][1].g >> 1) & 1) << 20;
-        block.y |= ((endPoint[1][1].g >> 2) & 1) << 21;
-        block.y |= ((endPoint[1][1].g >> 3) & 1) << 22;
-        block.y |= ((endPoint[0][1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[0][1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[0][1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[0][1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0][1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[0][1].b >> 5) & 1) << 28;
-        block.y |= ((endPoint[1][0].b >> 0) & 1) << 29;
-        block.y |= ((endPoint[1][0].b >> 1) & 1) << 30;
-        block.y |= ((endPoint[1][0].b >> 2) & 1) << 31;
-        block.z |= ((endPoint[1][0].b >> 3) & 1) << 0;
-        block.z |= ((endPoint[1][0].r >> 0) & 1) << 1;
-        block.z |= ((endPoint[1][0].r >> 1) & 1) << 2;
-        block.z |= ((endPoint[1][0].r >> 2) & 1) << 3;
-        block.z |= ((endPoint[1][0].r >> 3) & 1) << 4;
-        block.z |= ((endPoint[1][0].r >> 4) & 1) << 5;
-        block.z |= ((endPoint[1][0].r >> 5) & 1) << 6;
-        block.z |= ((endPoint[1][1].r >> 0) & 1) << 7;
-        block.z |= ((endPoint[1][1].r >> 1) & 1) << 8;
-        block.z |= ((endPoint[1][1].r >> 2) & 1) << 9;
-        block.z |= ((endPoint[1][1].r >> 3) & 1) << 10;
-        block.z |= ((endPoint[1][1].r >> 4) & 1) << 11;
-        block.z |= ((endPoint[1][1].r >> 5) & 1) << 12;
-        block.z |= ((partition_index >> 0) & 1) << 13;
-        block.z |= ((partition_index >> 1) & 1) << 14;
-        block.z |= ((partition_index >> 2) & 1) << 15;
-        block.z |= ((partition_index >> 3) & 1) << 16;
-        block.z |= ((partition_index >> 4) & 1) << 17;
-    }
-}
-void block_package(inout uint4 block, int2x3 endPoint, uint mode_type) // for mode 11 - 14
-{
-    /*block.x = ( ( endPoint[0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0].b << 25 ) & 0xFE000000 );
-    block.y |= ( endPoint[0].b >> 7 ) & 0x00000007;*/
-
-    block.xy = 0;
-    block.z &= 0xFFFFFFFE;
-
-
-    if (mode_type == candidateModeFlag[10])
-    {
-        /* block.x |= candidateModeMemory[10];
-         block.y |= ( ( endPoint[1].r << 3 ) & 0x00001FF8 ) | ( ( endPoint[1].g << 13 ) & 0x007FE000 ) | ( ( endPoint[1].b << 23 ) & 0xFF800000 );
-         block.z |= ( endPoint[1].b >> 9 ) & 0x00000001;*/
-
-        block.x |= ((candidateModeMemory[10] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[10] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[10] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[10] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[10] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[0].r >> 8) & 1) << 13;
-        block.x |= ((endPoint[0].r >> 9) & 1) << 14;
-        block.x |= ((endPoint[0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[0].g >> 8) & 1) << 23;
-        block.x |= ((endPoint[0].g >> 9) & 1) << 24;
-        block.x |= ((endPoint[0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[0].b >> 8) & 1) << 1;
-        block.y |= ((endPoint[0].b >> 9) & 1) << 2;
-        block.y |= ((endPoint[1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[1].r >> 5) & 1) << 8;
-        block.y |= ((endPoint[1].r >> 6) & 1) << 9;
-        block.y |= ((endPoint[1].r >> 7) & 1) << 10;
-        block.y |= ((endPoint[1].r >> 8) & 1) << 11;
-        block.y |= ((endPoint[1].r >> 9) & 1) << 12;
-        block.y |= ((endPoint[1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[1].g >> 5) & 1) << 18;
-        block.y |= ((endPoint[1].g >> 6) & 1) << 19;
-        block.y |= ((endPoint[1].g >> 7) & 1) << 20;
-        block.y |= ((endPoint[1].g >> 8) & 1) << 21;
-        block.y |= ((endPoint[1].g >> 9) & 1) << 22;
-        block.y |= ((endPoint[1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[1].b >> 5) & 1) << 28;
-        block.y |= ((endPoint[1].b >> 6) & 1) << 29;
-        block.y |= ((endPoint[1].b >> 7) & 1) << 30;
-        block.y |= ((endPoint[1].b >> 8) & 1) << 31;
-        block.z |= ((endPoint[1].b >> 9) & 1) << 0;
-    }
-    else if (mode_type == candidateModeFlag[11])
-    {
-        /*block.x |= candidateModeMemory[11];
-        block.y |= ( ( endPoint[0].r << 2 ) & 0x00001000 ) | ( ( endPoint[0].g << 12 ) & 0x00400000 );
-        block.y |= ( ( endPoint[1].r << 3 ) & 0x00000FF8 ) | ( ( endPoint[1].g << 13 ) & 0x003FE000 ) | ( ( endPoint[1].b << 23 ) & 0xFF800000 );
-        block.z |= ( endPoint[0].b >> 10 ) & 0x00000001;*/
-
-        block.x |= ((candidateModeMemory[11] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[11] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[11] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[11] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[11] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[0].r >> 8) & 1) << 13;
-        block.x |= ((endPoint[0].r >> 9) & 1) << 14;
-        block.x |= ((endPoint[0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[0].g >> 8) & 1) << 23;
-        block.x |= ((endPoint[0].g >> 9) & 1) << 24;
-        block.x |= ((endPoint[0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[0].b >> 8) & 1) << 1;
-        block.y |= ((endPoint[0].b >> 9) & 1) << 2;
-        block.y |= ((endPoint[1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[1].r >> 5) & 1) << 8;
-        block.y |= ((endPoint[1].r >> 6) & 1) << 9;
-        block.y |= ((endPoint[1].r >> 7) & 1) << 10;
-        block.y |= ((endPoint[1].r >> 8) & 1) << 11;
-        block.y |= ((endPoint[0].r >> 10) & 1) << 12;
-        block.y |= ((endPoint[1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[1].g >> 5) & 1) << 18;
-        block.y |= ((endPoint[1].g >> 6) & 1) << 19;
-        block.y |= ((endPoint[1].g >> 7) & 1) << 20;
-        block.y |= ((endPoint[1].g >> 8) & 1) << 21;
-        block.y |= ((endPoint[0].g >> 10) & 1) << 22;
-        block.y |= ((endPoint[1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[1].b >> 5) & 1) << 28;
-        block.y |= ((endPoint[1].b >> 6) & 1) << 29;
-        block.y |= ((endPoint[1].b >> 7) & 1) << 30;
-        block.y |= ((endPoint[1].b >> 8) & 1) << 31;
-        block.z |= ((endPoint[0].b >> 10) & 1) << 0;
-    }
-    else if (mode_type == candidateModeFlag[12])// violate the spec in  [0].low
-    {
-        /*block.x |= candidateModeMemory[12];
-        block.y |= ( ( endPoint[0].r << 2 ) & 0x00001000 ) | ( ( endPoint[0].g << 12 ) & 0x00400000 );
-        block.y |= ( ( endPoint[0].r << 0 ) & 0x00000800 ) | ( ( endPoint[0].g << 10 ) & 0x00200000 );
-        block.y |= ( endPoint[0].b << 20 ) & 0x80000000;
-        block.y |= ( ( endPoint[1].r << 3 ) & 0x000007F8 ) | ( ( endPoint[1].g << 13 ) & 0x001FE000 ) | ( ( endPoint[1].b << 23 ) & 0x7F800000 );
-        block.z |= ( endPoint[0].b >> 10 ) & 0x00000001;*/
-
-        block.x |= ((candidateModeMemory[12] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[12] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[12] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[12] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[12] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[0].r >> 8) & 1) << 13;
-        block.x |= ((endPoint[0].r >> 9) & 1) << 14;
-        block.x |= ((endPoint[0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[0].g >> 8) & 1) << 23;
-        block.x |= ((endPoint[0].g >> 9) & 1) << 24;
-        block.x |= ((endPoint[0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[0].b >> 8) & 1) << 1;
-        block.y |= ((endPoint[0].b >> 9) & 1) << 2;
-        block.y |= ((endPoint[1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[1].r >> 4) & 1) << 7;
-        block.y |= ((endPoint[1].r >> 5) & 1) << 8;
-        block.y |= ((endPoint[1].r >> 6) & 1) << 9;
-        block.y |= ((endPoint[1].r >> 7) & 1) << 10;
-        block.y |= ((endPoint[0].r >> 11) & 1) << 11;
-        block.y |= ((endPoint[0].r >> 10) & 1) << 12;
-        block.y |= ((endPoint[1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[1].g >> 4) & 1) << 17;
-        block.y |= ((endPoint[1].g >> 5) & 1) << 18;
-        block.y |= ((endPoint[1].g >> 6) & 1) << 19;
-        block.y |= ((endPoint[1].g >> 7) & 1) << 20;
-        block.y |= ((endPoint[0].g >> 11) & 1) << 21;
-        block.y |= ((endPoint[0].g >> 10) & 1) << 22;
-        block.y |= ((endPoint[1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[1].b >> 4) & 1) << 27;
-        block.y |= ((endPoint[1].b >> 5) & 1) << 28;
-        block.y |= ((endPoint[1].b >> 6) & 1) << 29;
-        block.y |= ((endPoint[1].b >> 7) & 1) << 30;
-        block.y |= ((endPoint[0].b >> 11) & 1) << 31;
-        block.z |= ((endPoint[0].b >> 10) & 1) << 0;
-    }
-    else if (mode_type == candidateModeFlag[13])
-    {
-        /*block.x |= candidateModeMemory[13];
-        block.y |= ( ( endPoint[0].r >> 8 ) & 0x00000080 );
-        block.y |= ( ( endPoint[0].r >> 6 ) & 0x00000100 );
-        block.y |= ( ( endPoint[0].r >> 4 ) & 0x00000200 );
-        block.y |= ( ( endPoint[0].r >> 2 ) & 0x00000400 );
-        block.y |= ( ( endPoint[0].r >> 0 ) & 0x00000800 );
-        block.y |= ( ( endPoint[0].r << 2 ) & 0x00001000 );
-        block.y |= ( ( endPoint[0].g << 2 ) & 0x00020000 );
-        block.y |= ( ( endPoint[0].g << 4 ) & 0x00040000 );
-        block.y |= ( ( endPoint[0].g << 6 ) & 0x00080000 );
-        block.y |= ( ( endPoint[0].g << 8 ) & 0x00100000 );
-        block.y |= ( ( endPoint[0].g << 10 ) & 0x00200000 );
-        block.y |= ( ( endPoint[0].g << 12 ) & 0x00400000 );
-        block.y |= ( ( endPoint[0].b << 12 ) & 0x08000000 );
-        block.y |= ( ( endPoint[0].b << 14 ) & 0x10000000 );
-        block.y |= ( ( endPoint[0].b << 16 ) & 0x20000000 );
-        block.y |= ( ( endPoint[0].b << 18 ) & 0x40000000 );
-        block.y |= ( ( endPoint[0].b << 20 ) & 0x80000000 );
-        block.y |= ( ( endPoint[1].r << 3 ) & 0x00000078 ) | ( ( endPoint[1].g << 13 ) & 0x0001E000 ) | ( ( endPoint[1].b << 23 ) & 0x07800000 );
-        block.z |= ( endPoint[0].b >> 10 ) & 0x00000001;*/
-
-        block.x |= ((candidateModeMemory[13] >> 0) & 1) << 0;
-        block.x |= ((candidateModeMemory[13] >> 1) & 1) << 1;
-        block.x |= ((candidateModeMemory[13] >> 2) & 1) << 2;
-        block.x |= ((candidateModeMemory[13] >> 3) & 1) << 3;
-        block.x |= ((candidateModeMemory[13] >> 4) & 1) << 4;
-        block.x |= ((endPoint[0].r >> 0) & 1) << 5;
-        block.x |= ((endPoint[0].r >> 1) & 1) << 6;
-        block.x |= ((endPoint[0].r >> 2) & 1) << 7;
-        block.x |= ((endPoint[0].r >> 3) & 1) << 8;
-        block.x |= ((endPoint[0].r >> 4) & 1) << 9;
-        block.x |= ((endPoint[0].r >> 5) & 1) << 10;
-        block.x |= ((endPoint[0].r >> 6) & 1) << 11;
-        block.x |= ((endPoint[0].r >> 7) & 1) << 12;
-        block.x |= ((endPoint[0].r >> 8) & 1) << 13;
-        block.x |= ((endPoint[0].r >> 9) & 1) << 14;
-        block.x |= ((endPoint[0].g >> 0) & 1) << 15;
-        block.x |= ((endPoint[0].g >> 1) & 1) << 16;
-        block.x |= ((endPoint[0].g >> 2) & 1) << 17;
-        block.x |= ((endPoint[0].g >> 3) & 1) << 18;
-        block.x |= ((endPoint[0].g >> 4) & 1) << 19;
-        block.x |= ((endPoint[0].g >> 5) & 1) << 20;
-        block.x |= ((endPoint[0].g >> 6) & 1) << 21;
-        block.x |= ((endPoint[0].g >> 7) & 1) << 22;
-        block.x |= ((endPoint[0].g >> 8) & 1) << 23;
-        block.x |= ((endPoint[0].g >> 9) & 1) << 24;
-        block.x |= ((endPoint[0].b >> 0) & 1) << 25;
-        block.x |= ((endPoint[0].b >> 1) & 1) << 26;
-        block.x |= ((endPoint[0].b >> 2) & 1) << 27;
-        block.x |= ((endPoint[0].b >> 3) & 1) << 28;
-        block.x |= ((endPoint[0].b >> 4) & 1) << 29;
-        block.x |= ((endPoint[0].b >> 5) & 1) << 30;
-        block.x |= ((endPoint[0].b >> 6) & 1) << 31;
-        block.y |= ((endPoint[0].b >> 7) & 1) << 0;
-        block.y |= ((endPoint[0].b >> 8) & 1) << 1;
-        block.y |= ((endPoint[0].b >> 9) & 1) << 2;
-        block.y |= ((endPoint[1].r >> 0) & 1) << 3;
-        block.y |= ((endPoint[1].r >> 1) & 1) << 4;
-        block.y |= ((endPoint[1].r >> 2) & 1) << 5;
-        block.y |= ((endPoint[1].r >> 3) & 1) << 6;
-        block.y |= ((endPoint[0].r >> 15) & 1) << 7;
-        block.y |= ((endPoint[0].r >> 14) & 1) << 8;
-        block.y |= ((endPoint[0].r >> 13) & 1) << 9;
-        block.y |= ((endPoint[0].r >> 12) & 1) << 10;
-        block.y |= ((endPoint[0].r >> 11) & 1) << 11;
-        block.y |= ((endPoint[0].r >> 10) & 1) << 12;
-        block.y |= ((endPoint[1].g >> 0) & 1) << 13;
-        block.y |= ((endPoint[1].g >> 1) & 1) << 14;
-        block.y |= ((endPoint[1].g >> 2) & 1) << 15;
-        block.y |= ((endPoint[1].g >> 3) & 1) << 16;
-        block.y |= ((endPoint[0].g >> 15) & 1) << 17;
-        block.y |= ((endPoint[0].g >> 14) & 1) << 18;
-        block.y |= ((endPoint[0].g >> 13) & 1) << 19;
-        block.y |= ((endPoint[0].g >> 12) & 1) << 20;
-        block.y |= ((endPoint[0].g >> 11) & 1) << 21;
-        block.y |= ((endPoint[0].g >> 10) & 1) << 22;
-        block.y |= ((endPoint[1].b >> 0) & 1) << 23;
-        block.y |= ((endPoint[1].b >> 1) & 1) << 24;
-        block.y |= ((endPoint[1].b >> 2) & 1) << 25;
-        block.y |= ((endPoint[1].b >> 3) & 1) << 26;
-        block.y |= ((endPoint[0].b >> 15) & 1) << 27;
-        block.y |= ((endPoint[0].b >> 14) & 1) << 28;
-        block.y |= ((endPoint[0].b >> 13) & 1) << 29;
-        block.y |= ((endPoint[0].b >> 12) & 1) << 30;
-        block.y |= ((endPoint[0].b >> 11) & 1) << 31;
-        block.z |= ((endPoint[0].b >> 10) & 1) << 0;
-    }
-}
diff --git a/thirdparty/directxtex/Shaders/BC7Encode.hlsl b/thirdparty/directxtex/Shaders/BC7Encode.hlsl
deleted file mode 100644
index eed5578..0000000
--- a/thirdparty/directxtex/Shaders/BC7Encode.hlsl
+++ /dev/null
@@ -1,1932 +0,0 @@
-//--------------------------------------------------------------------------------------
-// File: BC7Encode.hlsl
-//
-// The Compute Shader for BC7 Encoder
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//--------------------------------------------------------------------------------------
-
-#define REF_DEVICE
-
-#define CHAR_LENGTH			8
-#define NCHANNELS			4
-#define	BC7_UNORM			98
-#define MAX_UINT			0xFFFFFFFF
-#define MIN_UINT			0
-
-static const uint candidateSectionBit[64] = //Associated to partition 0-63
-{
-    0xCCCC, 0x8888, 0xEEEE, 0xECC8,
-    0xC880, 0xFEEC, 0xFEC8, 0xEC80,
-    0xC800, 0xFFEC, 0xFE80, 0xE800,
-    0xFFE8, 0xFF00, 0xFFF0, 0xF000,
-    0xF710, 0x008E, 0x7100, 0x08CE,
-    0x008C, 0x7310, 0x3100, 0x8CCE,
-    0x088C, 0x3110, 0x6666, 0x366C,
-    0x17E8, 0x0FF0, 0x718E, 0x399C,
-    0xaaaa, 0xf0f0, 0x5a5a, 0x33cc,
-    0x3c3c, 0x55aa, 0x9696, 0xa55a,
-    0x73ce, 0x13c8, 0x324c, 0x3bdc,
-    0x6996, 0xc33c, 0x9966, 0x660,
-    0x272, 0x4e4, 0x4e40, 0x2720,
-    0xc936, 0x936c, 0x39c6, 0x639c,
-    0x9336, 0x9cc6, 0x817e, 0xe718,
-    0xccf0, 0xfcc, 0x7744, 0xee22,
-};
-static const uint candidateSectionBit2[64] = //Associated to partition 64-127
-{
-    0xaa685050, 0x6a5a5040, 0x5a5a4200, 0x5450a0a8,
-    0xa5a50000, 0xa0a05050, 0x5555a0a0, 0x5a5a5050,
-    0xaa550000, 0xaa555500, 0xaaaa5500, 0x90909090,
-    0x94949494, 0xa4a4a4a4, 0xa9a59450, 0x2a0a4250,
-    0xa5945040, 0x0a425054, 0xa5a5a500, 0x55a0a0a0,
-    0xa8a85454, 0x6a6a4040, 0xa4a45000, 0x1a1a0500,
-    0x0050a4a4, 0xaaa59090, 0x14696914, 0x69691400,
-    0xa08585a0, 0xaa821414, 0x50a4a450, 0x6a5a0200,
-    0xa9a58000, 0x5090a0a8, 0xa8a09050, 0x24242424,
-    0x00aa5500, 0x24924924, 0x24499224, 0x50a50a50,
-    0x500aa550, 0xaaaa4444, 0x66660000, 0xa5a0a5a0,
-    0x50a050a0, 0x69286928, 0x44aaaa44, 0x66666600,
-    0xaa444444, 0x54a854a8, 0x95809580, 0x96969600,
-    0xa85454a8, 0x80959580, 0xaa141414, 0x96960000,
-    0xaaaa1414, 0xa05050a0, 0xa0a5a5a0, 0x96000000,
-    0x40804080, 0xa9a8a9a8, 0xaaaaaa44, 0x2a4a5254,
-};
-static const uint2 candidateFixUpIndex1D[128] =
-{
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{ 2, 0},{ 8, 0},{ 2, 0},
-    { 2, 0},{ 8, 0},{ 8, 0},{15, 0},
-    { 2, 0},{ 8, 0},{ 2, 0},{ 2, 0},
-    { 8, 0},{ 8, 0},{ 2, 0},{ 2, 0},
-
-    {15, 0},{15, 0},{ 6, 0},{ 8, 0},
-    { 2, 0},{ 8, 0},{15, 0},{15, 0},
-    { 2, 0},{ 8, 0},{ 2, 0},{ 2, 0},
-    { 2, 0},{15, 0},{15, 0},{ 6, 0},
-    { 6, 0},{ 2, 0},{ 6, 0},{ 8, 0},
-    {15, 0},{15, 0},{ 2, 0},{ 2, 0},
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{ 2, 0},{ 2, 0},{15, 0},
-    //candidateFixUpIndex1D[i][1], i < 64 should not be used
-
-    { 3,15},{ 3, 8},{15, 8},{15, 3},
-    { 8,15},{ 3,15},{15, 3},{15, 8},
-    { 8,15},{ 8,15},{ 6,15},{ 6,15},
-    { 6,15},{ 5,15},{ 3,15},{ 3, 8},
-    { 3,15},{ 3, 8},{ 8,15},{15, 3},
-    { 3,15},{ 3, 8},{ 6,15},{10, 8},
-    { 5, 3},{ 8,15},{ 8, 6},{ 6,10},
-    { 8,15},{ 5,15},{15,10},{15, 8},
-
-    { 8,15},{15, 3},{ 3,15},{ 5,10},
-    { 6,10},{10, 8},{ 8, 9},{15,10},
-    {15, 6},{ 3,15},{15, 8},{ 5,15},
-    {15, 3},{15, 6},{15, 6},{15, 8}, //The Spec doesn't mark the first fixed up index in this row, so I apply 15 for them, and seems correct
-    { 3,15},{15, 3},{ 5,15},{ 5,15},
-    { 5,15},{ 8,15},{ 5,15},{10,15},
-    { 5,15},{10,15},{ 8,15},{13,15},
-    {15, 3},{12,15},{ 3,15},{ 3, 8},
-};
-static const uint2 candidateFixUpIndex1DOrdered[128] = //Same with candidateFixUpIndex1D but order the result when i >= 64
-{
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{ 2, 0},{ 8, 0},{ 2, 0},
-    { 2, 0},{ 8, 0},{ 8, 0},{15, 0},
-    { 2, 0},{ 8, 0},{ 2, 0},{ 2, 0},
-    { 8, 0},{ 8, 0},{ 2, 0},{ 2, 0},
-
-    {15, 0},{15, 0},{ 6, 0},{ 8, 0},
-    { 2, 0},{ 8, 0},{15, 0},{15, 0},
-    { 2, 0},{ 8, 0},{ 2, 0},{ 2, 0},
-    { 2, 0},{15, 0},{15, 0},{ 6, 0},
-    { 6, 0},{ 2, 0},{ 6, 0},{ 8, 0},
-    {15, 0},{15, 0},{ 2, 0},{ 2, 0},
-    {15, 0},{15, 0},{15, 0},{15, 0},
-    {15, 0},{ 2, 0},{ 2, 0},{15, 0},
-    //candidateFixUpIndex1DOrdered[i][1], i < 64 should not be used
-
-    { 3,15},{ 3, 8},{ 8,15},{ 3,15},
-    { 8,15},{ 3,15},{ 3,15},{ 8,15},
-    { 8,15},{ 8,15},{ 6,15},{ 6,15},
-    { 6,15},{ 5,15},{ 3,15},{ 3, 8},
-    { 3,15},{ 3, 8},{ 8,15},{ 3,15},
-    { 3,15},{ 3, 8},{ 6,15},{ 8,10},
-    { 3, 5},{ 8,15},{ 6, 8},{ 6,10},
-    { 8,15},{ 5,15},{10,15},{ 8,15},
-
-    { 8,15},{ 3,15},{ 3,15},{ 5,10},
-    { 6,10},{ 8,10},{ 8, 9},{10,15},
-    { 6,15},{ 3,15},{ 8,15},{ 5,15},
-    { 3,15},{ 6,15},{ 6,15},{ 8,15}, //The Spec doesn't mark the first fixed up index in this row, so I apply 15 for them, and seems correct
-    { 3,15},{ 3,15},{ 5,15},{ 5,15},
-    { 5,15},{ 8,15},{ 5,15},{10,15},
-    { 5,15},{10,15},{ 8,15},{13,15},
-    { 3,15},{12,15},{ 3,15},{ 3, 8},
-};
-//static const uint4x4 candidateRotation[4] = 
-//{
-//    {1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1},
-//    {0,0,0,1},{0,1,0,0},{0,0,1,0},{1,0,0,0},
-//    {1,0,0,0},{0,0,0,1},{0,0,1,0},{0,1,0,0},
-//    {1,0,0,0},{0,1,0,0},{0,0,0,1},{0,0,1,0}
-//};
-//static const uint2 candidateIndexPrec[8] = {{3,0},{3,0},{2,0},{2,0},
-//                                            {2,3}, //color index and alpha index can exchange
-//                                            {2,2},{4,4},{2,2}};
-
-static const uint aWeight[3][16] = { {0,  4,  9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64},
-                                    {0,  9, 18, 27, 37, 46, 55, 64,  0,  0,  0,  0,  0,  0,  0,  0},
-                                    {0, 21, 43, 64,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0} };
-
-//4 bit index: 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64
-static const uint aStep[3][64] = { { 0, 0, 0, 1, 1, 1, 1, 2,
-                                    2, 2, 2, 2, 3, 3, 3, 3,
-                                    4, 4, 4, 4, 5, 5, 5, 5,
-                                    6, 6, 6, 6, 6, 7, 7, 7,
-                                    7, 8, 8, 8, 8, 9, 9, 9,
-                                    9,10,10,10,10,10,11,11,
-                                   11,11,12,12,12,12,13,13,
-                                   13,13,14,14,14,14,15,15 },
-    //3 bit index: 0, 9, 18, 27, 37, 46, 55, 64
-        { 0,0,0,0,0,1,1,1,
-        1,1,1,1,1,1,2,2,
-        2,2,2,2,2,2,2,3,
-        3,3,3,3,3,3,3,3,
-        3,4,4,4,4,4,4,4,
-        4,4,5,5,5,5,5,5,
-        5,5,5,6,6,6,6,6,
-        6,6,6,6,7,7,7,7 },
-    //2 bit index: 0, 21, 43, 64
-        { 0,0,0,0,0,0,0,0,
-        0,0,0,1,1,1,1,1,
-        1,1,1,1,1,1,1,1,
-        1,1,1,1,1,1,1,1,
-        1,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,3,3,
-        3,3,3,3,3,3,3,3 } };
-
-cbuffer cbCS : register(b0)
-{
-    uint g_tex_width;
-    uint g_num_block_x;
-    uint g_format;
-    uint g_mode_id;
-    uint g_start_block_id;
-    uint g_num_total_blocks;
-    float g_alpha_weight;
-};
-
-//Forward declaration
-uint2x4 compress_endpoints0(inout uint2x4 endPoint, uint2 P); //Mode = 0
-uint2x4 compress_endpoints1(inout uint2x4 endPoint, uint2 P); //Mode = 1
-uint2x4 compress_endpoints2(inout uint2x4 endPoint); //Mode = 2
-uint2x4 compress_endpoints3(inout uint2x4 endPoint, uint2 P); //Mode = 3
-uint2x4 compress_endpoints7(inout uint2x4 endPoint, uint2 P); //Mode = 7
-uint2x4 compress_endpoints6(inout uint2x4 endPoint, uint2 P); //Mode = 6
-uint2x4 compress_endpoints4(inout uint2x4 endPoint); //Mode = 4
-uint2x4 compress_endpoints5(inout uint2x4 endPoint); //Mode = 5
-
-void block_package0(out uint4 block, uint partition, uint threadBase); //Mode0
-void block_package1(out uint4 block, uint partition, uint threadBase); //Mode1
-void block_package2(out uint4 block, uint partition, uint threadBase); //Mode2
-void block_package3(out uint4 block, uint partition, uint threadBase); //Mode3
-void block_package4(out uint4 block, uint rotation, uint index_selector, uint threadBase); //Mode4
-void block_package5(out uint4 block, uint rotation, uint threadBase); //Mode5
-void block_package6(out uint4 block, uint threadBase); //Mode6
-void block_package7(out uint4 block, uint partition, uint threadBase); //Mode7
-
-
-void swap(inout uint4 lhs, inout uint4 rhs)
-{
-    uint4 tmp = lhs;
-    lhs = rhs;
-    rhs = tmp;
-}
-void swap(inout uint3 lhs, inout uint3 rhs)
-{
-    uint3 tmp = lhs;
-    lhs = rhs;
-    rhs = tmp;
-}
-void swap(inout uint lhs, inout uint rhs)
-{
-    uint tmp = lhs;
-    lhs = rhs;
-    rhs = tmp;
-}
-
-uint ComputeError(in uint4 a, in uint4 b)
-{
-    return dot(a.rgb, b.rgb) + g_alpha_weight * a.a*b.a;
-}
-
-void Ensure_A_Is_Larger(inout uint4 a, inout uint4 b)
-{
-    if (a.x < b.x)
-        swap(a.x, b.x);
-    if (a.y < b.y)
-        swap(a.y, b.y);
-    if (a.z < b.z)
-        swap(a.z, b.z);
-    if (a.w < b.w)
-        swap(a.w, b.w);
-}
-
-
-Texture2D g_Input : register(t0);
-StructuredBuffer<uint4> g_InBuff : register(t1);
-
-RWStructuredBuffer<uint4> g_OutBuff : register(u0);
-
-#define THREAD_GROUP_SIZE	64
-#define BLOCK_SIZE_Y		4
-#define BLOCK_SIZE_X		4
-#define BLOCK_SIZE			(BLOCK_SIZE_Y * BLOCK_SIZE_X)
-
-struct BufferShared
-{
-    uint4 pixel;
-    uint error;
-    uint mode;
-    uint partition;
-    uint index_selector;
-    uint rotation;
-    uint4 endPoint_low;
-    uint4 endPoint_high;
-    uint4 endPoint_low_quantized;
-    uint4 endPoint_high_quantized;
-};
-groupshared BufferShared shared_temp[THREAD_GROUP_SIZE];
-
-[numthreads(THREAD_GROUP_SIZE, 1, 1)]
-void TryMode456CS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID) // mode 4 5 6 all have 1 subset per block, and fix-up index is always index 0
-{
-    // we process 4 BC blocks per thread group
-    const uint MAX_USED_THREAD = 16;                                                // pixels in a BC (block compressed) block
-    uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;                      // the number of BC blocks a thread group processes = 64 / 16 = 4
-    uint blockInGroup = GI / MAX_USED_THREAD;                                       // what BC block this thread is on within this thread group
-    uint blockID = g_start_block_id + groupID.x * BLOCK_IN_GROUP + blockInGroup;    // what global BC block this thread is on
-    uint threadBase = blockInGroup * MAX_USED_THREAD;                               // the first id of the pixel in this BC block in this thread group
-    uint threadInBlock = GI - threadBase;                                           // id of the pixel in this BC block
-
-#ifndef REF_DEVICE
-    if (blockID >= g_num_total_blocks)
-    {
-        return;
-    }
-#endif
-
-    uint block_y = blockID / g_num_block_x;
-    uint block_x = blockID - block_y * g_num_block_x;
-    uint base_x = block_x * BLOCK_SIZE_X;
-    uint base_y = block_y * BLOCK_SIZE_Y;
-
-    if (threadInBlock < 16)
-    {
-        shared_temp[GI].pixel = clamp(uint4(g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)) * 255), 0, 255);
-
-        shared_temp[GI].endPoint_low = shared_temp[GI].pixel;
-        shared_temp[GI].endPoint_high = shared_temp[GI].pixel;
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 8)
-    {
-        shared_temp[GI].endPoint_low = min(shared_temp[GI].endPoint_low, shared_temp[GI + 8].endPoint_low);
-        shared_temp[GI].endPoint_high = max(shared_temp[GI].endPoint_high, shared_temp[GI + 8].endPoint_high);
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 4)
-    {
-        shared_temp[GI].endPoint_low = min(shared_temp[GI].endPoint_low, shared_temp[GI + 4].endPoint_low);
-        shared_temp[GI].endPoint_high = max(shared_temp[GI].endPoint_high, shared_temp[GI + 4].endPoint_high);
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 2)
-    {
-        shared_temp[GI].endPoint_low = min(shared_temp[GI].endPoint_low, shared_temp[GI + 2].endPoint_low);
-        shared_temp[GI].endPoint_high = max(shared_temp[GI].endPoint_high, shared_temp[GI + 2].endPoint_high);
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 1)
-    {
-        shared_temp[GI].endPoint_low = min(shared_temp[GI].endPoint_low, shared_temp[GI + 1].endPoint_low);
-        shared_temp[GI].endPoint_high = max(shared_temp[GI].endPoint_high, shared_temp[GI + 1].endPoint_high);
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    uint2x4 endPoint;
-    endPoint[0] = shared_temp[threadBase].endPoint_low;
-    endPoint[1] = shared_temp[threadBase].endPoint_high;
-
-    uint error = 0xFFFFFFFF;
-    uint mode = 0;
-    uint index_selector = 0;
-    uint rotation = 0;
-
-    uint2 indexPrec;
-    if (threadInBlock < 8) // all threads of threadInBlock < 8 will be working on trying out mode 4, since only mode 4 has index selector bit
-    {
-        if (0 == (threadInBlock & 1)) // thread 0, 2, 4, 6
-        {
-            //2 represents 2bit index precision; 1 represents 3bit index precision
-            index_selector = 0;
-            indexPrec = uint2(2, 1);
-        }
-        else                          // thread 1, 3, 5, 7
-        {
-            //2 represents 2bit index precision; 1 represents 3bit index precision
-            index_selector = 1;
-            indexPrec = uint2(1, 2);
-        }
-    }
-    else
-    {
-        //2 represents 2bit index precision
-        indexPrec = uint2(2, 2);
-    }
-
-    uint4 pixel_r;
-    uint color_index;
-    uint alpha_index;
-    int4 span;
-    int2 span_norm_sqr;
-    int2 dotProduct;
-    if (threadInBlock < 12) // Try mode 4 5 in threads 0..11
-    {
-        // mode 4 5 have component rotation
-        if ((threadInBlock < 2) || (8 == threadInBlock))       // rotation = 0 in thread 0, 1
-        {
-            rotation = 0;
-        }
-        else if ((threadInBlock < 4) || (9 == threadInBlock))  // rotation = 1 in thread 2, 3
-        {
-            endPoint[0].ra = endPoint[0].ar;
-            endPoint[1].ra = endPoint[1].ar;
-
-            rotation = 1;
-        }
-        else if ((threadInBlock < 6) || (10 == threadInBlock)) // rotation = 2 in thread 4, 5
-        {
-            endPoint[0].ga = endPoint[0].ag;
-            endPoint[1].ga = endPoint[1].ag;
-
-            rotation = 2;
-        }
-        else if ((threadInBlock < 8) || (11 == threadInBlock)) // rotation = 3 in thread 6, 7
-        {
-            endPoint[0].ba = endPoint[0].ab;
-            endPoint[1].ba = endPoint[1].ab;
-
-            rotation = 3;
-        }
-
-        if (threadInBlock < 8)  // try mode 4 in threads 0..7
-        {
-            // mode 4 thread distribution
-            // Thread           0	1	2	3	4	5	6	7
-            // Rotation	        0	0	1	1	2	2	3	3
-            // Index selector   0	1	0	1	0	1	0	1
-
-            mode = 4;
-            compress_endpoints4(endPoint);
-        }
-        else                    // try mode 5 in threads 8..11
-        {
-            // mode 5 thread distribution
-            // Thread	 8	9  10  11
-            // Rotation	 0	1   2   3
-
-            mode = 5;
-            compress_endpoints5(endPoint);
-        }
-
-        uint4 pixel = shared_temp[threadBase + 0].pixel;
-        if (1 == rotation)
-        {
-            pixel.ra = pixel.ar;
-        }
-        else if (2 == rotation)
-        {
-            pixel.ga = pixel.ag;
-        }
-        else if (3 == rotation)
-        {
-            pixel.ba = pixel.ab;
-        }
-
-        span = endPoint[1] - endPoint[0];
-        span_norm_sqr = uint2(dot(span.rgb, span.rgb), span.a * span.a);
-
-        // in mode 4 5 6, end point 0 must be closer to pixel 0 than end point 1, because of the fix-up index is always index 0
-        // TODO: this shouldn't be necessary here in error calculation
-        /*
-        dotProduct = int2( dot( span.rgb, pixel.rgb - endPoint[0].rgb ), span.a * ( pixel.a - endPoint[0].a ) );
-        if ( span_norm_sqr.x > 0 && dotProduct.x > 0 && uint( dotProduct.x * 63.49999 ) > uint( 32 * span_norm_sqr.x ) )
-        {
-            span.rgb = -span.rgb;
-            swap(endPoint[0].rgb, endPoint[1].rgb);
-        }
-        if ( span_norm_sqr.y > 0 && dotProduct.y > 0 && uint( dotProduct.y * 63.49999 ) > uint( 32 * span_norm_sqr.y ) )
-        {
-            span.a = -span.a;
-            swap(endPoint[0].a, endPoint[1].a);
-        }
-        */
-
-        // should be the same as above
-        dotProduct = int2(dot(pixel.rgb - endPoint[0].rgb, pixel.rgb - endPoint[0].rgb), dot(pixel.rgb - endPoint[1].rgb, pixel.rgb - endPoint[1].rgb));
-        if (dotProduct.x > dotProduct.y)
-        {
-            span.rgb = -span.rgb;
-            swap(endPoint[0].rgb, endPoint[1].rgb);
-        }
-        dotProduct = int2(dot(pixel.a - endPoint[0].a, pixel.a - endPoint[0].a), dot(pixel.a - endPoint[1].a, pixel.a - endPoint[1].a));
-        if (dotProduct.x > dotProduct.y)
-        {
-            span.a = -span.a;
-            swap(endPoint[0].a, endPoint[1].a);
-        }
-
-        error = 0;
-        for (uint i = 0; i < 16; i++)
-        {
-            pixel = shared_temp[threadBase + i].pixel;
-            if (1 == rotation)
-            {
-                pixel.ra = pixel.ar;
-            }
-            else if (2 == rotation)
-            {
-                pixel.ga = pixel.ag;
-            }
-            else if (3 == rotation)
-            {
-                pixel.ba = pixel.ab;
-            }
-
-            dotProduct.x = dot(span.rgb, pixel.rgb - endPoint[0].rgb);
-            color_index = (span_norm_sqr.x <= 0 /*endPoint[0] == endPoint[1]*/ || dotProduct.x <= 0 /*pixel == endPoint[0]*/) ? 0
-                : ((dotProduct.x < span_norm_sqr.x) ? aStep[indexPrec.x][uint(dotProduct.x * 63.49999 / span_norm_sqr.x)] : aStep[indexPrec.x][63]);
-            dotProduct.y = dot(span.a, pixel.a - endPoint[0].a);
-            alpha_index = (span_norm_sqr.y <= 0 || dotProduct.y <= 0) ? 0
-                : ((dotProduct.y < span_norm_sqr.y) ? aStep[indexPrec.y][uint(dotProduct.y * 63.49999 / span_norm_sqr.y)] : aStep[indexPrec.y][63]);
-
-            // the same color_index and alpha_index should be used for reconstruction, so this should be left commented out
-            /*if (index_selector)
-            {
-                swap(color_index, alpha_index);
-            }*/
-
-            pixel_r.rgb = ((64 - aWeight[indexPrec.x][color_index]) * endPoint[0].rgb +
-                aWeight[indexPrec.x][color_index] * endPoint[1].rgb +
-                32) >> 6;
-            pixel_r.a = ((64 - aWeight[indexPrec.y][alpha_index]) * endPoint[0].a +
-                aWeight[indexPrec.y][alpha_index] * endPoint[1].a +
-                32) >> 6;
-
-            Ensure_A_Is_Larger(pixel_r, pixel);
-            pixel_r -= pixel;
-            if (1 == rotation)
-            {
-                pixel_r.ra = pixel_r.ar;
-            }
-            else if (2 == rotation)
-            {
-                pixel_r.ga = pixel_r.ag;
-            }
-            else if (3 == rotation)
-            {
-                pixel_r.ba = pixel_r.ab;
-            }
-            error += ComputeError(pixel_r, pixel_r);
-        }
-    }
-    else if (threadInBlock < 16) // Try mode 6 in threads 12..15, since in mode 4 5 6, only mode 6 has p bit
-    {
-        uint p = threadInBlock - 12;
-
-        compress_endpoints6(endPoint, uint2(p >> 0, p >> 1) & 1);
-
-        uint4 pixel = shared_temp[threadBase + 0].pixel;
-
-        span = endPoint[1] - endPoint[0];
-        span_norm_sqr = dot(span, span);
-        dotProduct = dot(span, pixel - endPoint[0]);
-        if (span_norm_sqr.x > 0 && dotProduct.x >= 0 && uint(dotProduct.x * 63.49999) > uint(32 * span_norm_sqr.x))
-        {
-            span = -span;
-            swap(endPoint[0], endPoint[1]);
-        }
-
-        error = 0;
-        for (uint i = 0; i < 16; i++)
-        {
-            pixel = shared_temp[threadBase + i].pixel;
-
-            dotProduct.x = dot(span, pixel - endPoint[0]);
-            color_index = (span_norm_sqr.x <= 0 || dotProduct.x <= 0) ? 0
-                : ((dotProduct.x < span_norm_sqr.x) ? aStep[0][uint(dotProduct.x * 63.49999 / span_norm_sqr.x)] : aStep[0][63]);
-
-            pixel_r = ((64 - aWeight[0][color_index]) * endPoint[0]
-                + aWeight[0][color_index] * endPoint[1] + 32) >> 6;
-
-            Ensure_A_Is_Larger(pixel_r, pixel);
-            pixel_r -= pixel;
-            error += ComputeError(pixel_r, pixel_r);
-        }
-
-        mode = 6;
-        rotation = p;    // Borrow rotation for p
-    }
-
-    shared_temp[GI].error = error;
-    shared_temp[GI].mode = mode;
-    shared_temp[GI].index_selector = index_selector;
-    shared_temp[GI].rotation = rotation;
-
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 8)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 8].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 8].error;
-            shared_temp[GI].mode = shared_temp[GI + 8].mode;
-            shared_temp[GI].index_selector = shared_temp[GI + 8].index_selector;
-            shared_temp[GI].rotation = shared_temp[GI + 8].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 4)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 4].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 4].error;
-            shared_temp[GI].mode = shared_temp[GI + 4].mode;
-            shared_temp[GI].index_selector = shared_temp[GI + 4].index_selector;
-            shared_temp[GI].rotation = shared_temp[GI + 4].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 2)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 2].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 2].error;
-            shared_temp[GI].mode = shared_temp[GI + 2].mode;
-            shared_temp[GI].index_selector = shared_temp[GI + 2].index_selector;
-            shared_temp[GI].rotation = shared_temp[GI + 2].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 1)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 1].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 1].error;
-            shared_temp[GI].mode = shared_temp[GI + 1].mode;
-            shared_temp[GI].index_selector = shared_temp[GI + 1].index_selector;
-            shared_temp[GI].rotation = shared_temp[GI + 1].rotation;
-        }
-
-        g_OutBuff[blockID] = uint4(shared_temp[GI].error, (shared_temp[GI].index_selector << 31) | shared_temp[GI].mode,
-            0, shared_temp[GI].rotation); // rotation is indeed rotation for mode 4 5. for mode 6, rotation is p bit
-    }
-}
-
-[numthreads(THREAD_GROUP_SIZE, 1, 1)]
-void TryMode137CS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID) // mode 1 3 7 all have 2 subsets per block
-{
-    const uint MAX_USED_THREAD = 64;
-    uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
-    uint blockInGroup = GI / MAX_USED_THREAD;
-    uint blockID = g_start_block_id + groupID.x * BLOCK_IN_GROUP + blockInGroup;
-    uint threadBase = blockInGroup * MAX_USED_THREAD;
-    uint threadInBlock = GI - threadBase;
-
-    uint block_y = blockID / g_num_block_x;
-    uint block_x = blockID - block_y * g_num_block_x;
-    uint base_x = block_x * BLOCK_SIZE_X;
-    uint base_y = block_y * BLOCK_SIZE_Y;
-
-    if (threadInBlock < 16)
-    {
-        shared_temp[GI].pixel = clamp(uint4(g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)) * 255), 0, 255);
-    }
-    GroupMemoryBarrierWithGroupSync();
-
-    shared_temp[GI].error = 0xFFFFFFFF;
-
-    uint4 pixel_r;
-    uint2x4 endPoint[2];        // endPoint[0..1 for subset id][0..1 for low and high in the subset]
-    uint2x4 endPointBackup[2];
-    uint color_index;
-    if (threadInBlock < 64)
-    {
-        uint partition = threadInBlock;
-
-        endPoint[0][0] = MAX_UINT;
-        endPoint[0][1] = MIN_UINT;
-        endPoint[1][0] = MAX_UINT;
-        endPoint[1][1] = MIN_UINT;
-        uint bits = candidateSectionBit[partition];
-        for (uint i = 0; i < 16; i++)
-        {
-            uint4 pixel = shared_temp[threadBase + i].pixel;
-            if (((bits >> i) & 0x01) == 1)
-            {
-                endPoint[1][0] = min(endPoint[1][0], pixel);
-                endPoint[1][1] = max(endPoint[1][1], pixel);
-            }
-            else
-            {
-                endPoint[0][0] = min(endPoint[0][0], pixel);
-                endPoint[0][1] = max(endPoint[0][1], pixel);
-            }
-        }
-
-        endPointBackup[0] = endPoint[0];
-        endPointBackup[1] = endPoint[1];
-
-        uint max_p;
-        if (1 == g_mode_id)
-        {
-            // in mode 1, there is only one p bit per subset
-            max_p = 2;
-        }
-        else
-        {
-            // in mode 3 7, there are two p bits per subset, one for each end point
-            max_p = 4;
-        }
-
-        uint final_p[2] = { 0, 0 };
-        uint error[2] = { MAX_UINT, MAX_UINT };
-        for (uint p = 0; p < max_p; p++)
-        {
-            endPoint[0] = endPointBackup[0];
-            endPoint[1] = endPointBackup[1];
-
-            for (i = 0; i < 2; i++) // loop through 2 subsets
-            {
-                if (g_mode_id == 1)
-                {
-                    compress_endpoints1(endPoint[i], p);
-                }
-                else if (g_mode_id == 3)
-                {
-                    compress_endpoints3(endPoint[i], uint2(p, p >> 1) & 1);
-                }
-                else if (g_mode_id == 7)
-                {
-                    compress_endpoints7(endPoint[i], uint2(p, p >> 1) & 1);
-                }
-            }
-
-            int4 span[2];
-            span[0] = endPoint[0][1] - endPoint[0][0];
-            span[1] = endPoint[1][1] - endPoint[1][0];
-
-            if (g_mode_id != 7)
-            {
-                span[0].w = span[1].w = 0;
-            }
-
-            int span_norm_sqr[2];
-            span_norm_sqr[0] = dot(span[0], span[0]);
-            span_norm_sqr[1] = dot(span[1], span[1]);
-
-            // TODO: again, this shouldn't be necessary here in error calculation
-            int dotProduct = dot(span[0], shared_temp[threadBase + 0].pixel - endPoint[0][0]);
-            if (span_norm_sqr[0] > 0 && dotProduct > 0 && uint(dotProduct * 63.49999) > uint(32 * span_norm_sqr[0]))
-            {
-                span[0] = -span[0];
-                swap(endPoint[0][0], endPoint[0][1]);
-            }
-            dotProduct = dot(span[1], shared_temp[threadBase + candidateFixUpIndex1D[partition].x].pixel - endPoint[1][0]);
-            if (span_norm_sqr[1] > 0 && dotProduct > 0 && uint(dotProduct * 63.49999) > uint(32 * span_norm_sqr[1]))
-            {
-                span[1] = -span[1];
-                swap(endPoint[1][0], endPoint[1][1]);
-            }
-
-            uint step_selector;
-            if (g_mode_id != 1)
-            {
-                step_selector = 2;  // mode 3 7 have 2 bit index
-            }
-            else
-            {
-                step_selector = 1;  // mode 1 has 3 bit index
-            }
-
-            uint p_error[2] = { 0, 0 };
-            for (i = 0; i < 16; i++)
-            {
-                uint subset_index = (bits >> i) & 0x01;
-
-                if (subset_index == 1)
-                {
-                    dotProduct = dot(span[1], shared_temp[threadBase + i].pixel - endPoint[1][0]);
-                    color_index = (span_norm_sqr[1] <= 0 || dotProduct <= 0) ? 0
-                        : ((dotProduct < span_norm_sqr[1]) ? aStep[step_selector][uint(dotProduct * 63.49999 / span_norm_sqr[1])] : aStep[step_selector][63]);
-                }
-                else
-                {
-                    dotProduct = dot(span[0], shared_temp[threadBase + i].pixel - endPoint[0][0]);
-                    color_index = (span_norm_sqr[0] <= 0 || dotProduct <= 0) ? 0
-                        : ((dotProduct < span_norm_sqr[0]) ? aStep[step_selector][uint(dotProduct * 63.49999 / span_norm_sqr[0])] : aStep[step_selector][63]);
-                }
-
-                pixel_r = ((64 - aWeight[step_selector][color_index]) * endPoint[subset_index][0]
-                    + aWeight[step_selector][color_index] * endPoint[subset_index][1] + 32) >> 6;
-                if (g_mode_id != 7)
-                {
-                    pixel_r.a = 255;
-                }
-
-                uint4 pixel = shared_temp[threadBase + i].pixel;
-                Ensure_A_Is_Larger(pixel_r, pixel);
-                pixel_r -= pixel;
-                uint pixel_error = ComputeError(pixel_r, pixel_r);
-                if (subset_index == 1)
-                    p_error[1] += pixel_error;
-                else
-                    p_error[0] += pixel_error;
-            }
-
-            for (i = 0; i < 2; i++)
-            {
-                if (p_error[i] < error[i])
-                {
-                    error[i] = p_error[i];
-                    final_p[i] = p;
-                }
-            }
-        }
-
-        shared_temp[GI].error = error[0] + error[1];
-        shared_temp[GI].mode = g_mode_id;
-        shared_temp[GI].partition = partition;
-
-        // mode 1 3 7 don't have rotation, we use rotation for p bits
-        if (g_mode_id == 1)
-            shared_temp[GI].rotation = (final_p[1] << 1) | final_p[0];
-        else
-            shared_temp[GI].rotation = (final_p[1] << 2) | final_p[0];
-    }
-    GroupMemoryBarrierWithGroupSync();
-
-    if (threadInBlock < 32)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 32].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 32].error;
-            shared_temp[GI].mode = shared_temp[GI + 32].mode;
-            shared_temp[GI].partition = shared_temp[GI + 32].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 32].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 16)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 16].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 16].error;
-            shared_temp[GI].mode = shared_temp[GI + 16].mode;
-            shared_temp[GI].partition = shared_temp[GI + 16].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 16].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 8)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 8].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 8].error;
-            shared_temp[GI].mode = shared_temp[GI + 8].mode;
-            shared_temp[GI].partition = shared_temp[GI + 8].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 8].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 4)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 4].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 4].error;
-            shared_temp[GI].mode = shared_temp[GI + 4].mode;
-            shared_temp[GI].partition = shared_temp[GI + 4].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 4].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 2)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 2].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 2].error;
-            shared_temp[GI].mode = shared_temp[GI + 2].mode;
-            shared_temp[GI].partition = shared_temp[GI + 2].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 2].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 1)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 1].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 1].error;
-            shared_temp[GI].mode = shared_temp[GI + 1].mode;
-            shared_temp[GI].partition = shared_temp[GI + 1].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 1].rotation;
-        }
-
-        if (g_InBuff[blockID].x > shared_temp[GI].error)
-        {
-            g_OutBuff[blockID] = uint4(shared_temp[GI].error, shared_temp[GI].mode, shared_temp[GI].partition, shared_temp[GI].rotation); // mode 1 3 7 don't have rotation, we use rotation for p bits
-        }
-        else
-        {
-            g_OutBuff[blockID] = g_InBuff[blockID];
-        }
-    }
-}
-
-[numthreads(THREAD_GROUP_SIZE, 1, 1)]
-void TryMode02CS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID) // mode 0 2 have 3 subsets per block
-{
-    const uint MAX_USED_THREAD = 64;
-    uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
-    uint blockInGroup = GI / MAX_USED_THREAD;
-    uint blockID = g_start_block_id + groupID.x * BLOCK_IN_GROUP + blockInGroup;
-    uint threadBase = blockInGroup * MAX_USED_THREAD;
-    uint threadInBlock = GI - threadBase;
-
-    uint block_y = blockID / g_num_block_x;
-    uint block_x = blockID - block_y * g_num_block_x;
-    uint base_x = block_x * BLOCK_SIZE_X;
-    uint base_y = block_y * BLOCK_SIZE_Y;
-
-    if (threadInBlock < 16)
-    {
-        shared_temp[GI].pixel = clamp(uint4(g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)) * 255), 0, 255);
-    }
-    GroupMemoryBarrierWithGroupSync();
-
-    shared_temp[GI].error = 0xFFFFFFFF;
-
-    uint num_partitions;
-    if (0 == g_mode_id)
-    {
-        num_partitions = 16;
-    }
-    else
-    {
-        num_partitions = 64;
-    }
-
-    uint4 pixel_r;
-    uint2x4 endPoint[3];        // endPoint[0..1 for subset id][0..1 for low and high in the subset]
-    uint2x4 endPointBackup[3];
-    uint color_index[16];
-    if (threadInBlock < num_partitions)
-    {
-        uint partition = threadInBlock + 64;
-
-        endPoint[0][0] = MAX_UINT;
-        endPoint[0][1] = MIN_UINT;
-        endPoint[1][0] = MAX_UINT;
-        endPoint[1][1] = MIN_UINT;
-        endPoint[2][0] = MAX_UINT;
-        endPoint[2][1] = MIN_UINT;
-        uint bits2 = candidateSectionBit2[partition - 64];
-        for (uint i = 0; i < 16; i++)
-        {
-            uint4 pixel = shared_temp[threadBase + i].pixel;
-            uint subset_index = (bits2 >> (i * 2)) & 0x03;
-            if (subset_index == 2)
-            {
-                endPoint[2][0] = min(endPoint[2][0], pixel);
-                endPoint[2][1] = max(endPoint[2][1], pixel);
-            }
-            else if (subset_index == 1)
-            {
-                endPoint[1][0] = min(endPoint[1][0], pixel);
-                endPoint[1][1] = max(endPoint[1][1], pixel);
-            }
-            else
-            {
-                endPoint[0][0] = min(endPoint[0][0], pixel);
-                endPoint[0][1] = max(endPoint[0][1], pixel);
-            }
-        }
-
-        endPointBackup[0] = endPoint[0];
-        endPointBackup[1] = endPoint[1];
-        endPointBackup[2] = endPoint[2];
-
-        uint max_p;
-        if (0 == g_mode_id)
-        {
-            max_p = 4;
-        }
-        else
-        {
-            max_p = 1;
-        }
-
-        uint final_p[3] = { 0, 0, 0 };
-        uint error[3] = { MAX_UINT, MAX_UINT, MAX_UINT };
-        for (uint p = 0; p < max_p; p++)
-        {
-            endPoint[0] = endPointBackup[0];
-            endPoint[1] = endPointBackup[1];
-            endPoint[2] = endPointBackup[2];
-
-            for (i = 0; i < 3; i++)
-            {
-                if (0 == g_mode_id)
-                {
-                    compress_endpoints0(endPoint[i], uint2(p, p >> 1) & 1);
-                }
-                else
-                {
-                    compress_endpoints2(endPoint[i]);
-                }
-            }
-
-            uint step_selector = 1 + (2 == g_mode_id);
-
-            int4 span[3];
-            span[0] = endPoint[0][1] - endPoint[0][0];
-            span[1] = endPoint[1][1] - endPoint[1][0];
-            span[2] = endPoint[2][1] - endPoint[2][0];
-            span[0].w = span[1].w = span[2].w = 0;
-            int span_norm_sqr[3];
-            span_norm_sqr[0] = dot(span[0], span[0]);
-            span_norm_sqr[1] = dot(span[1], span[1]);
-            span_norm_sqr[2] = dot(span[2], span[2]);
-
-            // TODO: again, this shouldn't be necessary here in error calculation
-            uint ci[3] = { 0, candidateFixUpIndex1D[partition].x, candidateFixUpIndex1D[partition].y };
-            for (i = 0; i < 3; i++)
-            {
-                int dotProduct = dot(span[i], shared_temp[threadBase + ci[i]].pixel - endPoint[i][0]);
-                if (span_norm_sqr[i] > 0 && dotProduct > 0 && uint(dotProduct * 63.49999) > uint(32 * span_norm_sqr[i]))
-                {
-                    span[i] = -span[i];
-                    swap(endPoint[i][0], endPoint[i][1]);
-                }
-            }
-
-            uint p_error[3] = { 0, 0, 0 };
-            for (i = 0; i < 16; i++)
-            {
-                uint subset_index = (bits2 >> (i * 2)) & 0x03;
-                if (subset_index == 2)
-                {
-                    int dotProduct = dot(span[2], shared_temp[threadBase + i].pixel - endPoint[2][0]);
-                    color_index[i] = (span_norm_sqr[2] <= 0 || dotProduct <= 0) ? 0
-                        : ((dotProduct < span_norm_sqr[2]) ? aStep[step_selector][uint(dotProduct * 63.49999 / span_norm_sqr[2])] : aStep[step_selector][63]);
-                }
-                else if (subset_index == 1)
-                {
-                    int dotProduct = dot(span[1], shared_temp[threadBase + i].pixel - endPoint[1][0]);
-                    color_index[i] = (span_norm_sqr[1] <= 0 || dotProduct <= 0) ? 0
-                        : ((dotProduct < span_norm_sqr[1]) ? aStep[step_selector][uint(dotProduct * 63.49999 / span_norm_sqr[1])] : aStep[step_selector][63]);
-                }
-                else
-                {
-                    int dotProduct = dot(span[0], shared_temp[threadBase + i].pixel - endPoint[0][0]);
-                    color_index[i] = (span_norm_sqr[0] <= 0 || dotProduct <= 0) ? 0
-                        : ((dotProduct < span_norm_sqr[0]) ? aStep[step_selector][uint(dotProduct * 63.49999 / span_norm_sqr[0])] : aStep[step_selector][63]);
-                }
-
-                pixel_r = ((64 - aWeight[step_selector][color_index[i]]) * endPoint[subset_index][0]
-                    + aWeight[step_selector][color_index[i]] * endPoint[subset_index][1] + 32) >> 6;
-                pixel_r.a = 255;
-
-                uint4 pixel = shared_temp[threadBase + i].pixel;
-                Ensure_A_Is_Larger(pixel_r, pixel);
-                pixel_r -= pixel;
-
-                uint pixel_error = ComputeError(pixel_r, pixel_r);
-
-                if (subset_index == 2)
-                    p_error[2] += pixel_error;
-                else if (subset_index == 1)
-                    p_error[1] += pixel_error;
-                else
-                    p_error[0] += pixel_error;
-            }
-
-            for (i = 0; i < 3; i++)
-            {
-                if (p_error[i] < error[i])
-                {
-                    error[i] = p_error[i];
-                    final_p[i] = p;    // Borrow rotation for p
-                }
-            }
-        }
-
-        shared_temp[GI].error = error[0] + error[1] + error[2];
-        shared_temp[GI].partition = partition;
-        shared_temp[GI].rotation = (final_p[2] << 4) | (final_p[1] << 2) | final_p[0];
-    }
-    GroupMemoryBarrierWithGroupSync();
-
-    if (threadInBlock < 32)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 32].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 32].error;
-            shared_temp[GI].partition = shared_temp[GI + 32].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 32].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 16)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 16].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 16].error;
-            shared_temp[GI].partition = shared_temp[GI + 16].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 16].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 8)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 8].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 8].error;
-            shared_temp[GI].partition = shared_temp[GI + 8].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 8].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 4)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 4].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 4].error;
-            shared_temp[GI].partition = shared_temp[GI + 4].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 4].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 2)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 2].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 2].error;
-            shared_temp[GI].partition = shared_temp[GI + 2].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 2].rotation;
-        }
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-    if (threadInBlock < 1)
-    {
-        if (shared_temp[GI].error > shared_temp[GI + 1].error)
-        {
-            shared_temp[GI].error = shared_temp[GI + 1].error;
-            shared_temp[GI].partition = shared_temp[GI + 1].partition;
-            shared_temp[GI].rotation = shared_temp[GI + 1].rotation;
-        }
-
-        if (g_InBuff[blockID].x > shared_temp[GI].error)
-        {
-            g_OutBuff[blockID] = uint4(shared_temp[GI].error, g_mode_id, shared_temp[GI].partition, shared_temp[GI].rotation); // rotation is actually p bit for mode 0. for mode 2, rotation is always 0
-        }
-        else
-        {
-            g_OutBuff[blockID] = g_InBuff[blockID];
-        }
-    }
-}
-
-[numthreads(THREAD_GROUP_SIZE, 1, 1)]
-void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
-{
-    const uint MAX_USED_THREAD = 16;
-    uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
-    uint blockInGroup = GI / MAX_USED_THREAD;
-    uint blockID = g_start_block_id + groupID.x * BLOCK_IN_GROUP + blockInGroup;
-    uint threadBase = blockInGroup * MAX_USED_THREAD;
-    uint threadInBlock = GI - threadBase;
-
-#ifndef REF_DEVICE
-    if (blockID >= g_num_total_blocks)
-    {
-        return;
-    }
-#endif
-
-    uint block_y = blockID / g_num_block_x;
-    uint block_x = blockID - block_y * g_num_block_x;
-    uint base_x = block_x * BLOCK_SIZE_X;
-    uint base_y = block_y * BLOCK_SIZE_Y;
-
-    uint mode = g_InBuff[blockID].y & 0x7FFFFFFF;
-    uint partition = g_InBuff[blockID].z;
-    uint index_selector = (g_InBuff[blockID].y >> 31) & 1;
-    uint rotation = g_InBuff[blockID].w;
-
-    if (threadInBlock < 16)
-    {
-        uint4 pixel = clamp(uint4(g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)) * 255), 0, 255);
-
-        if ((4 == mode) || (5 == mode))
-        {
-            if (1 == rotation)
-            {
-                pixel.ra = pixel.ar;
-            }
-            else if (2 == rotation)
-            {
-                pixel.ga = pixel.ag;
-            }
-            else if (3 == rotation)
-            {
-                pixel.ba = pixel.ab;
-            }
-        }
-
-        shared_temp[GI].pixel = pixel;
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    uint bits = candidateSectionBit[partition];
-    uint bits2 = candidateSectionBit2[partition - 64];
-
-    uint2x4 ep;
-    ep[0] = MAX_UINT;
-    ep[1] = MIN_UINT;
-    uint2x4 ep_quantized;
-    [unroll]
-    for (int ii = 2; ii >= 0; --ii)
-    {
-        if (threadInBlock < 16)
-        {
-            uint2x4 ep;
-            ep[0] = MAX_UINT;
-            ep[1] = MIN_UINT;
-
-            uint4 pixel = shared_temp[GI].pixel;
-
-            uint subset_index = (bits >> threadInBlock) & 0x01;
-            uint subset_index2 = (bits2 >> (threadInBlock * 2)) & 0x03;
-            if (0 == ii)
-            {
-                if ((0 == mode) || (2 == mode))
-                {
-                    if (0 == subset_index2)
-                    {
-                        ep[0] = ep[1] = pixel;
-                    }
-                }
-                else if ((1 == mode) || (3 == mode) || (7 == mode))
-                {
-                    if (0 == subset_index)
-                    {
-                        ep[0] = ep[1] = pixel;
-                    }
-                }
-                else if ((4 == mode) || (5 == mode) || (6 == mode))
-                {
-                    ep[0] = ep[1] = pixel;
-                }
-            }
-            else if (1 == ii)
-            {
-                if ((0 == mode) || (2 == mode))
-                {
-                    if (1 == subset_index2)
-                    {
-                        ep[0] = ep[1] = pixel;
-                    }
-                }
-                else if ((1 == mode) || (3 == mode) || (7 == mode))
-                {
-                    if (1 == subset_index)
-                    {
-                        ep[0] = ep[1] = pixel;
-                    }
-                }
-            }
-            else
-            {
-                if ((0 == mode) || (2 == mode))
-                {
-                    if (2 == subset_index2)
-                    {
-                        ep[0] = ep[1] = pixel;
-                    }
-                }
-            }
-
-            shared_temp[GI].endPoint_low = ep[0];
-            shared_temp[GI].endPoint_high = ep[1];
-        }
-#ifdef REF_DEVICE
-        GroupMemoryBarrierWithGroupSync();
-#endif
-
-        if (threadInBlock < 8)
-        {
-            shared_temp[GI].endPoint_low = min(shared_temp[GI].endPoint_low, shared_temp[GI + 8].endPoint_low);
-            shared_temp[GI].endPoint_high = max(shared_temp[GI].endPoint_high, shared_temp[GI + 8].endPoint_high);
-        }
-#ifdef REF_DEVICE
-        GroupMemoryBarrierWithGroupSync();
-#endif
-        if (threadInBlock < 4)
-        {
-            shared_temp[GI].endPoint_low = min(shared_temp[GI].endPoint_low, shared_temp[GI + 4].endPoint_low);
-            shared_temp[GI].endPoint_high = max(shared_temp[GI].endPoint_high, shared_temp[GI + 4].endPoint_high);
-        }
-#ifdef REF_DEVICE
-        GroupMemoryBarrierWithGroupSync();
-#endif
-        if (threadInBlock < 2)
-        {
-            shared_temp[GI].endPoint_low = min(shared_temp[GI].endPoint_low, shared_temp[GI + 2].endPoint_low);
-            shared_temp[GI].endPoint_high = max(shared_temp[GI].endPoint_high, shared_temp[GI + 2].endPoint_high);
-        }
-#ifdef REF_DEVICE
-        GroupMemoryBarrierWithGroupSync();
-#endif
-        if (threadInBlock < 1)
-        {
-            shared_temp[GI].endPoint_low = min(shared_temp[GI].endPoint_low, shared_temp[GI + 1].endPoint_low);
-            shared_temp[GI].endPoint_high = max(shared_temp[GI].endPoint_high, shared_temp[GI + 1].endPoint_high);
-        }
-#ifdef REF_DEVICE
-        GroupMemoryBarrierWithGroupSync();
-#endif
-
-        if (ii == (int)threadInBlock)
-        {
-            ep[0] = shared_temp[threadBase].endPoint_low;
-            ep[1] = shared_temp[threadBase].endPoint_high;
-        }
-    }
-
-    if (threadInBlock < 3)
-    {
-        uint2 P;
-        if (1 == mode)
-        {
-            P = (rotation >> threadInBlock) & 1;
-        }
-        else
-        {
-            P = uint2(rotation >> (threadInBlock * 2 + 0), rotation >> (threadInBlock * 2 + 1)) & 1;
-        }
-
-        if (0 == mode)
-        {
-            ep_quantized = compress_endpoints0(ep, P);
-        }
-        else if (1 == mode)
-        {
-            ep_quantized = compress_endpoints1(ep, P);
-        }
-        else if (2 == mode)
-        {
-            ep_quantized = compress_endpoints2(ep);
-        }
-        else if (3 == mode)
-        {
-            ep_quantized = compress_endpoints3(ep, P);
-        }
-        else if (4 == mode)
-        {
-            ep_quantized = compress_endpoints4(ep);
-        }
-        else if (5 == mode)
-        {
-            ep_quantized = compress_endpoints5(ep);
-        }
-        else if (6 == mode)
-        {
-            ep_quantized = compress_endpoints6(ep, P);
-        }
-        else //if (7 == mode)
-        {
-            ep_quantized = compress_endpoints7(ep, P);
-        }
-
-        int4 span = ep[1] - ep[0];
-        if (mode < 4)
-        {
-            span.w = 0;
-        }
-
-        if ((4 == mode) || (5 == mode))
-        {
-            if (0 == threadInBlock)
-            {
-                int2 span_norm_sqr = uint2(dot(span.rgb, span.rgb), span.a * span.a);
-                int2 dotProduct = int2(dot(span.rgb, shared_temp[threadBase + 0].pixel.rgb - ep[0].rgb), span.a * (shared_temp[threadBase + 0].pixel.a - ep[0].a));
-                if (span_norm_sqr.x > 0 && dotProduct.x > 0 && uint(dotProduct.x * 63.49999) > uint(32 * span_norm_sqr.x))
-                {
-                    swap(ep[0].rgb, ep[1].rgb);
-                    swap(ep_quantized[0].rgb, ep_quantized[1].rgb);
-                }
-                if (span_norm_sqr.y > 0 && dotProduct.y > 0 && uint(dotProduct.y * 63.49999) > uint(32 * span_norm_sqr.y))
-                {
-                    swap(ep[0].a, ep[1].a);
-                    swap(ep_quantized[0].a, ep_quantized[1].a);
-                }
-            }
-        }
-        else //if ((0 == mode) || (2 == mode) || (1 == mode) || (3 == mode) || (7 == mode) || (6 == mode))
-        {
-            int p;
-            if (0 == threadInBlock)
-            {
-                p = 0;
-            }
-            else if (1 == threadInBlock)
-            {
-                p = candidateFixUpIndex1D[partition].x;
-            }
-            else //if (2 == threadInBlock)
-            {
-                p = candidateFixUpIndex1D[partition].y;
-            }
-
-            int span_norm_sqr = dot(span, span);
-            int dotProduct = dot(span, shared_temp[threadBase + p].pixel - ep[0]);
-            if (span_norm_sqr > 0 && dotProduct > 0 && uint(dotProduct * 63.49999) > uint(32 * span_norm_sqr))
-            {
-                swap(ep[0], ep[1]);
-                swap(ep_quantized[0], ep_quantized[1]);
-            }
-        }
-
-        shared_temp[GI].endPoint_low = ep[0];
-        shared_temp[GI].endPoint_high = ep[1];
-        shared_temp[GI].endPoint_low_quantized = ep_quantized[0];
-        shared_temp[GI].endPoint_high_quantized = ep_quantized[1];
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (threadInBlock < 16)
-    {
-        uint color_index = 0;
-        uint alpha_index = 0;
-
-        uint2x4 ep;
-
-        uint2 indexPrec;
-        if ((0 == mode) || (1 == mode))
-        {
-            indexPrec = 1;
-        }
-        else if (6 == mode)
-        {
-            indexPrec = 0;
-        }
-        else if (4 == mode)
-        {
-            if (0 == index_selector)
-            {
-                indexPrec = uint2(2, 1);
-            }
-            else
-            {
-                indexPrec = uint2(1, 2);
-            }
-        }
-        else
-        {
-            indexPrec = 2;
-        }
-
-        int subset_index;
-        if ((0 == mode) || (2 == mode))
-        {
-            subset_index = (bits2 >> (threadInBlock * 2)) & 0x03;
-        }
-        else if ((1 == mode) || (3 == mode) || (7 == mode))
-        {
-            subset_index = (bits >> threadInBlock) & 0x01;
-        }
-        else
-        {
-            subset_index = 0;
-        }
-
-        ep[0] = shared_temp[threadBase + subset_index].endPoint_low;
-        ep[1] = shared_temp[threadBase + subset_index].endPoint_high;
-
-        int4 span = ep[1] - ep[0];
-        if (mode < 4)
-        {
-            span.w = 0;
-        }
-
-        if ((4 == mode) || (5 == mode))
-        {
-            int2 span_norm_sqr;
-            span_norm_sqr.x = dot(span.rgb, span.rgb);
-            span_norm_sqr.y = span.a * span.a;
-
-            int dotProduct = dot(span.rgb, shared_temp[threadBase + threadInBlock].pixel.rgb - ep[0].rgb);
-            color_index = (span_norm_sqr.x <= 0 || dotProduct <= 0) ? 0
-                : ((dotProduct < span_norm_sqr.x) ? aStep[indexPrec.x][uint(dotProduct * 63.49999 / span_norm_sqr.x)] : aStep[indexPrec.x][63]);
-            dotProduct = dot(span.a, shared_temp[threadBase + threadInBlock].pixel.a - ep[0].a);
-            alpha_index = (span_norm_sqr.y <= 0 || dotProduct <= 0) ? 0
-                : ((dotProduct < span_norm_sqr.y) ? aStep[indexPrec.y][uint(dotProduct * 63.49999 / span_norm_sqr.y)] : aStep[indexPrec.y][63]);
-
-            if (index_selector)
-            {
-                swap(color_index, alpha_index);
-            }
-        }
-        else
-        {
-            int span_norm_sqr = dot(span, span);
-
-            int dotProduct = dot(span, shared_temp[threadBase + threadInBlock].pixel - ep[0]);
-            color_index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
-                : ((dotProduct < span_norm_sqr) ? aStep[indexPrec.x][uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep[indexPrec.x][63]);
-        }
-
-        shared_temp[GI].error = color_index;
-        shared_temp[GI].mode = alpha_index;
-    }
-#ifdef REF_DEVICE
-    GroupMemoryBarrierWithGroupSync();
-#endif
-
-    if (0 == threadInBlock)
-    {
-        uint4 block;
-        if (0 == mode)
-        {
-            block_package0(block, partition, threadBase);
-        }
-        else if (1 == mode)
-        {
-            block_package1(block, partition, threadBase);
-        }
-        else if (2 == mode)
-        {
-            block_package2(block, partition, threadBase);
-        }
-        else if (3 == mode)
-        {
-            block_package3(block, partition, threadBase);
-        }
-        else if (4 == mode)
-        {
-            block_package4(block, rotation, index_selector, threadBase);
-        }
-        else if (5 == mode)
-        {
-            block_package5(block, rotation, threadBase);
-        }
-        else if (6 == mode)
-        {
-            block_package6(block, threadBase);
-        }
-        else //if (7 == mode)
-        {
-            block_package7(block, partition, threadBase);
-        }
-
-        g_OutBuff[blockID] = block;
-    }
-}
-
-//uint4 truncate_and_round( uint4 color, uint bits)
-//{
-//    uint precisionMask = ((1 << bits) - 1) << (8 - bits);
-//    uint precisionHalf = (1 << (7-bits));
-//
-//    uint4 truncated = color & precisionMask; 
-//    uint4 rounded = min(255, color + precisionHalf) & precisionMask;
-//    
-//    uint4 truncated_bak = truncated = truncated | (truncated >> bits);
-//    uint4 rounded_bak = rounded = rounded | (rounded >> bits);
-//
-//    uint4 color_bak = color;
-//    
-//    Ensure_A_Is_Larger( rounded, color );
-//    Ensure_A_Is_Larger( truncated, color_bak );
-//
-//    if (dot(rounded - color, rounded - color) < 
-//        dot(truncated - color_bak, truncated - color_bak))
-//    {
-//        return rounded_bak;
-//    }
-//    else
-//    {
-//        return truncated_bak;
-//    }
-//}
-
-uint4 quantize(uint4 color, uint uPrec)
-{
-    return (((color << 8) + color) * ((1 << uPrec) - 1) + 32768) >> 16;
-}
-
-uint4 unquantize(uint4 color, uint uPrec)
-{
-    color = color << (8 - uPrec);
-    return color | (color >> uPrec);
-}
-
-uint2x4 compress_endpoints0(inout uint2x4 endPoint, uint2 P)
-{
-    uint2x4 quantized;
-    [unroll] for (uint j = 0; j < 2; j++)
-    {
-        quantized[j].rgb = quantize(endPoint[j].rgbb, 5).rgb & 0xFFFFFFFE;
-        quantized[j].rgb |= P[j];
-        quantized[j].a = 0xFF;
-
-        endPoint[j].rgb = unquantize(quantized[j].rgbb, 5).rgb;
-        endPoint[j].a = 0xFF;
-
-        quantized[j] <<= 3;
-    }
-    return quantized;
-}
-uint2x4 compress_endpoints1(inout uint2x4 endPoint, uint2 P)
-{
-    uint2x4 quantized;
-    [unroll] for (uint j = 0; j < 2; j++)
-    {
-        quantized[j].rgb = quantize(endPoint[j].rgbb, 7).rgb & 0xFFFFFFFE;
-        quantized[j].rgb |= P[j];
-        quantized[j].a = 0xFF;
-
-        endPoint[j].rgb = unquantize(quantized[j].rgbb, 7).rgb;
-        endPoint[j].a = 0xFF;
-
-        quantized[j] <<= 1;
-    }
-    return quantized;
-}
-uint2x4 compress_endpoints2(inout uint2x4 endPoint)
-{
-    uint2x4 quantized;
-    [unroll] for (uint j = 0; j < 2; j++)
-    {
-        quantized[j].rgb = quantize(endPoint[j].rgbb, 5).rgb;
-        quantized[j].a = 0xFF;
-
-        endPoint[j].rgb = unquantize(quantized[j].rgbb, 5).rgb;
-        endPoint[j].a = 0xFF;
-
-        quantized[j] <<= 3;
-    }
-    return quantized;
-}
-uint2x4 compress_endpoints3(inout uint2x4 endPoint, uint2 P)
-{
-    uint2x4 quantized;
-    for (uint j = 0; j < 2; j++)
-    {
-        quantized[j].rgb = endPoint[j].rgb & 0xFFFFFFFE;
-        quantized[j].rgb |= P[j];
-        quantized[j].a = 0xFF;
-
-        endPoint[j].rgb = quantized[j].rgb;
-        endPoint[j].a = 0xFF;
-    }
-    return quantized;
-}
-uint2x4 compress_endpoints4(inout uint2x4 endPoint)
-{
-    uint2x4 quantized;
-    [unroll] for (uint j = 0; j < 2; j++)
-    {
-        quantized[j].rgb = quantize(endPoint[j].rgbb, 5).rgb;
-        quantized[j].a = quantize(endPoint[j].a, 6).r;
-
-        endPoint[j].rgb = unquantize(quantized[j].rgbb, 5).rgb;
-        endPoint[j].a = unquantize(quantized[j].a, 6).r;
-
-        quantized[j].rgb <<= 3;
-        quantized[j].a <<= 2;
-    }
-    return quantized;
-}
-uint2x4 compress_endpoints5(inout uint2x4 endPoint)
-{
-    uint2x4 quantized;
-    [unroll] for (uint j = 0; j < 2; j++)
-    {
-        quantized[j].rgb = quantize(endPoint[j].rgbb, 7).rgb;
-        quantized[j].a = endPoint[j].a;
-
-        endPoint[j].rgb = unquantize(quantized[j].rgbb, 7).rgb;
-        // endPoint[j].a   Alpha is full precision
-
-        quantized[j].rgb <<= 1;
-    }
-    return quantized;
-}
-uint2x4 compress_endpoints6(inout uint2x4 endPoint, uint2 P)
-{
-    uint2x4 quantized;
-    for (uint j = 0; j < 2; j++)
-    {
-        quantized[j] = endPoint[j] & 0xFFFFFFFE;
-        quantized[j] |= P[j];
-
-        endPoint[j] = quantized[j];
-    }
-    return quantized;
-}
-uint2x4 compress_endpoints7(inout uint2x4 endPoint, uint2 P)
-{
-    uint2x4 quantized;
-    [unroll] for (uint j = 0; j < 2; j++)
-    {
-        quantized[j] = quantize(endPoint[j], 6) & 0xFFFFFFFE;
-        quantized[j] |= P[j];
-
-        endPoint[j] = unquantize(quantized[j], 6);
-    }
-    return quantized << 2;
-}
-
-#define get_end_point_l(subset) shared_temp[threadBase + subset].endPoint_low_quantized
-#define get_end_point_h(subset) shared_temp[threadBase + subset].endPoint_high_quantized
-#define get_color_index(index) shared_temp[threadBase + index].error
-#define get_alpha_index(index) shared_temp[threadBase + index].mode
-
-void block_package0(out uint4 block, uint partition, uint threadBase)
-{
-    block.x = 0x01 | ((partition - 64) << 1)
-        | ((get_end_point_l(0).r & 0xF0) <<  1) | ((get_end_point_h(0).r & 0xF0) <<  5)
-        | ((get_end_point_l(1).r & 0xF0) <<  9) | ((get_end_point_h(1).r & 0xF0) << 13)
-        | ((get_end_point_l(2).r & 0xF0) << 17) | ((get_end_point_h(2).r & 0xF0) << 21)
-        | ((get_end_point_l(0).g & 0xF0) << 25);
-    block.y = ((get_end_point_l(0).g & 0xF0) >>  7) | ((get_end_point_h(0).g & 0xF0) >>  3)
-        | ((get_end_point_l(1).g & 0xF0) <<  1) | ((get_end_point_h(1).g & 0xF0) <<  5)
-        | ((get_end_point_l(2).g & 0xF0) <<  9) | ((get_end_point_h(2).g & 0xF0) << 13)
-        | ((get_end_point_l(0).b & 0xF0) << 17) | ((get_end_point_h(0).b & 0xF0) << 21)
-        | ((get_end_point_l(1).b & 0xF0) << 25);
-    block.z = ((get_end_point_l(1).b & 0xF0) >>  7) | ((get_end_point_h(1).b & 0xF0) >>  3)
-        | ((get_end_point_l(2).b & 0xF0) <<  1) | ((get_end_point_h(2).b & 0xF0) <<  5)
-        | ((get_end_point_l(0).r & 0x08) << 10) | ((get_end_point_h(0).r & 0x08) << 11)
-        | ((get_end_point_l(1).r & 0x08) << 12) | ((get_end_point_h(1).r & 0x08) << 13)
-        | ((get_end_point_l(2).r & 0x08) << 14) | ((get_end_point_h(2).r & 0x08) << 15)
-        | (get_color_index(0) << 19);
-    block.w = 0;
-    uint i = 1;
-    for (; i <= min(candidateFixUpIndex1DOrdered[partition][0], 4); i++)
-    {
-        block.z |= get_color_index(i) << (i * 3 + 18);
-    }
-    if (candidateFixUpIndex1DOrdered[partition][0] < 4) //i = 4
-    {
-        block.z |= get_color_index(4) << 29;
-        i += 1;
-    }
-    else //i = 5
-    {
-        block.w |= (get_color_index(4) & 0x04) >> 2;
-        for (; i <= candidateFixUpIndex1DOrdered[partition][0]; i++)
-            block.w |= get_color_index(i) << (i * 3 - 14);
-    }
-    for (; i <= candidateFixUpIndex1DOrdered[partition][1]; i++)
-    {
-        block.w |= get_color_index(i) << (i * 3 - 15);
-    }
-    for (; i < 16; i++)
-    {
-        block.w |= get_color_index(i) << (i * 3 - 16);
-    }
-}
-void block_package1(out uint4 block, uint partition, uint threadBase)
-{
-    block.x = 0x02 | (partition << 2)
-        | ((get_end_point_l(0).r & 0xFC) <<  6) | ((get_end_point_h(0).r & 0xFC) << 12)
-        | ((get_end_point_l(1).r & 0xFC) << 18) | ((get_end_point_h(1).r & 0xFC) << 24);
-    block.y = ((get_end_point_l(0).g & 0xFC) >>  2) | ((get_end_point_h(0).g & 0xFC) <<  4)
-        | ((get_end_point_l(1).g & 0xFC) << 10) | ((get_end_point_h(1).g & 0xFC) << 16)
-        | ((get_end_point_l(0).b & 0xFC) << 22) | ((get_end_point_h(0).b & 0xFC) << 28);
-    block.z = ((get_end_point_h(0).b & 0xFC) >>  4) | ((get_end_point_l(1).b & 0xFC) <<  2)
-        | ((get_end_point_h(1).b & 0xFC) <<  8)
-        | ((get_end_point_l(0).r & 0x02) << 15) | ((get_end_point_l(1).r & 0x02) << 16)
-        | (get_color_index(0) << 18);
-    if (candidateFixUpIndex1DOrdered[partition][0] == 15)
-    {
-        block.w = (get_color_index(15) << 30) | (get_color_index(14) << 27) | (get_color_index(13) << 24) | (get_color_index(12) << 21) | (get_color_index(11) << 18) | (get_color_index(10) << 15)
-            | (get_color_index(9) << 12) | (get_color_index(8) << 9) | (get_color_index(7) << 6) | (get_color_index(6) << 3) | get_color_index(5);
-        block.z |= (get_color_index(4) << 29) | (get_color_index(3) << 26) | (get_color_index(2) << 23) | (get_color_index(1) << 20) | (get_color_index(0) << 18);
-    }
-    else if (candidateFixUpIndex1DOrdered[partition][0] == 2)
-    {
-        block.w = (get_color_index(15) << 29) | (get_color_index(14) << 26) | (get_color_index(13) << 23) | (get_color_index(12) << 20) | (get_color_index(11) << 17) | (get_color_index(10) << 14)
-            | (get_color_index(9) << 11) | (get_color_index(8) << 8) | (get_color_index(7) << 5) | (get_color_index(6) << 2) | (get_color_index(5) >> 1);
-        block.z |= (get_color_index(5) << 31) | (get_color_index(4) << 28) | (get_color_index(3) << 25) | (get_color_index(2) << 23) | (get_color_index(1) << 20) | (get_color_index(0) << 18);
-    }
-    else if (candidateFixUpIndex1DOrdered[partition][0] == 8)
-    {
-        block.w = (get_color_index(15) << 29) | (get_color_index(14) << 26) | (get_color_index(13) << 23) | (get_color_index(12) << 20) | (get_color_index(11) << 17) | (get_color_index(10) << 14)
-            | (get_color_index(9) << 11) | (get_color_index(8) << 9) | (get_color_index(7) << 6) | (get_color_index(6) << 3) | get_color_index(5);
-        block.z |= (get_color_index(4) << 29) | (get_color_index(3) << 26) | (get_color_index(2) << 23) | (get_color_index(1) << 20) | (get_color_index(0) << 18);
-    }
-    else //candidateFixUpIndex1DOrdered[partition] == 6
-    {
-        block.w = (get_color_index(15) << 29) | (get_color_index(14) << 26) | (get_color_index(13) << 23) | (get_color_index(12) << 20) | (get_color_index(11) << 17) | (get_color_index(10) << 14)
-            | (get_color_index(9) << 11) | (get_color_index(8) << 8) | (get_color_index(7) << 5) | (get_color_index(6) << 3) | get_color_index(5);
-        block.z |= (get_color_index(4) << 29) | (get_color_index(3) << 26) | (get_color_index(2) << 23) | (get_color_index(1) << 20) | (get_color_index(0) << 18);
-    }
-}
-void block_package2(out uint4 block, uint partition, uint threadBase)
-{
-    block.x = 0x04 | ((partition - 64) << 3)
-        | ((get_end_point_l(0).r & 0xF8) <<  6) | ((get_end_point_h(0).r & 0xF8) << 11)
-        | ((get_end_point_l(1).r & 0xF8) << 16) | ((get_end_point_h(1).r & 0xF8) << 21)
-        | ((get_end_point_l(2).r & 0xF8) << 26);
-    block.y = ((get_end_point_l(2).r & 0xF8) >>  6) | ((get_end_point_h(2).r & 0xF8) >>  1)
-        | ((get_end_point_l(0).g & 0xF8) <<  4) | ((get_end_point_h(0).g & 0xF8) <<  9)
-        | ((get_end_point_l(1).g & 0xF8) << 14) | ((get_end_point_h(1).g & 0xF8) << 19)
-        | ((get_end_point_l(2).g & 0xF8) << 24);
-    block.z = ((get_end_point_h(2).g & 0xF8) >>  3) | ((get_end_point_l(0).b & 0xF8) <<  2)
-        | ((get_end_point_h(0).b & 0xF8) <<  7)	| ((get_end_point_l(1).b & 0xF8) << 12)
-        | ((get_end_point_h(1).b & 0xF8) << 17) | ((get_end_point_l(2).b & 0xF8) << 22)
-        | ((get_end_point_h(2).b & 0xF8) << 27);
-    block.w = ((get_end_point_h(2).b & 0xF8) >>  5)
-        | (get_color_index(0) << 3);
-    uint i = 1;
-    for (; i <= candidateFixUpIndex1DOrdered[partition][0]; i++)
-    {
-        block.w |= get_color_index(i) << (i * 2 + 2);
-    }
-    for (; i <= candidateFixUpIndex1DOrdered[partition][1]; i++)
-    {
-        block.w |= get_color_index(i) << (i * 2 + 1);
-    }
-    for (; i < 16; i++)
-    {
-        block.w |= get_color_index(i) << (i * 2);
-    }
-}
-void block_package3(out uint4 block, uint partition, uint threadBase)
-{
-    block.x = 0x08 | (partition << 4)
-        | ((get_end_point_l(0).r & 0xFE) <<  9) | ((get_end_point_h(0).r & 0xFE) << 16)
-        | ((get_end_point_l(1).r & 0xFE) << 23) | ((get_end_point_h(1).r & 0xFE) << 30);
-    block.y = ((get_end_point_h(1).r & 0xFE) >>  2) | ((get_end_point_l(0).g & 0xFE) <<  5)
-        | ((get_end_point_h(0).g & 0xFE) << 12) | ((get_end_point_l(1).g & 0xFE) << 19)
-        | ((get_end_point_h(1).g & 0xFE) << 26);
-    block.z = ((get_end_point_h(1).g & 0xFE) >>  6) | ((get_end_point_l(0).b & 0xFE) <<  1)
-        | ((get_end_point_h(0).b & 0xFE) <<  8) | ((get_end_point_l(1).b & 0xFE) << 15)
-        | ((get_end_point_h(1).b & 0xFE) << 22)
-        | ((get_end_point_l(0).r & 0x01) << 30) | ((get_end_point_h(0).r & 0x01) << 31);
-    block.w = ((get_end_point_l(1).r & 0x01) <<  0) | ((get_end_point_h(1).r & 0x01) <<  1)
-        | (get_color_index(0) << 2);
-    uint i = 1;
-    for (; i <= candidateFixUpIndex1DOrdered[partition][0]; i++)
-    {
-        block.w |= get_color_index(i) << (i * 2 + 1);
-    }
-    for (; i < 16; i++)
-    {
-        block.w |= get_color_index(i) << (i * 2);
-    }
-}
-void block_package4(out uint4 block, uint rotation, uint index_selector, uint threadBase)
-{
-    block.x = 0x10 | ((rotation & 3) << 5) | ((index_selector & 1) << 7)
-        | ((get_end_point_l(0).r & 0xF8) <<  5) | ((get_end_point_h(0).r & 0xF8) << 10)
-        | ((get_end_point_l(0).g & 0xF8) << 15) | ((get_end_point_h(0).g & 0xF8) << 20)
-        | ((get_end_point_l(0).b & 0xF8) << 25);
-
-    block.y = ((get_end_point_l(0).b & 0xF8) >>  7) | ((get_end_point_h(0).b & 0xF8) >>  2)
-        | ((get_end_point_l(0).a & 0xFC) <<  4) | ((get_end_point_h(0).a & 0xFC) << 10)
-        | ((get_color_index(0) & 1) << 18) | (get_color_index(1) << 19) | (get_color_index(2) << 21) | (get_color_index(3) << 23)
-        | (get_color_index(4) << 25) | (get_color_index(5) << 27) | (get_color_index(6) << 29) | (get_color_index(7) << 31);
-
-    block.z = (get_color_index(7) >>  1) | (get_color_index(8) <<  1) | (get_color_index(9) <<  3) | (get_color_index(10)<<  5)
-        | (get_color_index(11)<<  7) | (get_color_index(12)<<  9) | (get_color_index(13)<< 11) | (get_color_index(14)<< 13)
-        | (get_color_index(15)<< 15) | ((get_alpha_index(0) & 3) << 17) | (get_alpha_index(1) << 19) | (get_alpha_index(2) << 22)
-        | (get_alpha_index(3) << 25) | (get_alpha_index(4) << 28) | (get_alpha_index(5) << 31);
-
-    block.w = (get_alpha_index(5) >>  1) | (get_alpha_index(6) <<  2) | (get_alpha_index(7) <<  5) | (get_alpha_index(8) <<  8)
-        | (get_alpha_index(9) << 11) | (get_alpha_index(10)<< 14) | (get_alpha_index(11)<< 17) | (get_alpha_index(12)<< 20)
-        | (get_alpha_index(13)<< 23) | (get_alpha_index(14)<< 26) | (get_alpha_index(15)<< 29);
-}
-void block_package5(out uint4 block, uint rotation, uint threadBase)
-{
-    block.x = 0x20 | (rotation << 6)
-        | ((get_end_point_l(0).r & 0xFE) <<  7) | ((get_end_point_h(0).r & 0xFE) << 14)
-        | ((get_end_point_l(0).g & 0xFE) << 21) | ((get_end_point_h(0).g & 0xFE) << 28);
-    block.y = ((get_end_point_h(0).g & 0xFE) >>  4) | ((get_end_point_l(0).b & 0xFE) <<  3)
-        | ((get_end_point_h(0).b & 0xFE) << 10)	| (get_end_point_l(0).a << 18) | (get_end_point_h(0).a << 26);
-    block.z = (get_end_point_h(0).a >>  6)
-        | (get_color_index(0) <<  2) | (get_color_index(1) <<  3) | (get_color_index(2) <<  5) | (get_color_index(3) <<  7)
-        | (get_color_index(4) <<  9) | (get_color_index(5) << 11) | (get_color_index(6) << 13) | (get_color_index(7) << 15)
-        | (get_color_index(8) << 17) | (get_color_index(9) << 19) | (get_color_index(10)<< 21) | (get_color_index(11)<< 23)
-        | (get_color_index(12)<< 25) | (get_color_index(13)<< 27) | (get_color_index(14)<< 29) | (get_color_index(15)<< 31);
-    block.w = (get_color_index(15)>> 1) | (get_alpha_index(0) <<  1) | (get_alpha_index(1) <<  2) | (get_alpha_index(2) <<  4)
-        | (get_alpha_index(3) <<  6) | (get_alpha_index(4) <<  8) | (get_alpha_index(5) << 10) | (get_alpha_index(6) << 12)
-        | (get_alpha_index(7) << 14) | (get_alpha_index(8) << 16) | (get_alpha_index(9) << 18) | (get_alpha_index(10)<< 20)
-        | (get_alpha_index(11)<< 22) | (get_alpha_index(12)<< 24) | (get_alpha_index(13)<< 26) | (get_alpha_index(14)<< 28)
-        | (get_alpha_index(15)<< 30);
-}
-void block_package6(out uint4 block, uint threadBase)
-{
-    block.x = 0x40
-        | ((get_end_point_l(0).r & 0xFE) <<  6) | ((get_end_point_h(0).r & 0xFE) << 13)
-        | ((get_end_point_l(0).g & 0xFE) << 20) | ((get_end_point_h(0).g & 0xFE) << 27);
-    block.y = ((get_end_point_h(0).g & 0xFE) >>  5) | ((get_end_point_l(0).b & 0xFE) <<  2)
-        | ((get_end_point_h(0).b & 0xFE) <<  9)	| ((get_end_point_l(0).a & 0xFE) << 16)
-        | ((get_end_point_h(0).a & 0xFE) << 23)
-        | (get_end_point_l(0).r & 0x01) << 31;
-    block.z = (get_end_point_h(0).r & 0x01)
-        | (get_color_index(0) <<  1) | (get_color_index(1) <<  4) | (get_color_index(2) <<  8) | (get_color_index(3) << 12)
-        | (get_color_index(4) << 16) | (get_color_index(5) << 20) | (get_color_index(6) << 24) | (get_color_index(7) << 28);
-    block.w = (get_color_index(8) <<  0) | (get_color_index(9) <<  4) | (get_color_index(10)<<  8) | (get_color_index(11)<< 12)
-        | (get_color_index(12)<< 16) | (get_color_index(13)<< 20) | (get_color_index(14)<< 24) | (get_color_index(15)<< 28);
-}
-void block_package7(out uint4 block, uint partition, uint threadBase)
-{
-    block.x = 0x80 | (partition << 8)
-        | ((get_end_point_l(0).r & 0xF8) << 11) | ((get_end_point_h(0).r & 0xF8) << 16)
-        | ((get_end_point_l(1).r & 0xF8) << 21) | ((get_end_point_h(1).r & 0xF8) << 26);
-    block.y = ((get_end_point_h(1).r & 0xF8) >>  6) | ((get_end_point_l(0).g & 0xF8) >>  1)
-        | ((get_end_point_h(0).g & 0xF8) <<  4) | ((get_end_point_l(1).g & 0xF8) <<  9)
-        | ((get_end_point_h(1).g & 0xF8) << 14)	| ((get_end_point_l(0).b & 0xF8) << 19)
-        | ((get_end_point_h(0).b & 0xF8) << 24);
-    block.z = ((get_end_point_l(1).b & 0xF8) >>  3)	| ((get_end_point_h(1).b & 0xF8) <<  2)
-        | ((get_end_point_l(0).a & 0xF8) <<  7) | ((get_end_point_h(0).a & 0xF8) << 12)
-        | ((get_end_point_l(1).a & 0xF8) << 17) | ((get_end_point_h(1).a & 0xF8) << 22)
-        | ((get_end_point_l(0).r & 0x04) << 28) | ((get_end_point_h(0).r & 0x04) << 29);
-    block.w = ((get_end_point_l(1).r & 0x04) >>  2) | ((get_end_point_h(1).r & 0x04) >>  1)
-        | (get_color_index(0) <<  2);
-    uint i = 1;
-    for (; i <= candidateFixUpIndex1DOrdered[partition][0]; i++)
-    {
-        block.w |= get_color_index(i) << (i * 2 + 1);
-    }
-    for (; i < 16; i++)
-    {
-        block.w |= get_color_index(i) << (i * 2);
-    }
-}
diff --git a/thirdparty/directxtex/Shaders/CompileShaders.cmd b/thirdparty/directxtex/Shaders/CompileShaders.cmd
deleted file mode 100644
index 13418e0..0000000
--- a/thirdparty/directxtex/Shaders/CompileShaders.cmd
+++ /dev/null
@@ -1,51 +0,0 @@
-@echo off
-rem Copyright (c) Microsoft Corporation.
-rem Licensed under the MIT License.
-
-setlocal
-set error=0
-
-set FXCOPTS=/nologo /WX /Ges /Zi /Zpc /Qstrip_reflect /Qstrip_debug
-
-set PCFXC="%WindowsSdkVerBinPath%x86\fxc.exe"
-if exist %PCFXC% goto continue
-set PCFXC="%WindowsSdkBinPath%%WindowsSDKVersion%\x86\fxc.exe"
-if exist %PCFXC% goto continue
-set PCFXC="%WindowsSdkDir%bin\%WindowsSDKVersion%\x86\fxc.exe"
-if exist %PCFXC% goto continue
-
-set PCFXC=fxc.exe
-
-:continue
-if not defined CompileShadersOutput set CompileShadersOutput=Compiled
-set StrTrim=%CompileShadersOutput%##
-set StrTrim=%StrTrim: ##=%
-set CompileShadersOutput=%StrTrim:##=%
-@if not exist "%CompileShadersOutput%" mkdir "%CompileShadersOutput%"
-call :CompileShader BC7Encode TryMode456CS
-call :CompileShader BC7Encode TryMode137CS
-call :CompileShader BC7Encode TryMode02CS
-call :CompileShader BC7Encode EncodeBlockCS
-
-call :CompileShader BC6HEncode TryModeG10CS
-call :CompileShader BC6HEncode TryModeLE10CS
-call :CompileShader BC6HEncode EncodeBlockCS
-
-echo.
-
-if %error% == 0 (
-    echo Shaders compiled ok
-) else (
-    echo There were shader compilation errors!
-    exit /b 1
-)
-
-endlocal
-exit /b 0
-
-:CompileShader
-set fxc=%PCFXC% "%1.hlsl" %FXCOPTS% /Tcs_4_0 /E%2 "/Fh%CompileShadersOutput%\%1_%2.inc" "/Fd%CompileShadersOutput%\%1_%2.pdb" /Vn%1_%2
-echo.
-echo %fxc%
-%fxc% || set error=1
-exit /b
diff --git a/thirdparty/directxtex/Shaders/Compiled/BC6HEncode_EncodeBlockCS.inc b/thirdparty/directxtex/Shaders/Compiled/BC6HEncode_EncodeBlockCS.inc
deleted file mode 100644
index 1b67b98..0000000
--- a/thirdparty/directxtex/Shaders/Compiled/BC6HEncode_EncodeBlockCS.inc
+++ /dev/null
@@ -1,22226 +0,0 @@
-#if 0
-//
-// Generated by Microsoft (R) D3D Shader Disassembler
-//
-//
-// Input signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Input
-//
-// Output signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Output
-cs_4_0
-dcl_globalFlags refactoringAllowed
-dcl_immediateConstantBuffer { { 0x0000cccc, 15, 0, 0},
-                              { 0x00008888, 15, 0, 0},
-                              { 0x0000eeee, 15, 0, 0},
-                              { 0x0000ecc8, 15, 1, 0},
-                              { 0x0000c880, 15, 1, 0},
-                              { 0x0000feec, 15, 1, 1},
-                              { 0x0000fec8, 15, 1, 1},
-                              { 0x0000ec80, 15, 2, 1},
-                              { 0x0000c800, 15, 2, 1},
-                              { 0x0000ffec, 15, 2, 1},
-                              { 0x0000fe80, 15, 2, 1},
-                              { 0x0000e800, 15, 2, 1},
-                              { 0x0000ffe8, 15, 3, 1},
-                              { 0x0000ff00, 15, 3, 1},
-                              { 0x0000fff0, 15, 3, 2},
-                              { 0x0000f000, 15, 3, 2},
-                              { 0x0000f710, 15, 4, 2},
-                              { 142, 2, 4, 2},
-                              { 0x00007100, 8, 4, 2},
-                              { 2254, 2, 4, 2},
-                              { 140, 2, 5, 2},
-                              { 0x00007310, 8, 5, 2},
-                              { 0x00003100, 8, 5, 2},
-                              { 0x00008cce, 15, 5, 3},
-                              { 2188, 2, 6, 3},
-                              { 0x00003110, 8, 6, 3},
-                              { 0x00006666, 2, 6, 3},
-                              { 0x0000366c, 2, 6, 3},
-                              { 6120, 8, 6, 3},
-                              { 4080, 8, 7, 3},
-                              { 0x0000718e, 2, 7, 3},
-                              { 0x0000399c, 2, 7, 3},
-                              { -1, 0, 7, 3},
-                              { -1, 0, 8, 4},
-                              { -1, 0, 8, 4},
-                              { -1, 0, 8, 4},
-                              { -1, 0, 8, 4},
-                              { -1, 0, 9, 4},
-                              { -1, 0, 9, 4},
-                              { -1, 0, 9, 4},
-                              { -1, 0, 9, 4},
-                              { 0, 0, 10, 4},
-                              { 0, 0, 10, 5},
-                              { -1, 0, 10, 5},
-                              { -1, 0, 10, 5},
-                              { -1, 0, 10, 5},
-                              { 0, 0, 11, 5},
-                              { 0, 0, 11, 5},
-                              { 0, 0, 11, 5},
-                              { 0, 0, 11, 5},
-                              { 0, 0, 12, 5},
-                              { 0, 0, 12, 6},
-                              { 0, 0, 12, 6},
-                              { 0, 0, 12, 6},
-                              { 0, 0, 13, 6},
-                              { 0, 0, 13, 6},
-                              { 0, 0, 13, 6},
-                              { 0, 0, 13, 6},
-                              { 0, 0, 14, 6},
-                              { 0, 0, 14, 6},
-                              { 0, 0, 14, 7},
-                              { 0, 0, 14, 7},
-                              { 0, 0, 15, 7},
-                              { 0, 0, 15, 7},
-                              { 10, 5, 5, 5},
-                              { 7, 6, 6, 6},
-                              { 11, 5, 4, 4},
-                              { 11, 4, 5, 4},
-                              { 11, 4, 4, 5},
-                              { 9, 5, 5, 5},
-                              { 8, 6, 5, 5},
-                              { 8, 5, 6, 5},
-                              { 8, 5, 5, 6},
-                              { 6, 6, 6, 6},
-                              { 10, 10, 10, 10},
-                              { 11, 9, 9, 9},
-                              { 12, 8, 8, 8},
-                              { 16, 4, 4, 4} }
-dcl_constantbuffer CB0[2], immediateIndexed
-dcl_resource_texture2d (float,float,float,float) t0
-dcl_resource_structured t1, 16
-dcl_uav_structured u0, 16
-dcl_input vThreadIDInGroupFlattened
-dcl_input vThreadGroupID.x
-dcl_temps 18
-dcl_tgsm_structured g0, 84, 64
-dcl_thread_group 64, 1, 1
-ushr r0.x, vThreadIDInGroupFlattened.x, l(5)
-ishl r0.y, vThreadGroupID.x, l(1)
-iadd r0.y, r0.y, cb0[1].x
-iadd r0.x, r0.x, r0.y
-and r0.y, vThreadIDInGroupFlattened.x, l(32)
-iadd r0.z, -r0.y, vThreadIDInGroupFlattened.x
-ult r1.xyzw, r0.zzzz, l(16, 32, 2, 8)
-if_nz r1.x
-  udiv r0.w, null, r0.x, cb0[0].y
-  imad r2.x, -r0.w, cb0[0].y, r0.x
-  ishl r2.x, r2.x, l(2)
-  ishl r0.w, r0.w, l(2)
-  and r2.y, r0.z, l(3)
-  iadd r2.x, r2.y, r2.x
-  ushr r3.x, r0.z, l(2)
-  iadd r2.y, r0.w, r3.x
-  mov r2.zw, l(0,0,0,0)
-  ld r2.xyzw, r2.xyzw, t0.xyzw
-  dp3 r0.w, r2.xyzx, l(0.212600, 0.715200, 0.072200, 0.000000)
-  store_structured g0.x, vThreadIDInGroupFlattened.x, l(36), r0.w
-  ushr r3.xyz, r2.xyzx, l(16)
-  and r3.xyz, r3.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  and r4.xyzw, r2.xxyy, l(0x7fffffff, 0x007fffff, 0x7fffffff, 0x007fffff)
-  ult r2.xy, l(0x47ffefff, 0x47ffefff, 0, 0), r4.xzxx
-  ult r5.xy, r4.xzxx, l(0x38800000, 0x38800000, 0, 0)
-  ushr r5.zw, r4.xxxz, l(23)
-  iadd r5.zw, -r5.zzzw, l(0, 0, 113, 113)
-  iadd r4.yw, r4.yyyw, l(0, 0x00800000, 0, 0x00800000)
-  ushr r6.x, r4.y, r5.z
-  ushr r6.y, r4.w, r5.w
-  iadd r4.xy, r4.xzxx, l(0xc8000000, 0xc8000000, 0, 0)
-  movc r4.xy, r5.xyxx, r6.xyxx, r4.xyxx
-  iadd r4.zw, r4.xxxy, l(0, 0, 4095, 4095)
-  ushr r4.xy, r4.xyxx, l(13)
-  and r4.xy, r4.xyxx, l(1, 1, 0, 0)
-  iadd r4.xy, r4.xyxx, r4.zwzz
-  ushr r4.xy, r4.xyxx, l(13)
-  and r4.xy, r4.xyxx, l(0x00007fff, 0x00007fff, 0, 0)
-  movc r2.xy, r2.xyxx, l(0x00007fff,0x00007fff,0,0), r4.xyxx
-  iadd r4.xy, r3.xyxx, r2.xyxx
-  and r2.xy, r2.zzzz, l(0x7fffffff, 0x007fffff, 0, 0)
-  ult r0.w, l(0x47ffefff), r2.x
-  ult r2.z, r2.x, l(0x38800000)
-  ushr r2.w, r2.x, l(23)
-  iadd r2.w, -r2.w, l(113)
-  iadd r2.y, r2.y, l(0x00800000)
-  ushr r2.y, r2.y, r2.w
-  iadd r2.x, r2.x, l(0xc8000000)
-  movc r2.x, r2.z, r2.y, r2.x
-  iadd r2.y, r2.x, l(4095)
-  ushr r2.x, r2.x, l(13)
-  and r2.x, r2.x, l(1)
-  iadd r2.x, r2.x, r2.y
-  ushr r2.x, r2.x, l(13)
-  and r2.x, r2.x, l(0x00007fff)
-  movc r0.w, r0.w, l(0x00007fff), r2.x
-  iadd r4.z, r3.z, r0.w
-  ieq r0.w, cb0[0].z, l(95)
-  ishl r2.xyz, r4.xyzx, l(6)
-  udiv r2.xyz, null, r2.xyzx, l(31, 31, 31, 0)
-  ult r3.xyz, r4.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  ieq r5.xyz, r4.xyzx, l(0x00007bff, 0x00007bff, 0x00007bff, 0)
-  ishl r4.xyz, r4.xyzx, l(5)
-  udiv r6.xyz, null, r4.xyzx, l(31, 31, 31, 0)
-  movc r6.xyz, r5.xyzx, l(0x00007fff,0x00007fff,0x00007fff,0), r6.xyzx
-  and r4.xyz, r4.xyzx, l(0x000fffe0, 0x000fffe0, 0x000fffe0, 0)
-  udiv r4.xyz, null, r4.xyzx, l(31, 31, 31, 0)
-  ineg r4.xyz, r4.xyzx
-  movc r4.xyz, r5.xyzx, l(0xffff8001,0xffff8001,0xffff8001,0), r4.xyzx
-  movc r3.xyz, r3.xyzx, r6.xyzx, r4.xyzx
-  movc r2.xyz, r0.wwww, r2.xyzx, r3.xyzx
-  store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(12), r2.xyzx
-endif 
-sync_g_t
-ld_structured r2.xy, r0.x, l(4), t1.xyxx
-if_nz r1.y
-  and r0.w, r0.z, l(15)
-  iadd r1.y, r0.w, r0.y
-  ld_structured r3.xyz, r1.y, l(12), g0.xyzx
-  ld_structured r3.w, r1.y, l(36), g0.xxxx
-  if_nz r1.x
-    ult r1.y, l(10), r2.x
-    if_nz r1.y
-      mov r4.xyzw, r3.xyzx
-      mov r5.xyzw, r3.yzww
-    else 
-      ushr r1.y, icb[r2.y + 0].x, r0.z
-      and r1.y, r1.y, l(1)
-      movc r4.xyzw, r1.yyyy, l(0x7fffffff,0x7fffffff,0x7fffffff,-0.000000), r3.xyzx
-      movc r5.xyzw, r1.yyyy, l(-0.000000,-0.000000,340282346638528859811704183484516925440.000000,-340282346638528859811704183484516925440.000000), r3.yzww
-    endif 
-  else 
-    uge r1.y, l(10), r2.x
-    if_nz r1.y
-      ushr r0.w, icb[r2.y + 0].x, r0.w
-      and r0.w, r0.w, l(1)
-      ieq r0.w, r0.w, l(1)
-      movc r4.xyzw, r0.wwww, r3.xyzx, l(0x7fffffff,0x7fffffff,0x7fffffff,-0.000000)
-      movc r5.xyzw, r0.wwww, r3.yzww, l(-0.000000,-0.000000,340282346638528859811704183484516925440.000000,-340282346638528859811704183484516925440.000000)
-    else 
-      mov r4.xyzw, l(0x7fffffff,0x7fffffff,0x7fffffff,-0.000000)
-      mov r5.xyzw, l(-0.000000,-0.000000,340282346638528859811704183484516925440.000000,-340282346638528859811704183484516925440.000000)
-    endif 
-  endif 
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r4.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(68), r5.xyzw
-endif 
-sync_g_t
-and r0.w, r0.z, l(15)
-ult r3.xyzw, r0.wwww, l(8, 4, 2, 1)
-if_nz r3.x
-  ld_structured r4.x, vThreadIDInGroupFlattened.x, l(76), g0.xxxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r5.x, r0.w, l(76), g0.xxxx
-  lt r1.y, r5.x, r4.x
-  if_nz r1.y
-    ld_structured r4.xyz, r0.w, l(52), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(52), r4.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(76), r5.x
-  endif 
-  ld_structured r4.x, vThreadIDInGroupFlattened.x, l(80), g0.xxxx
-  ld_structured r5.x, r0.w, l(80), g0.xxxx
-  lt r1.y, r4.x, r5.x
-  if_nz r1.y
-    ld_structured r4.xyz, r0.w, l(64), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(64), r4.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(80), r5.x
-  endif 
-endif 
-sync_g_t
-if_nz r3.y
-  ld_structured r4.x, vThreadIDInGroupFlattened.x, l(76), g0.xxxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r5.x, r0.w, l(76), g0.xxxx
-  lt r1.y, r5.x, r4.x
-  if_nz r1.y
-    ld_structured r4.xyz, r0.w, l(52), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(52), r4.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(76), r5.x
-  endif 
-  ld_structured r4.x, vThreadIDInGroupFlattened.x, l(80), g0.xxxx
-  ld_structured r5.x, r0.w, l(80), g0.xxxx
-  lt r1.y, r4.x, r5.x
-  if_nz r1.y
-    ld_structured r4.xyz, r0.w, l(64), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(64), r4.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(80), r5.x
-  endif 
-endif 
-sync_g_t
-if_nz r3.z
-  ld_structured r4.x, vThreadIDInGroupFlattened.x, l(76), g0.xxxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r5.x, r0.w, l(76), g0.xxxx
-  lt r1.y, r5.x, r4.x
-  if_nz r1.y
-    ld_structured r4.xyz, r0.w, l(52), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(52), r4.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(76), r5.x
-  endif 
-  ld_structured r4.x, vThreadIDInGroupFlattened.x, l(80), g0.xxxx
-  ld_structured r5.x, r0.w, l(80), g0.xxxx
-  lt r1.y, r4.x, r5.x
-  if_nz r1.y
-    ld_structured r4.xyz, r0.w, l(64), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(64), r4.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(80), r5.x
-  endif 
-endif 
-sync_g_t
-if_nz r3.w
-  ld_structured r3.x, vThreadIDInGroupFlattened.x, l(76), g0.xxxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r4.x, r0.w, l(76), g0.xxxx
-  lt r1.y, r4.x, r3.x
-  if_nz r1.y
-    ld_structured r3.xyz, r0.w, l(52), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(52), r3.xyzx
-  endif 
-  ld_structured r3.x, vThreadIDInGroupFlattened.x, l(80), g0.xxxx
-  ld_structured r4.x, r0.w, l(80), g0.xxxx
-  lt r1.y, r3.x, r4.x
-  if_nz r1.y
-    ld_structured r3.xyz, r0.w, l(64), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(64), r3.xyzx
-  endif 
-endif 
-sync_g_t
-if_nz r1.z
-  ishl r0.w, r0.z, l(4)
-  iadd r0.w, r0.w, r0.y
-  ld_structured r3.xyz, r0.w, l(52), g0.xyzx
-  ld_structured r4.xyz, r0.w, l(64), g0.xyzx
-  ieq r0.w, r0.z, l(1)
-  uge r1.y, l(10), r2.x
-  and r0.w, r0.w, r1.y
-  if_nz r0.w
-    mov r0.w, icb[r2.y + 0].y
-  else 
-    mov r0.w, l(0)
-  endif 
-  iadd r5.xyz, -r3.xyzx, r4.xyzx
-  itof r5.xyz, r5.xyzx
-  dp3 r1.y, r5.xyzx, r5.xyzx
-  iadd r0.w, r0.w, r0.y
-  ld_structured r6.xyz, r0.w, l(12), g0.xyzx
-  iadd r6.xyz, -r3.xyzx, r6.xyzx
-  itof r6.xyz, r6.xyzx
-  dp3 r0.w, r5.xyzx, r6.xyzx
-  lt r2.z, l(0.000000), r1.y
-  ge r2.w, r0.w, l(0.000000)
-  and r2.z, r2.w, r2.z
-  mul r0.w, r0.w, l(63.499989)
-  div r0.w, r0.w, r1.y
-  ftou r0.w, r0.w
-  ult r0.w, l(32), r0.w
-  and r0.w, r0.w, r2.z
-  mov r4.w, r3.x
-  mov r3.w, r4.x
-  movc r5.xyzw, r0.wwww, r4.xyzw, r3.xyzw
-  movc r2.zw, r0.wwww, r3.yyyz, r4.yyyz
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r5.xyzw
-  store_structured g0.xy, vThreadIDInGroupFlattened.x, l(68), r2.zwzz
-endif 
-sync_g_t
-if_nz r1.x
-  ult r0.w, l(10), r2.x
-  if_nz r0.w
-    mov r1.x, l(0)
-  else 
-    mov r1.x, icb[r2.y + 0].x
-  endif 
-  ushr r1.x, r1.x, r0.z
-  and r1.x, r1.x, l(1)
-  if_nz r1.x
-    iadd r1.x, r0.y, l(1)
-    ld_structured r3.xyz, r1.x, l(64), g0.xyzx
-    ld_structured r4.xyz, r1.x, l(52), g0.xyzx
-    iadd r3.xyz, r3.xyzx, -r4.xyzx
-    itof r3.xyz, r3.xyzx
-    ld_structured r5.xyz, vThreadIDInGroupFlattened.x, l(12), g0.xyzx
-    iadd r4.xyz, -r4.xyzx, r5.xyzx
-    itof r4.xyz, r4.xyzx
-    dp3 r1.x, r3.xyzx, r4.xyzx
-  else 
-    ld_structured r4.xyz, r0.y, l(64), g0.xyzx
-    ld_structured r5.xyz, r0.y, l(52), g0.xyzx
-    iadd r4.xyz, r4.xyzx, -r5.xyzx
-    itof r3.xyz, r4.xyzx
-    ld_structured r4.xyz, vThreadIDInGroupFlattened.x, l(12), g0.xyzx
-    iadd r4.xyz, -r5.xyzx, r4.xyzx
-    itof r4.xyz, r4.xyzx
-    dp3 r1.x, r3.xyzx, r4.xyzx
-  endif 
-  dp3 r1.y, r3.xyzx, r3.xyzx
-  if_nz r0.w
-    ge r0.w, l(0.000000), r1.y
-    ge r2.z, l(0.000000), r1.x
-    or r0.w, r0.w, r2.z
-    lt r2.z, r1.x, r1.y
-    mul r2.w, r1.x, l(63.499989)
-    div r2.w, r2.w, r1.y
-    ftou r2.w, r2.w
-    movc r2.z, r2.z, icb[r2.w + 0].z, l(15)
-    movc r0.w, r0.w, l(0), r2.z
-    ishl r3.x, r0.w, l(1)
-    ult r2.z, r0.z, l(8)
-    ishl r2.w, r0.z, l(2)
-    ishl r4.x, r0.w, r2.w
-    iadd r2.w, r2.w, l(-32)
-    ishl r4.w, r0.w, r2.w
-    mov r4.yz, l(0,0,0,0)
-    movc r2.zw, r2.zzzz, r4.xxxy, r4.zzzw
-    mov r3.y, l(0)
-    movc r3.xy, r0.zzzz, r2.zwzz, r3.xyxx
-  else 
-    ge r0.w, l(0.000000), r1.y
-    ge r2.z, l(0.000000), r1.x
-    or r0.w, r0.w, r2.z
-    lt r2.z, r1.x, r1.y
-    mul r1.x, r1.x, l(63.499989)
-    div r1.x, r1.x, r1.y
-    ftou r1.x, r1.x
-    movc r1.x, r2.z, icb[r1.x + 0].w, l(7)
-    movc r0.w, r0.w, l(0), r1.x
-    if_z r0.z
-      ishl r3.x, r0.w, l(18)
-      mov r3.y, l(0)
-    else 
-      ult r1.x, r0.z, l(3)
-      if_nz r1.x
-        imad r1.x, r0.z, l(3), l(17)
-        ishl r3.x, r0.w, r1.x
-        mov r3.y, l(0)
-      else 
-        ine r1.x, l(2), icb[r2.y + 0].y
-        ieq r1.y, l(15), icb[r2.y + 0].y
-        and r2.zw, r1.xxxy, l(0, 0, 1, 1)
-        ult r1.y, r0.z, l(5)
-        if_nz r1.y
-          imad r1.y, r0.z, l(3), r2.z
-          iadd r1.y, r1.y, l(16)
-          ishl r3.x, r0.w, r1.y
-          mov r3.y, l(0)
-        else 
-          ieq r1.y, r0.z, l(5)
-          movc r4.x, r1.x, l(0), l(1)
-          ushr r4.y, r0.w, r4.x
-          ishl r4.z, r0.w, l(31)
-          movc r4.x, r1.x, l(0), r4.z
-          ult r1.x, r0.z, l(9)
-          imad r2.zw, r0.zzzz, l(0, 0, 3, 3), r2.zzzw
-          iadd r2.zw, r2.zzzw, l(0, 0, -16, -16)
-          ishl r2.z, r0.w, r2.z
-          ishl r0.w, r0.w, r2.w
-          movc r5.y, r1.x, r2.z, r0.w
-          mov r5.x, l(0)
-          movc r3.xy, r1.yyyy, r4.xyxx, r5.xyxx
-        endif 
-      endif 
-    endif 
-  endif 
-  store_structured g0.xy, vThreadIDInGroupFlattened.x, l(24), r3.xyxx
-else 
-  mov r3.xy, l(0,0,0,0)
-endif 
-sync_g_t
-if_nz r1.w
-  ld_structured r4.xy, vThreadIDInGroupFlattened.x, l(24), g0.xyxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r5.xy, r0.w, l(24), g0.xyxx
-  or r1.xy, r4.xyxx, r5.xyxx
-  store_structured g0.xy, vThreadIDInGroupFlattened.x, l(24), r1.xyxx
-endif 
-sync_g_t
-ult r1.xy, r0.zzzz, l(4, 1, 0, 0)
-if_nz r1.x
-  ld_structured r4.xy, vThreadIDInGroupFlattened.x, l(24), g0.xyxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r5.xy, r0.w, l(24), g0.xyxx
-  or r1.xw, r4.xxxy, r5.xxxy
-  store_structured g0.xy, vThreadIDInGroupFlattened.x, l(24), r1.xwxx
-endif 
-sync_g_t
-if_nz r1.z
-  ld_structured r4.xy, vThreadIDInGroupFlattened.x, l(24), g0.xyxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r5.xy, r0.w, l(24), g0.xyxx
-  or r1.xw, r4.xxxy, r5.xxxy
-  store_structured g0.xy, vThreadIDInGroupFlattened.x, l(24), r1.xwxx
-endif 
-sync_g_t
-if_nz r1.y
-  ld_structured r4.xy, vThreadIDInGroupFlattened.x, l(24), g0.xyxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r5.xy, r0.w, l(24), g0.xyxx
-  or r3.xy, r4.xyxx, r5.xyxx
-endif 
-sync_g_t
-iadd r0.w, r2.x, l(-1)
-ieq r1.xy, r0.zzzz, l(2, 3, 0, 0)
-if_nz r1.x
-  ld_structured r4.xyz, r0.y, l(52), g0.xyzx
-  ld_structured r5.xyz, r0.y, l(64), g0.xyzx
-  ieq r1.x, cb0[0].z, l(95)
-  if_nz r1.x
-    ige r1.x, icb[r0.w + 64].x, l(15)
-    and r1.x, r1.x, l(1)
-    movc r6.xyz, r4.xyzx, l(0,0,0,0), l(1,1,1,0)
-    movc r7.xyz, r5.xyzx, l(0,0,0,0), l(1,1,1,0)
-    or r6.xyz, r1.xxxx, r6.xyzx
-    or r7.xyz, r1.xxxx, r7.xyzx
-    ieq r8.xyz, r4.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-    ieq r9.xyz, r5.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-    ishl r1.x, l(1), icb[r0.w + 64].x
-    iadd r1.x, r1.x, l(-1)
-    ishl r10.xyz, r4.xyzx, icb[r0.w + 64].x
-    ishl r11.xyz, r5.xyzx, icb[r0.w + 64].x
-    ishr r10.xyz, r10.xyzx, l(16)
-    ishr r11.xyz, r11.xyzx, l(16)
-    movc r8.xyz, r8.xyzx, r1.xxxx, r10.xyzx
-    movc r9.xyz, r9.xyzx, r1.xxxx, r11.xyzx
-    movc r6.xyz, r6.xyzx, r4.xyzx, r8.xyzx
-    movc r7.xyz, r7.xyzx, r5.xyzx, r9.xyzx
-  else 
-    ige r1.x, icb[r0.w + 64].x, l(16)
-    and r1.x, r1.x, l(1)
-    movc r8.xyz, r4.xyzx, l(0,0,0,0), l(1,1,1,0)
-    movc r9.xyz, r5.xyzx, l(0,0,0,0), l(1,1,1,0)
-    or r8.xyz, r1.xxxx, r8.xyzx
-    or r9.xyz, r1.xxxx, r9.xyzx
-    ige r10.xyz, r4.xyzx, l(0, 0, 0, 0)
-    ige r11.xyz, r5.xyzx, l(0, 0, 0, 0)
-    ieq r12.xyz, r4.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ieq r13.xyz, r5.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    iadd r1.x, l(-1), icb[r0.w + 64].x
-    ishl r1.w, l(1), r1.x
-    iadd r2.z, r1.w, l(-1)
-    ishl r14.xyz, r4.xyzx, r1.x
-    ishl r15.xyz, r5.xyzx, r1.x
-    ishr r14.xyz, r14.xyzx, l(15)
-    ishr r15.xyz, r15.xyzx, l(15)
-    movc r12.xyz, r12.xyzx, r2.zzzz, r14.xyzx
-    movc r13.xyz, r13.xyzx, r2.zzzz, r15.xyzx
-    ineg r14.xyz, r4.xyzx
-    ineg r15.xyz, r5.xyzx
-    ieq r16.xyz, r14.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ieq r17.xyz, r15.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    iadd r1.w, -r1.w, l(1)
-    ishl r14.xyz, r14.xyzx, r1.x
-    ishl r15.xyz, r15.xyzx, r1.x
-    ishr r14.xyz, r14.xyzx, l(15)
-    ishr r15.xyz, r15.xyzx, l(15)
-    ineg r14.xyz, r14.xyzx
-    ineg r15.xyz, r15.xyzx
-    movc r14.xyz, r16.xyzx, r1.wwww, r14.xyzx
-    movc r15.xyz, r17.xyzx, r1.wwww, r15.xyzx
-    movc r10.xyz, r10.xyzx, r12.xyzx, r14.xyzx
-    movc r11.xyz, r11.xyzx, r13.xyzx, r15.xyzx
-    movc r6.xyz, r8.xyzx, r4.xyzx, r10.xyzx
-    movc r7.xyz, r9.xyzx, r5.xyzx, r11.xyzx
-  endif 
-  iadd r4.xyz, -r6.xyzx, r7.xyzx
-  movc r4.xyz, icb[r0.w + 32].xxxx, r4.xyzx, r7.xyzx
-  mov r6.w, r4.x
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-  store_structured g0.xy, vThreadIDInGroupFlattened.x, l(68), r4.yzyy
-endif 
-sync_g_t
-if_nz r1.y
-  iadd r1.xy, r0.yyyy, l(2, 1, 0, 0)
-  ld_structured r4.xyz, r1.x, l(52), g0.xyzx
-  ld_structured r5.xyz, r1.y, l(52), g0.xyzx
-  ld_structured r6.xyz, r1.y, l(64), g0.xyzx
-  uge r1.x, l(10), r2.x
-  if_nz r1.x
-    ieq r1.x, cb0[0].z, l(95)
-    if_nz r1.x
-      ige r1.x, icb[r0.w + 64].x, l(15)
-      and r1.x, r1.x, l(1)
-      movc r7.xyz, r5.xyzx, l(0,0,0,0), l(1,1,1,0)
-      movc r8.xyz, r6.xyzx, l(0,0,0,0), l(1,1,1,0)
-      or r7.xyz, r1.xxxx, r7.xyzx
-      or r1.xyw, r1.xxxx, r8.xyxz
-      ieq r8.xyz, r5.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-      ieq r9.xyz, r6.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-      ishl r2.z, l(1), icb[r0.w + 64].x
-      iadd r2.z, r2.z, l(-1)
-      ishl r10.xyz, r5.xyzx, icb[r0.w + 64].x
-      ishl r11.xyz, r6.xyzx, icb[r0.w + 64].x
-      ishr r10.xyz, r10.xyzx, l(16)
-      ishr r11.xyz, r11.xyzx, l(16)
-      movc r8.xyz, r8.xyzx, r2.zzzz, r10.xyzx
-      movc r9.xyz, r9.xyzx, r2.zzzz, r11.xyzx
-      movc r7.xyz, r7.xyzx, r5.xyzx, r8.xyzx
-      movc r1.xyw, r1.xyxw, r6.xyxz, r9.xyxz
-    else 
-      ige r2.z, icb[r0.w + 64].x, l(16)
-      and r2.z, r2.z, l(1)
-      movc r8.xyz, r5.xyzx, l(0,0,0,0), l(1,1,1,0)
-      movc r9.xyz, r6.xyzx, l(0,0,0,0), l(1,1,1,0)
-      or r8.xyz, r2.zzzz, r8.xyzx
-      or r9.xyz, r2.zzzz, r9.xyzx
-      ige r10.xyz, r5.xyzx, l(0, 0, 0, 0)
-      ige r11.xyz, r6.xyzx, l(0, 0, 0, 0)
-      ieq r12.xyz, r5.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-      ieq r13.xyz, r6.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-      iadd r2.z, l(-1), icb[r0.w + 64].x
-      ishl r2.w, l(1), r2.z
-      iadd r4.w, r2.w, l(-1)
-      ishl r14.xyz, r5.xyzx, r2.z
-      ishl r15.xyz, r6.xyzx, r2.z
-      ishr r14.xyz, r14.xyzx, l(15)
-      ishr r15.xyz, r15.xyzx, l(15)
-      movc r12.xyz, r12.xyzx, r4.wwww, r14.xyzx
-      movc r13.xyz, r13.xyzx, r4.wwww, r15.xyzx
-      ineg r14.xyz, r5.xyzx
-      ineg r15.xyz, r6.xyzx
-      ieq r16.xyz, r14.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-      ieq r17.xyz, r15.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-      iadd r2.w, -r2.w, l(1)
-      ishl r14.xyz, r14.xyzx, r2.z
-      ishl r15.xyz, r15.xyzx, r2.z
-      ishr r14.xyz, r14.xyzx, l(15)
-      ishr r15.xyz, r15.xyzx, l(15)
-      ineg r14.xyz, r14.xyzx
-      ineg r15.xyz, r15.xyzx
-      movc r14.xyz, r16.xyzx, r2.wwww, r14.xyzx
-      movc r15.xyz, r17.xyzx, r2.wwww, r15.xyzx
-      movc r10.xyz, r10.xyzx, r12.xyzx, r14.xyzx
-      movc r11.xyz, r11.xyzx, r13.xyzx, r15.xyzx
-      movc r7.xyz, r8.xyzx, r5.xyzx, r10.xyzx
-      movc r1.xyw, r9.xyxz, r6.xyxz, r11.xyxz
-    endif 
-    iadd r5.xyz, -r4.xyzx, r7.xyzx
-    iadd r4.xyz, -r4.xyzx, r1.xywx
-    mov r5.w, r4.x
-    mov r7.w, r1.x
-    movc r5.xyzw, icb[r0.w + 32].xxxx, r5.xyzw, r7.xyzw
-    movc r1.xy, icb[r0.w + 32].xxxx, r4.yzyy, r1.ywyy
-    store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r5.xyzw
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(68), r1.xyxx
-  endif 
-endif 
-sync_g_t
-if_nz r1.z
-  iadd r1.x, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r4.xyz, r1.x, l(52), g0.xyzx
-  ld_structured r1.xyz, r1.x, l(64), g0.yzxx
-  if_z r0.z
-    ult r1.w, l(10), r2.x
-    if_nz r1.w
-      ishl r5.x, l(1), icb[r0.w + 64].x
-      ishl r5.y, l(1), icb[r0.w + 64].y
-      ishl r5.z, l(1), icb[r0.w + 64].z
-      ishl r5.w, l(1), icb[r0.w + 64].w
-      ige r6.xyz, r1.zxyz, l(0, 0, 0, 0)
-      iadd r7.xyz, l(-1, -1, -1, 0), icb[r0.w + 64].yzwy
-      ishl r8.x, l(1), r7.x
-      ishl r8.y, l(1), r7.y
-      ishl r8.z, l(1), r7.z
-      ige r7.xyz, r1.zxyz, r8.xyzx
-      iadd r9.xyz, r8.xyzx, l(-1, -1, -1, 0)
-      movc r7.xyz, r7.xyzx, r9.xyzx, r1.zxyz
-      ineg r9.xyz, r1.zxyz
-      ilt r9.xyz, r8.xyzx, r9.xyzx
-      iadd r5.xyzw, r5.xyzw, l(-1, -1, -1, -1)
-      and r5.yzw, r1.zzxy, r5.yyzw
-      movc r5.yzw, r9.xxyz, r8.xxyz, r5.yyzw
-      movc r5.yzw, r6.xxyz, r7.xxyz, r5.yyzw
-      mov r4.w, r1.z
-      and r6.xyzw, r4.xyzw, r5.xxxx
-      and r2.zw, r1.xxxy, r5.xxxx
-      mov r7.xyz, r6.xyzx
-      mov r7.w, r5.y
-      movc r4.xyzw, icb[r0.w + 32].xxxx, r7.xyzw, r6.xyzw
-      movc r1.xy, icb[r0.w + 32].xxxx, r5.zwzz, r2.zwzz
-    else 
-      if_nz icb[r0.w + 32].x
-        ishl r5.x, l(1), icb[r0.w + 64].x
-        ishl r5.y, l(1), icb[r0.w + 64].y
-        ishl r5.z, l(1), icb[r0.w + 64].z
-        ishl r5.w, l(1), icb[r0.w + 64].w
-        iadd r5.xyzw, r5.xyzw, l(-1, -1, -1, -1)
-        and r4.xyz, r4.xyzx, r5.xxxx
-        ige r6.xyz, r1.zxyz, l(0, 0, 0, 0)
-        iadd r7.xyz, l(-1, -1, -1, 0), icb[r0.w + 64].yzwy
-        ishl r8.x, l(1), r7.x
-        ishl r8.y, l(1), r7.y
-        ishl r8.z, l(1), r7.z
-        ige r7.xyz, r1.zxyz, r8.xyzx
-        iadd r9.xyz, r8.xyzx, l(-1, -1, -1, 0)
-        movc r7.xyz, r7.xyzx, r9.xyzx, r1.zxyz
-        ineg r9.xyz, r1.zxyz
-        ilt r9.xyz, r8.xyzx, r9.xyzx
-        and r5.xyz, r1.zxyz, r5.yzwy
-        movc r5.xyz, r9.xyzx, r8.xyzx, r5.xyzx
-        movc r1.xyz, r6.yzxy, r7.yzxy, r5.yzxy
-        mov r4.w, r1.z
-      else 
-        ishl r1.w, l(1), icb[r0.w + 64].x
-        iadd r1.w, r1.w, l(-1)
-        mov r4.w, r1.z
-        and r4.xyzw, r1.wwww, r4.xyzw
-        and r1.xy, r1.wwww, r1.xyxx
-      endif 
-    endif 
-  else 
-    uge r1.w, l(10), r2.x
-    if_nz r1.w
-      if_nz icb[r0.w + 32].x
-        ige r5.xyz, r4.xyzx, l(0, 0, 0, 0)
-        iadd r6.xyz, l(-1, -1, -1, 0), icb[r0.w + 64].yzwy
-        ishl r7.x, l(1), r6.x
-        ishl r7.y, l(1), r6.y
-        ishl r7.z, l(1), r6.z
-        ige r6.xyz, r4.xyzx, r7.xyzx
-        iadd r8.xyz, r7.xyzx, l(-1, -1, -1, 0)
-        movc r6.xyz, r6.xyzx, r8.xyzx, r4.xyzx
-        ineg r9.xyz, r4.xyzx
-        ilt r9.xyz, r7.xyzx, r9.xyzx
-        ishl r10.x, l(1), icb[r0.w + 64].y
-        ishl r10.y, l(1), icb[r0.w + 64].z
-        ishl r10.z, l(1), icb[r0.w + 64].w
-        iadd r10.xyz, r10.xyzx, l(-1, -1, -1, 0)
-        and r11.xyz, r4.xyzx, r10.xyzx
-        movc r9.xyz, r9.xyzx, r7.xyzx, r11.xyzx
-        movc r4.xyz, r5.xyzx, r6.xyzx, r9.xyzx
-        ige r5.xyz, r1.zxyz, l(0, 0, 0, 0)
-        ige r6.xyz, r1.zxyz, r7.xyzx
-        movc r6.xyz, r6.xyzx, r8.xyzx, r1.zxyz
-        ineg r8.xyz, r1.zxyz
-        ilt r8.xyz, r7.xyzx, r8.xyzx
-        and r9.xyz, r1.zxyz, r10.xyzx
-        movc r7.xyz, r8.xyzx, r7.xyzx, r9.xyzx
-        movc r1.xyz, r5.yzxy, r6.yzxy, r7.yzxy
-        mov r4.w, r1.z
-      else 
-        ishl r0.w, l(1), icb[r0.w + 64].x
-        iadd r0.w, r0.w, l(-1)
-        mov r4.w, r1.z
-        and r4.xyzw, r0.wwww, r4.xyzw
-        and r1.xy, r0.wwww, r1.xyxx
-      endif 
-    else 
-      mov r4.w, r1.z
-    endif 
-  endif 
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r4.xyzw
-  store_structured g0.xy, vThreadIDInGroupFlattened.x, l(68), r1.xyxx
-endif 
-sync_g_t
-if_z r0.z
-  ld_structured r1.xyzw, r0.y, l(52), g0.xyzw
-  ld_structured r4.xy, r0.y, l(68), g0.xyxx
-  ult r0.z, l(10), r2.x
-  if_nz r0.z
-    and r3.w, r3.x, l(-2)
-    ieq r0.z, r2.x, l(11)
-    if_nz r0.z
-      ishl r5.x, r1.x, l(5)
-      ishl r5.y, r1.y, l(15)
-      ishl r5.z, r1.z, l(25)
-      ishl r5.w, r1.w, l(3)
-      and r5.xyzw, r5.xyzw, l(32, 0x00008000, 0x02000000, 8)
-      iadd r0.z, r5.x, l(3)
-      ishr r0.w, r1.x, l(1)
-      ishr r2.z, r1.x, l(2)
-      ishr r2.w, r1.x, l(3)
-      ishr r4.z, r1.x, l(4)
-      ishl r6.x, r0.w, l(6)
-      ishl r6.y, r2.z, l(7)
-      ishl r6.z, r2.w, l(8)
-      ishl r6.w, r4.z, l(9)
-      and r6.xyzw, r6.xyzw, l(64, 128, 256, 512)
-      iadd r0.z, r0.z, r6.x
-      iadd r0.z, r6.y, r0.z
-      iadd r0.z, r6.z, r0.z
-      iadd r0.z, r6.w, r0.z
-      ishr r0.w, r1.x, l(5)
-      ishr r2.z, r1.x, l(6)
-      ishr r2.w, r1.x, l(7)
-      ishr r4.z, r1.x, l(8)
-      ishl r6.x, r0.w, l(10)
-      ishl r6.y, r2.z, l(11)
-      ishl r6.z, r2.w, l(12)
-      ishl r6.w, r4.z, l(13)
-      and r6.xyzw, r6.xyzw, l(1024, 2048, 4096, 8192)
-      iadd r0.z, r0.z, r6.x
-      iadd r0.z, r6.y, r0.z
-      iadd r0.z, r6.z, r0.z
-      iadd r0.z, r6.w, r0.z
-      ishr r0.w, r1.x, l(9)
-      ishr r2.z, r1.y, l(1)
-      ishr r2.w, r1.y, l(2)
-      ishr r4.z, r1.y, l(3)
-      ishl r6.x, r0.w, l(14)
-      ishl r6.y, r2.z, l(16)
-      ishl r6.z, r2.w, l(17)
-      ishl r6.w, r4.z, l(18)
-      and r6.xyzw, r6.xyzw, l(0x00004000, 0x00010000, 0x00020000, 0x00040000)
-      iadd r0.z, r0.z, r6.x
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r6.y, r0.z
-      iadd r0.z, r6.z, r0.z
-      iadd r0.z, r6.w, r0.z
-      ishr r0.w, r1.y, l(4)
-      ishr r2.z, r1.y, l(5)
-      ishr r2.w, r1.y, l(6)
-      ishr r4.z, r1.y, l(7)
-      ishl r6.x, r0.w, l(19)
-      ishl r6.y, r2.z, l(20)
-      ishl r6.z, r2.w, l(21)
-      ishl r6.w, r4.z, l(22)
-      and r6.xyzw, r6.xyzw, l(0x00080000, 0x00100000, 0x00200000, 0x00400000)
-      iadd r0.z, r0.z, r6.x
-      iadd r0.z, r6.y, r0.z
-      iadd r0.z, r6.z, r0.z
-      iadd r0.z, r6.w, r0.z
-      ishr r0.w, r1.y, l(8)
-      ishr r2.z, r1.y, l(9)
-      ishr r2.w, r1.z, l(1)
-      ishr r4.z, r1.z, l(2)
-      ishl r6.x, r0.w, l(23)
-      ishl r6.y, r2.z, l(24)
-      ishl r6.z, r2.w, l(26)
-      ishl r6.w, r4.z, l(27)
-      and r6.xyzw, r6.xyzw, l(0x00800000, 0x01000000, 0x04000000, 0x08000000)
-      iadd r0.z, r0.z, r6.x
-      iadd r0.z, r6.y, r0.z
-      iadd r0.z, r5.z, r0.z
-      iadd r0.z, r6.z, r0.z
-      iadd r0.z, r6.w, r0.z
-      ishr r0.w, r1.z, l(3)
-      ishr r2.z, r1.z, l(4)
-      ishr r2.w, r1.z, l(5)
-      ishr r4.z, r1.z, l(6)
-      ishl r5.x, r0.w, l(28)
-      ishl r5.y, r2.z, l(29)
-      ishl r5.z, r2.w, l(30)
-      ishl r0.w, r4.z, l(31)
-      and r5.xyz, r5.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-      iadd r0.z, r0.z, r5.x
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r5.z, r0.z
-      iadd r3.x, r0.w, r0.z
-      ishr r0.z, r1.z, l(7)
-      ishr r0.w, r1.z, l(8)
-      ishr r2.z, r1.z, l(9)
-      ishr r2.w, r1.w, l(1)
-      and r0.z, r0.z, l(1)
-      ishl r5.x, r0.w, l(1)
-      ishl r5.y, r2.z, l(2)
-      ishl r5.z, r2.w, l(4)
-      and r5.xyz, r5.xyzx, l(2, 4, 16, 0)
-      iadd r0.z, r0.z, r5.x
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r5.w, r0.z
-      iadd r0.z, r5.z, r0.z
-      ishr r0.w, r1.w, l(2)
-      ishr r2.z, r1.w, l(3)
-      ishr r2.w, r1.w, l(4)
-      ishr r4.z, r1.w, l(5)
-      ishl r5.x, r0.w, l(5)
-      ishl r5.y, r2.z, l(6)
-      ishl r5.z, r2.w, l(7)
-      ishl r5.w, r4.z, l(8)
-      and r5.xyzw, r5.xyzw, l(32, 64, 128, 256)
-      iadd r0.z, r0.z, r5.x
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r5.z, r0.z
-      iadd r0.z, r5.w, r0.z
-      ishr r0.w, r1.w, l(6)
-      ishr r2.z, r1.w, l(7)
-      ishr r2.w, r1.w, l(8)
-      ishr r4.z, r1.w, l(9)
-      ishl r5.x, r0.w, l(9)
-      ishl r5.y, r2.z, l(10)
-      ishl r5.z, r2.w, l(11)
-      ishl r5.w, r4.z, l(12)
-      and r5.xyzw, r5.xyzw, l(512, 1024, 2048, 4096)
-      iadd r0.z, r0.z, r5.x
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r5.z, r0.z
-      iadd r0.z, r5.w, r0.z
-      ishl r5.x, r4.x, l(13)
-      ishl r5.y, r4.y, l(23)
-      and r2.zw, r5.xxxy, l(0, 0, 8192, 0x00800000)
-      iadd r0.z, r0.z, r2.z
-      ishr r0.w, r4.x, l(1)
-      ishr r2.z, r4.x, l(2)
-      ishr r4.z, r4.x, l(3)
-      ishr r4.w, r4.x, l(4)
-      ishl r5.x, r0.w, l(14)
-      ishl r5.y, r2.z, l(15)
-      ishl r5.z, r4.z, l(16)
-      ishl r5.w, r4.w, l(17)
-      and r5.xyzw, r5.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-      iadd r0.z, r0.z, r5.x
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r5.z, r0.z
-      iadd r0.z, r5.w, r0.z
-      ishr r0.w, r4.x, l(5)
-      ishr r2.z, r4.x, l(6)
-      ishr r4.z, r4.x, l(7)
-      ishr r4.w, r4.x, l(8)
-      ishl r5.x, r0.w, l(18)
-      ishl r5.y, r2.z, l(19)
-      ishl r5.z, r4.z, l(20)
-      ishl r5.w, r4.w, l(21)
-      and r5.xyzw, r5.xyzw, l(0x00040000, 0x00080000, 0x00100000, 0x00200000)
-      iadd r0.z, r0.z, r5.x
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r5.z, r0.z
-      iadd r0.z, r5.w, r0.z
-      ishr r0.w, r4.x, l(9)
-      ishr r2.z, r4.y, l(1)
-      ishr r4.z, r4.y, l(2)
-      ishr r4.w, r4.y, l(3)
-      ishl r5.x, r0.w, l(22)
-      ishl r5.y, r2.z, l(24)
-      ishl r5.z, r4.z, l(25)
-      ishl r5.w, r4.w, l(26)
-      and r5.xyzw, r5.xyzw, l(0x00400000, 0x01000000, 0x02000000, 0x04000000)
-      iadd r0.z, r0.z, r5.x
-      iadd r0.z, r2.w, r0.z
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r5.z, r0.z
-      iadd r0.z, r5.w, r0.z
-      ishr r0.w, r4.y, l(4)
-      ishr r2.z, r4.y, l(5)
-      ishr r2.w, r4.y, l(6)
-      ishr r4.z, r4.y, l(7)
-      ishl r5.x, r0.w, l(27)
-      ishl r5.y, r2.z, l(28)
-      ishl r5.z, r2.w, l(29)
-      ishl r5.w, r4.z, l(30)
-      and r5.xyzw, r5.xyzw, l(0x08000000, 0x10000000, 0x20000000, 0x40000000)
-      iadd r0.z, r0.z, r5.x
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r5.z, r0.z
-      iadd r0.z, r5.w, r0.z
-      ishr r0.w, r4.y, l(8)
-      ishr r2.z, r4.y, l(9)
-      ishl r0.w, r0.w, l(31)
-      iadd r3.z, r0.w, r0.z
-      and r0.z, r2.z, l(1)
-      iadd r3.w, r0.z, r3.w
-    else 
-      ieq r0.z, r2.x, l(12)
-      if_nz r0.z
-        ishl r5.x, r1.x, l(5)
-        ishl r5.y, r1.y, l(15)
-        ishl r5.z, r1.z, l(25)
-        ishl r5.w, r1.w, l(3)
-        and r5.xyzw, r5.xyzw, l(32, 0x00008000, 0x02000000, 8)
-        iadd r0.z, r5.x, l(7)
-        ishr r0.w, r1.x, l(1)
-        ishr r2.z, r1.x, l(2)
-        ishr r2.w, r1.x, l(3)
-        ishr r4.z, r1.x, l(4)
-        ishl r6.x, r0.w, l(6)
-        ishl r6.y, r2.z, l(7)
-        ishl r6.z, r2.w, l(8)
-        ishl r6.w, r4.z, l(9)
-        and r6.xyzw, r6.xyzw, l(64, 128, 256, 512)
-        iadd r0.z, r0.z, r6.x
-        iadd r0.z, r6.y, r0.z
-        iadd r0.z, r6.z, r0.z
-        iadd r0.z, r6.w, r0.z
-        ishr r0.w, r1.x, l(5)
-        ishr r2.z, r1.x, l(6)
-        ishr r2.w, r1.x, l(7)
-        ishr r4.z, r1.x, l(8)
-        ishl r6.x, r0.w, l(10)
-        ishl r6.y, r2.z, l(11)
-        ishl r6.z, r2.w, l(12)
-        ishl r6.w, r4.z, l(13)
-        and r6.xyzw, r6.xyzw, l(1024, 2048, 4096, 8192)
-        iadd r0.z, r0.z, r6.x
-        iadd r0.z, r6.y, r0.z
-        iadd r0.z, r6.z, r0.z
-        iadd r0.z, r6.w, r0.z
-        ishr r0.w, r1.x, l(9)
-        ishr r2.z, r1.y, l(1)
-        ishr r2.w, r1.y, l(2)
-        ishr r4.z, r1.y, l(3)
-        ishl r6.x, r0.w, l(14)
-        ishl r6.y, r2.z, l(16)
-        ishl r6.z, r2.w, l(17)
-        ishl r6.w, r4.z, l(18)
-        and r6.xyzw, r6.xyzw, l(0x00004000, 0x00010000, 0x00020000, 0x00040000)
-        iadd r0.z, r0.z, r6.x
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r6.y, r0.z
-        iadd r0.z, r6.z, r0.z
-        iadd r0.z, r6.w, r0.z
-        ishr r0.w, r1.y, l(4)
-        ishr r2.z, r1.y, l(5)
-        ishr r2.w, r1.y, l(6)
-        ishr r4.z, r1.y, l(7)
-        ishl r6.x, r0.w, l(19)
-        ishl r6.y, r2.z, l(20)
-        ishl r6.z, r2.w, l(21)
-        ishl r6.w, r4.z, l(22)
-        and r6.xyzw, r6.xyzw, l(0x00080000, 0x00100000, 0x00200000, 0x00400000)
-        iadd r0.z, r0.z, r6.x
-        iadd r0.z, r6.y, r0.z
-        iadd r0.z, r6.z, r0.z
-        iadd r0.z, r6.w, r0.z
-        ishr r0.w, r1.y, l(8)
-        ishr r2.z, r1.y, l(9)
-        ishr r2.w, r1.z, l(1)
-        ishr r4.z, r1.z, l(2)
-        ishl r6.x, r0.w, l(23)
-        ishl r6.y, r2.z, l(24)
-        ishl r6.z, r2.w, l(26)
-        ishl r6.w, r4.z, l(27)
-        and r6.xyzw, r6.xyzw, l(0x00800000, 0x01000000, 0x04000000, 0x08000000)
-        iadd r0.z, r0.z, r6.x
-        iadd r0.z, r6.y, r0.z
-        iadd r0.z, r5.z, r0.z
-        iadd r0.z, r6.z, r0.z
-        iadd r0.z, r6.w, r0.z
-        ishr r0.w, r1.z, l(3)
-        ishr r2.z, r1.z, l(4)
-        ishr r2.w, r1.z, l(5)
-        ishr r4.z, r1.z, l(6)
-        ishl r5.x, r0.w, l(28)
-        ishl r5.y, r2.z, l(29)
-        ishl r5.z, r2.w, l(30)
-        ishl r0.w, r4.z, l(31)
-        and r5.xyz, r5.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-        iadd r0.z, r0.z, r5.x
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r5.z, r0.z
-        iadd r3.x, r0.w, r0.z
-        ishr r0.z, r1.z, l(7)
-        ishr r0.w, r1.z, l(8)
-        ishr r2.z, r1.z, l(9)
-        ishr r2.w, r1.w, l(1)
-        and r0.z, r0.z, l(1)
-        ishl r5.x, r0.w, l(1)
-        ishl r5.y, r2.z, l(2)
-        ishl r5.z, r2.w, l(4)
-        and r5.xyz, r5.xyzx, l(2, 4, 16, 0)
-        iadd r0.z, r0.z, r5.x
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r5.w, r0.z
-        iadd r0.z, r5.z, r0.z
-        ishr r0.w, r1.w, l(2)
-        ishr r2.z, r1.w, l(3)
-        ishr r2.w, r1.w, l(4)
-        ishr r4.z, r1.w, l(5)
-        ishl r5.x, r0.w, l(5)
-        ishl r5.y, r2.z, l(6)
-        ishl r5.z, r2.w, l(7)
-        ishl r5.w, r4.z, l(8)
-        and r5.xyzw, r5.xyzw, l(32, 64, 128, 256)
-        iadd r0.z, r0.z, r5.x
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r5.z, r0.z
-        iadd r0.z, r5.w, r0.z
-        ishr r0.w, r1.w, l(6)
-        ishr r2.z, r1.w, l(7)
-        ishr r2.w, r1.w, l(8)
-        ishr r4.z, r1.x, l(10)
-        ishl r5.x, r0.w, l(9)
-        ishl r5.y, r2.z, l(10)
-        ishl r5.z, r2.w, l(11)
-        ishl r5.w, r4.z, l(12)
-        and r5.xyzw, r5.xyzw, l(512, 1024, 2048, 4096)
-        iadd r0.z, r0.z, r5.x
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r5.z, r0.z
-        iadd r0.z, r5.w, r0.z
-        ishl r5.x, r4.x, l(13)
-        ishl r5.y, r4.y, l(23)
-        and r2.zw, r5.xxxy, l(0, 0, 8192, 0x00800000)
-        iadd r0.z, r0.z, r2.z
-        ishr r0.w, r4.x, l(1)
-        ishr r2.z, r4.x, l(2)
-        ishr r4.z, r4.x, l(3)
-        ishr r4.w, r4.x, l(4)
-        ishl r5.x, r0.w, l(14)
-        ishl r5.y, r2.z, l(15)
-        ishl r5.z, r4.z, l(16)
-        ishl r5.w, r4.w, l(17)
-        and r5.xyzw, r5.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-        iadd r0.z, r0.z, r5.x
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r5.z, r0.z
-        iadd r0.z, r5.w, r0.z
-        ishr r0.w, r4.x, l(5)
-        ishr r2.z, r4.x, l(6)
-        ishr r4.z, r4.x, l(7)
-        ishr r4.w, r4.x, l(8)
-        ishl r5.x, r0.w, l(18)
-        ishl r5.y, r2.z, l(19)
-        ishl r5.z, r4.z, l(20)
-        ishl r5.w, r4.w, l(21)
-        and r5.xyzw, r5.xyzw, l(0x00040000, 0x00080000, 0x00100000, 0x00200000)
-        iadd r0.z, r0.z, r5.x
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r5.z, r0.z
-        iadd r0.z, r5.w, r0.z
-        ishr r4.zw, r1.yyyz, l(10)
-        ishl r0.w, r4.z, l(22)
-        and r0.w, r0.w, l(0x00400000)
-        iadd r0.z, r0.w, r0.z
-        iadd r0.z, r2.w, r0.z
-        ishr r0.w, r4.y, l(1)
-        ishr r2.z, r4.y, l(2)
-        ishr r2.w, r4.y, l(3)
-        ishr r4.z, r4.y, l(4)
-        ishl r5.x, r0.w, l(24)
-        ishl r5.y, r2.z, l(25)
-        ishl r5.z, r2.w, l(26)
-        ishl r5.w, r4.z, l(27)
-        and r5.xyzw, r5.xyzw, l(0x01000000, 0x02000000, 0x04000000, 0x08000000)
-        iadd r0.z, r0.z, r5.x
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r5.z, r0.z
-        iadd r0.z, r5.w, r0.z
-        ishr r0.w, r4.y, l(5)
-        ishr r2.z, r4.y, l(6)
-        ishr r2.w, r4.y, l(7)
-        ishr r4.z, r4.y, l(8)
-        ishl r5.x, r0.w, l(28)
-        ishl r5.y, r2.z, l(29)
-        ishl r5.z, r2.w, l(30)
-        ishl r0.w, r4.z, l(31)
-        and r5.xyz, r5.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-        iadd r0.z, r0.z, r5.x
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r5.z, r0.z
-        iadd r3.z, r0.w, r0.z
-        and r0.z, r4.w, l(1)
-        iadd r3.w, r0.z, r3.w
-      else 
-        ieq r0.z, r2.x, l(13)
-        if_nz r0.z
-          ishl r5.x, r1.x, l(5)
-          ishl r5.y, r1.y, l(15)
-          ishl r5.z, r1.z, l(25)
-          ishl r5.w, r1.w, l(3)
-          and r5.xyzw, r5.xyzw, l(32, 0x00008000, 0x02000000, 8)
-          iadd r0.z, r5.x, l(11)
-          ishr r0.w, r1.x, l(1)
-          ishr r2.z, r1.x, l(2)
-          ishr r2.w, r1.x, l(3)
-          ishr r4.z, r1.x, l(4)
-          ishl r6.x, r0.w, l(6)
-          ishl r6.y, r2.z, l(7)
-          ishl r6.z, r2.w, l(8)
-          ishl r6.w, r4.z, l(9)
-          and r6.xyzw, r6.xyzw, l(64, 128, 256, 512)
-          iadd r0.z, r0.z, r6.x
-          iadd r0.z, r6.y, r0.z
-          iadd r0.z, r6.z, r0.z
-          iadd r0.z, r6.w, r0.z
-          ishr r0.w, r1.x, l(5)
-          ishr r2.z, r1.x, l(6)
-          ishr r2.w, r1.x, l(7)
-          ishr r4.z, r1.x, l(8)
-          ishl r6.x, r0.w, l(10)
-          ishl r6.y, r2.z, l(11)
-          ishl r6.z, r2.w, l(12)
-          ishl r6.w, r4.z, l(13)
-          and r6.xyzw, r6.xyzw, l(1024, 2048, 4096, 8192)
-          iadd r0.z, r0.z, r6.x
-          iadd r0.z, r6.y, r0.z
-          iadd r0.z, r6.z, r0.z
-          iadd r0.z, r6.w, r0.z
-          ishr r0.w, r1.x, l(9)
-          ishr r2.z, r1.y, l(1)
-          ishr r2.w, r1.y, l(2)
-          ishr r4.z, r1.y, l(3)
-          ishl r6.x, r0.w, l(14)
-          ishl r6.y, r2.z, l(16)
-          ishl r6.z, r2.w, l(17)
-          ishl r6.w, r4.z, l(18)
-          and r6.xyzw, r6.xyzw, l(0x00004000, 0x00010000, 0x00020000, 0x00040000)
-          iadd r0.z, r0.z, r6.x
-          iadd r0.z, r5.y, r0.z
-          iadd r0.z, r6.y, r0.z
-          iadd r0.z, r6.z, r0.z
-          iadd r0.z, r6.w, r0.z
-          ishr r0.w, r1.y, l(4)
-          ishr r2.z, r1.y, l(5)
-          ishr r2.w, r1.y, l(6)
-          ishr r4.z, r1.y, l(7)
-          ishl r6.x, r0.w, l(19)
-          ishl r6.y, r2.z, l(20)
-          ishl r6.z, r2.w, l(21)
-          ishl r6.w, r4.z, l(22)
-          and r6.xyzw, r6.xyzw, l(0x00080000, 0x00100000, 0x00200000, 0x00400000)
-          iadd r0.z, r0.z, r6.x
-          iadd r0.z, r6.y, r0.z
-          iadd r0.z, r6.z, r0.z
-          iadd r0.z, r6.w, r0.z
-          ishr r0.w, r1.y, l(8)
-          ishr r2.z, r1.y, l(9)
-          ishr r2.w, r1.z, l(1)
-          ishr r4.z, r1.z, l(2)
-          ishl r6.x, r0.w, l(23)
-          ishl r6.y, r2.z, l(24)
-          ishl r6.z, r2.w, l(26)
-          ishl r6.w, r4.z, l(27)
-          and r6.xyzw, r6.xyzw, l(0x00800000, 0x01000000, 0x04000000, 0x08000000)
-          iadd r0.z, r0.z, r6.x
-          iadd r0.z, r6.y, r0.z
-          iadd r0.z, r5.z, r0.z
-          iadd r0.z, r6.z, r0.z
-          iadd r0.z, r6.w, r0.z
-          ishr r0.w, r1.z, l(3)
-          ishr r2.z, r1.z, l(4)
-          ishr r2.w, r1.z, l(5)
-          ishr r4.z, r1.z, l(6)
-          ishl r5.x, r0.w, l(28)
-          ishl r5.y, r2.z, l(29)
-          ishl r5.z, r2.w, l(30)
-          ishl r0.w, r4.z, l(31)
-          and r5.xyz, r5.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-          iadd r0.z, r0.z, r5.x
-          iadd r0.z, r5.y, r0.z
-          iadd r0.z, r5.z, r0.z
-          iadd r3.x, r0.w, r0.z
-          ishr r0.z, r1.z, l(7)
-          ishr r0.w, r1.z, l(8)
-          ishr r2.z, r1.z, l(9)
-          ishr r2.w, r1.w, l(1)
-          and r0.z, r0.z, l(1)
-          ishl r5.x, r0.w, l(1)
-          ishl r5.y, r2.z, l(2)
-          ishl r5.z, r2.w, l(4)
-          and r5.xyz, r5.xyzx, l(2, 4, 16, 0)
-          iadd r0.z, r0.z, r5.x
-          iadd r0.z, r5.y, r0.z
-          iadd r0.z, r5.w, r0.z
-          iadd r0.z, r5.z, r0.z
-          ishr r0.w, r1.w, l(2)
-          ishr r2.z, r1.w, l(3)
-          ishr r2.w, r1.w, l(4)
-          ishr r4.z, r1.w, l(5)
-          ishl r5.x, r0.w, l(5)
-          ishl r5.y, r2.z, l(6)
-          ishl r5.z, r2.w, l(7)
-          ishl r5.w, r4.z, l(8)
-          and r5.xyzw, r5.xyzw, l(32, 64, 128, 256)
-          iadd r0.z, r0.z, r5.x
-          iadd r0.z, r5.y, r0.z
-          iadd r0.z, r5.z, r0.z
-          iadd r0.z, r5.w, r0.z
-          ishr r0.w, r1.w, l(6)
-          ishr r2.z, r1.w, l(7)
-          ishr r2.w, r1.x, l(10)
-          ishr r4.z, r1.y, l(11)
-          ishl r5.x, r0.w, l(9)
-          ishl r5.y, r2.z, l(10)
-          ishl r5.z, r2.w, l(12)
-          ishl r5.w, r4.z, l(21)
-          and r5.xyzw, r5.xyzw, l(512, 1024, 4096, 0x00200000)
-          iadd r0.z, r0.z, r5.x
-          iadd r0.z, r5.y, r0.z
-          and r0.w, r1.x, l(2048)
-          iadd r0.z, r0.w, r0.z
-          iadd r0.z, r5.z, r0.z
-          ishl r5.x, r4.x, l(13)
-          ishl r5.y, r4.y, l(23)
-          and r2.zw, r5.xxxy, l(0, 0, 8192, 0x00800000)
-          iadd r0.z, r0.z, r2.z
-          ishr r0.w, r4.x, l(1)
-          ishr r2.z, r4.x, l(2)
-          ishr r4.z, r4.x, l(3)
-          ishr r4.w, r4.x, l(4)
-          ishl r6.x, r0.w, l(14)
-          ishl r6.y, r2.z, l(15)
-          ishl r6.z, r4.z, l(16)
-          ishl r6.w, r4.w, l(17)
-          and r6.xyzw, r6.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-          iadd r0.z, r0.z, r6.x
-          iadd r0.z, r6.y, r0.z
-          iadd r0.z, r6.z, r0.z
-          iadd r0.z, r6.w, r0.z
-          ishr r0.w, r4.x, l(5)
-          ishr r2.z, r4.x, l(6)
-          ishr r4.z, r4.x, l(7)
-          ishr r4.w, r4.y, l(1)
-          ishl r6.x, r0.w, l(18)
-          ishl r6.y, r2.z, l(19)
-          ishl r6.z, r4.z, l(20)
-          ishl r6.w, r4.w, l(24)
-          and r6.xyzw, r6.xyzw, l(0x00040000, 0x00080000, 0x00100000, 0x01000000)
-          iadd r0.z, r0.z, r6.x
-          iadd r0.z, r6.y, r0.z
-          iadd r0.z, r6.z, r0.z
-          iadd r0.z, r5.w, r0.z
-          ishr r4.zw, r1.yyyz, l(10)
-          ishr r0.w, r1.z, l(11)
-          ishl r2.z, r4.z, l(22)
-          ishl r0.w, r0.w, l(31)
-          and r2.z, r2.z, l(0x00400000)
-          iadd r0.z, r0.z, r2.z
-          iadd r0.z, r2.w, r0.z
-          iadd r0.z, r6.w, r0.z
-          ishr r2.z, r4.y, l(2)
-          ishr r2.w, r4.y, l(3)
-          ishr r4.z, r4.y, l(4)
-          ishr r5.x, r4.y, l(5)
-          ishl r6.x, r2.z, l(25)
-          ishl r6.y, r2.w, l(26)
-          ishl r6.z, r4.z, l(27)
-          ishl r6.w, r5.x, l(28)
-          and r5.xyzw, r6.xyzw, l(0x02000000, 0x04000000, 0x08000000, 0x10000000)
-          iadd r0.z, r0.z, r5.x
-          iadd r0.z, r5.y, r0.z
-          iadd r0.z, r5.z, r0.z
-          iadd r0.z, r5.w, r0.z
-          ishr r2.z, r4.y, l(6)
-          ishr r2.w, r4.y, l(7)
-          ishl r5.x, r2.z, l(29)
-          ishl r5.y, r2.w, l(30)
-          and r2.zw, r5.xxxy, l(0, 0, 0x20000000, 0x40000000)
-          iadd r0.z, r0.z, r2.z
-          iadd r0.z, r2.w, r0.z
-          iadd r3.z, r0.w, r0.z
-          and r0.z, r4.w, l(1)
-          iadd r3.w, r0.z, r3.w
-        else 
-          ieq r0.z, r2.x, l(14)
-          if_nz r0.z
-            ishl r5.x, r1.x, l(5)
-            ishl r5.y, r1.y, l(15)
-            ishl r5.z, r1.z, l(25)
-            ishl r5.w, r1.w, l(3)
-            and r5.xyzw, r5.xyzw, l(32, 0x00008000, 0x02000000, 8)
-            iadd r0.z, r5.x, l(15)
-            ishr r0.w, r1.x, l(1)
-            ishr r2.z, r1.x, l(2)
-            ishr r2.w, r1.x, l(3)
-            ishr r4.z, r1.x, l(4)
-            ishl r6.x, r0.w, l(6)
-            ishl r6.y, r2.z, l(7)
-            ishl r6.z, r2.w, l(8)
-            ishl r6.w, r4.z, l(9)
-            and r6.xyzw, r6.xyzw, l(64, 128, 256, 512)
-            iadd r0.z, r0.z, r6.x
-            iadd r0.z, r6.y, r0.z
-            iadd r0.z, r6.z, r0.z
-            iadd r0.z, r6.w, r0.z
-            ishr r0.w, r1.x, l(5)
-            ishr r2.z, r1.x, l(6)
-            ishr r2.w, r1.x, l(7)
-            ishr r4.z, r1.x, l(8)
-            ishl r6.x, r0.w, l(10)
-            ishl r6.y, r2.z, l(11)
-            ishl r6.z, r2.w, l(12)
-            ishl r6.w, r4.z, l(13)
-            and r6.xyzw, r6.xyzw, l(1024, 2048, 4096, 8192)
-            iadd r0.z, r0.z, r6.x
-            iadd r0.z, r6.y, r0.z
-            iadd r0.z, r6.z, r0.z
-            iadd r0.z, r6.w, r0.z
-            ishr r0.w, r1.x, l(9)
-            ishr r2.z, r1.y, l(1)
-            ishr r2.w, r1.y, l(2)
-            ishr r4.z, r1.y, l(3)
-            ishl r6.x, r0.w, l(14)
-            ishl r6.y, r2.z, l(16)
-            ishl r6.z, r2.w, l(17)
-            ishl r6.w, r4.z, l(18)
-            and r6.xyzw, r6.xyzw, l(0x00004000, 0x00010000, 0x00020000, 0x00040000)
-            iadd r0.z, r0.z, r6.x
-            iadd r0.z, r5.y, r0.z
-            iadd r0.z, r6.y, r0.z
-            iadd r0.z, r6.z, r0.z
-            iadd r0.z, r6.w, r0.z
-            ishr r0.w, r1.y, l(4)
-            ishr r2.z, r1.y, l(5)
-            ishr r2.w, r1.y, l(6)
-            ishr r4.z, r1.y, l(7)
-            ishl r6.x, r0.w, l(19)
-            ishl r6.y, r2.z, l(20)
-            ishl r6.z, r2.w, l(21)
-            ishl r6.w, r4.z, l(22)
-            and r6.xyzw, r6.xyzw, l(0x00080000, 0x00100000, 0x00200000, 0x00400000)
-            iadd r0.z, r0.z, r6.x
-            iadd r0.z, r6.y, r0.z
-            iadd r0.z, r6.z, r0.z
-            iadd r0.z, r6.w, r0.z
-            ishr r0.w, r1.y, l(8)
-            ishr r2.z, r1.y, l(9)
-            ishr r2.w, r1.z, l(1)
-            ishr r4.z, r1.z, l(2)
-            ishl r6.x, r0.w, l(23)
-            ishl r6.y, r2.z, l(24)
-            ishl r6.z, r2.w, l(26)
-            ishl r6.w, r4.z, l(27)
-            and r6.xyzw, r6.xyzw, l(0x00800000, 0x01000000, 0x04000000, 0x08000000)
-            iadd r0.z, r0.z, r6.x
-            iadd r0.z, r6.y, r0.z
-            iadd r0.z, r5.z, r0.z
-            iadd r0.z, r6.z, r0.z
-            iadd r0.z, r6.w, r0.z
-            ishr r0.w, r1.z, l(3)
-            ishr r2.z, r1.z, l(4)
-            ishr r2.w, r1.z, l(5)
-            ishr r4.z, r1.z, l(6)
-            ishl r5.x, r0.w, l(28)
-            ishl r5.y, r2.z, l(29)
-            ishl r5.z, r2.w, l(30)
-            ishl r0.w, r4.z, l(31)
-            and r5.xyz, r5.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-            iadd r0.z, r0.z, r5.x
-            iadd r0.z, r5.y, r0.z
-            iadd r0.z, r5.z, r0.z
-            iadd r3.x, r0.w, r0.z
-            ishr r0.z, r1.z, l(7)
-            ishr r0.w, r1.z, l(8)
-            ishr r2.z, r1.z, l(9)
-            ishr r2.w, r1.w, l(1)
-            and r0.z, r0.z, l(1)
-            ishl r5.x, r0.w, l(1)
-            ishl r5.y, r2.z, l(2)
-            ishl r5.z, r2.w, l(4)
-            and r5.xyz, r5.xyzx, l(2, 4, 16, 0)
-            iadd r0.z, r0.z, r5.x
-            iadd r0.z, r5.y, r0.z
-            iadd r0.z, r5.w, r0.z
-            iadd r0.z, r5.z, r0.z
-            ishr r0.w, r1.w, l(2)
-            ishr r2.z, r1.w, l(3)
-            ishr r2.w, r1.x, l(15)
-            ishr r4.z, r1.x, l(14)
-            ishl r5.x, r0.w, l(5)
-            ishl r5.y, r2.z, l(6)
-            ishl r5.z, r2.w, l(7)
-            ishl r5.w, r4.z, l(8)
-            and r5.xyzw, r5.xyzw, l(32, 64, 128, 256)
-            iadd r0.z, r0.z, r5.x
-            iadd r0.z, r5.y, r0.z
-            iadd r0.z, r5.z, r0.z
-            iadd r0.z, r5.w, r0.z
-            ishr r0.w, r1.x, l(13)
-            ishr r2.z, r1.x, l(12)
-            ishr r2.w, r1.x, l(10)
-            ishr r4.z, r1.y, l(15)
-            ishl r5.x, r0.w, l(9)
-            ishl r5.y, r2.z, l(10)
-            ishl r5.z, r2.w, l(12)
-            ishl r5.w, r4.z, l(17)
-            and r5.xyzw, r5.xyzw, l(512, 1024, 4096, 0x00020000)
-            iadd r0.z, r0.z, r5.x
-            iadd r0.z, r5.y, r0.z
-            and r0.w, r1.x, l(2048)
-            iadd r0.z, r0.w, r0.z
-            iadd r0.z, r5.z, r0.z
-            ishl r5.x, r4.x, l(13)
-            ishl r5.y, r4.y, l(23)
-            and r2.zw, r5.xxxy, l(0, 0, 8192, 0x00800000)
-            iadd r0.z, r0.z, r2.z
-            ishr r4.zw, r4.xxxy, l(1)
-            ishr r0.w, r4.x, l(2)
-            ishr r2.z, r4.x, l(3)
-            ishl r6.x, r4.z, l(14)
-            ishl r6.y, r0.w, l(15)
-            ishl r6.z, r2.z, l(16)
-            ishl r6.w, r4.w, l(24)
-            and r6.xyzw, r6.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x01000000)
-            iadd r0.z, r0.z, r6.x
-            iadd r0.z, r6.y, r0.z
-            iadd r0.z, r6.z, r0.z
-            iadd r0.z, r5.w, r0.z
-            ishr r0.w, r1.y, l(14)
-            ishr r2.z, r1.y, l(13)
-            ishr r4.z, r1.y, l(12)
-            ishr r4.w, r1.y, l(11)
-            ishl r5.x, r0.w, l(18)
-            ishl r5.y, r2.z, l(19)
-            ishl r5.z, r4.z, l(20)
-            ishl r5.w, r4.w, l(21)
-            and r5.xyzw, r5.xyzw, l(0x00040000, 0x00080000, 0x00100000, 0x00200000)
-            iadd r0.z, r0.z, r5.x
-            iadd r0.z, r5.y, r0.z
-            iadd r0.z, r5.z, r0.z
-            iadd r0.z, r5.w, r0.z
-            ishr r0.w, r1.y, l(10)
-            ishr r2.z, r1.z, l(15)
-            ishr r4.z, r1.z, l(14)
-            ishr r4.w, r1.z, l(13)
-            ishl r5.x, r0.w, l(22)
-            ishl r5.y, r2.z, l(27)
-            ishl r5.z, r4.z, l(28)
-            ishl r5.w, r4.w, l(29)
-            and r5.xyzw, r5.xyzw, l(0x00400000, 0x08000000, 0x10000000, 0x20000000)
-            iadd r0.z, r0.z, r5.x
-            iadd r0.z, r2.w, r0.z
-            iadd r0.z, r6.w, r0.z
-            ishr r0.w, r4.y, l(2)
-            ishr r2.z, r4.y, l(3)
-            ishl r6.x, r0.w, l(25)
-            ishl r6.y, r2.z, l(26)
-            and r2.zw, r6.xxxy, l(0, 0, 0x02000000, 0x04000000)
-            iadd r0.z, r0.z, r2.z
-            iadd r0.z, r2.w, r0.z
-            iadd r0.z, r5.y, r0.z
-            iadd r0.z, r5.z, r0.z
-            iadd r0.z, r5.w, r0.z
-            ishr r0.w, r1.z, l(12)
-            ishr r2.z, r1.z, l(11)
-            ishr r2.w, r1.z, l(10)
-            ishl r0.w, r0.w, l(30)
-            ishl r2.z, r2.z, l(31)
-            and r0.w, r0.w, l(0x40000000)
-            iadd r0.z, r0.w, r0.z
-            iadd r3.z, r2.z, r0.z
-            and r0.z, r2.w, l(1)
-            iadd r3.w, r0.z, r3.w
-          else 
-            mov r3.xz, l(0,0,0,0)
-          endif 
-        endif 
-      endif 
-    endif 
-  else 
-    iadd r0.y, r0.y, l(1)
-    ld_structured r5.xyzw, r0.y, l(52), g0.xyzw
-    ld_structured r6.xy, r0.y, l(68), g0.xyxx
-    and r3.w, r3.x, l(0xfffc0000)
-    ieq r0.y, r2.x, l(1)
-    if_nz r0.y
-      ishr r0.yz, r5.yyzy, l(4)
-      ishr r0.w, r5.y, l(1)
-      ishr r2.z, r5.y, l(2)
-      ishl r7.x, r0.y, l(2)
-      ishl r7.y, r0.z, l(3)
-      ishl r7.z, r0.w, l(10)
-      ishl r7.w, r2.z, l(11)
-      and r7.xyzw, r7.xyzw, l(4, 8, 1024, 2048)
-      iadd r0.y, r7.y, r7.x
-      and r0.z, r6.y, l(16)
-      iadd r0.y, r0.z, r0.y
-      ishl r8.x, r1.x, l(5)
-      ishl r8.y, r1.y, l(15)
-      ishl r8.z, r1.z, l(25)
-      ishl r8.w, r1.w, l(3)
-      and r8.xyzw, r8.xyzw, l(32, 0x00008000, 0x02000000, 8)
-      iadd r0.y, r0.y, r8.x
-      ishr r0.z, r1.x, l(1)
-      ishr r0.w, r1.x, l(2)
-      ishr r2.z, r1.x, l(3)
-      ishr r2.w, r1.x, l(4)
-      ishl r9.x, r0.z, l(6)
-      ishl r9.y, r0.w, l(7)
-      ishl r9.z, r2.z, l(8)
-      ishl r9.w, r2.w, l(9)
-      and r9.xyzw, r9.xyzw, l(64, 128, 256, 512)
-      iadd r0.y, r0.y, r9.x
-      iadd r0.y, r9.y, r0.y
-      iadd r0.y, r9.z, r0.y
-      iadd r0.y, r9.w, r0.y
-      ishr r0.z, r1.x, l(5)
-      ishr r0.w, r1.x, l(6)
-      ishr r2.z, r1.x, l(7)
-      ishr r2.w, r1.x, l(8)
-      ishl r9.x, r0.z, l(10)
-      ishl r9.y, r0.w, l(11)
-      ishl r9.z, r2.z, l(12)
-      ishl r9.w, r2.w, l(13)
-      and r9.xyzw, r9.xyzw, l(1024, 2048, 4096, 8192)
-      iadd r0.y, r0.y, r9.x
-      iadd r0.y, r9.y, r0.y
-      iadd r0.y, r9.z, r0.y
-      iadd r0.y, r9.w, r0.y
-      ishr r0.z, r1.x, l(9)
-      ishr r0.w, r1.y, l(1)
-      ishr r2.z, r1.y, l(2)
-      ishr r2.w, r1.y, l(3)
-      ishl r9.x, r0.z, l(14)
-      ishl r9.y, r0.w, l(16)
-      ishl r9.z, r2.z, l(17)
-      ishl r9.w, r2.w, l(18)
-      and r9.xyzw, r9.xyzw, l(0x00004000, 0x00010000, 0x00020000, 0x00040000)
-      iadd r0.y, r0.y, r9.x
-      iadd r0.y, r8.y, r0.y
-      iadd r0.y, r9.y, r0.y
-      iadd r0.y, r9.z, r0.y
-      iadd r0.y, r9.w, r0.y
-      ishr r0.z, r1.y, l(4)
-      ishr r0.w, r1.y, l(5)
-      ishr r2.z, r1.y, l(6)
-      ishr r2.w, r1.y, l(7)
-      ishl r9.x, r0.z, l(19)
-      ishl r9.y, r0.w, l(20)
-      ishl r9.z, r2.z, l(21)
-      ishl r9.w, r2.w, l(22)
-      and r9.xyzw, r9.xyzw, l(0x00080000, 0x00100000, 0x00200000, 0x00400000)
-      iadd r0.y, r0.y, r9.x
-      iadd r0.y, r9.y, r0.y
-      iadd r0.y, r9.z, r0.y
-      iadd r0.y, r9.w, r0.y
-      ishr r0.z, r1.y, l(8)
-      ishr r0.w, r1.y, l(9)
-      ishr r2.z, r1.z, l(1)
-      ishr r2.w, r1.z, l(2)
-      ishl r9.x, r0.z, l(23)
-      ishl r9.y, r0.w, l(24)
-      ishl r9.z, r2.z, l(26)
-      ishl r9.w, r2.w, l(27)
-      and r9.xyzw, r9.xyzw, l(0x00800000, 0x01000000, 0x04000000, 0x08000000)
-      iadd r0.y, r0.y, r9.x
-      iadd r0.y, r9.y, r0.y
-      iadd r0.y, r8.z, r0.y
-      iadd r0.y, r9.z, r0.y
-      iadd r0.y, r9.w, r0.y
-      ishr r0.z, r1.z, l(3)
-      ishr r0.w, r1.z, l(4)
-      ishr r2.z, r1.z, l(5)
-      ishr r2.w, r1.z, l(6)
-      ishl r8.x, r0.z, l(28)
-      ishl r8.y, r0.w, l(29)
-      ishl r8.z, r2.z, l(30)
-      ishl r0.z, r2.w, l(31)
-      and r8.xyz, r8.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-      iadd r0.y, r0.y, r8.x
-      iadd r0.y, r8.y, r0.y
-      iadd r0.y, r8.z, r0.y
-      iadd r3.x, r0.z, r0.y
-      ishr r0.y, r1.z, l(7)
-      ishr r0.z, r1.z, l(8)
-      ishr r0.w, r1.z, l(9)
-      ishr r2.z, r1.w, l(1)
-      and r0.y, r0.y, l(1)
-      ishl r8.x, r0.z, l(1)
-      ishl r8.y, r0.w, l(2)
-      ishl r8.z, r2.z, l(4)
-      and r8.xyz, r8.xyzx, l(2, 4, 16, 0)
-      iadd r0.y, r0.y, r8.x
-      iadd r0.y, r8.y, r0.y
-      iadd r0.y, r8.w, r0.y
-      iadd r0.y, r8.z, r0.y
-      ishr r0.z, r1.w, l(2)
-      ishr r0.w, r1.w, l(3)
-      ishr r2.z, r1.w, l(4)
-      ishl r8.x, r0.z, l(5)
-      ishl r8.y, r0.w, l(6)
-      ishl r8.z, r2.z, l(7)
-      and r8.xyz, r8.xyzx, l(32, 64, 128, 0)
-      iadd r0.y, r0.y, r8.x
-      iadd r0.y, r8.y, r0.y
-      iadd r0.y, r8.z, r0.y
-      ishr r0.z, r6.x, l(4)
-      ishr r0.w, r6.x, l(1)
-      ishr r2.z, r6.x, l(2)
-      ishr r2.w, r6.x, l(3)
-      ishl r8.x, r0.z, l(8)
-      ishl r8.y, r0.w, l(20)
-      ishl r8.z, r2.z, l(21)
-      ishl r8.w, r2.w, l(22)
-      and r8.xyzw, r8.xyzw, l(256, 0x00100000, 0x00200000, 0x00400000)
-      iadd r0.y, r0.y, r8.x
-      ishl r9.x, r5.y, l(9)
-      ishl r9.y, r5.z, l(29)
-      ishl r9.z, r5.x, l(1)
-      ishl r9.w, r5.w, l(7)
-      and r9.xyzw, r9.xyzw, l(512, 0x20000000, 2, 128)
-      iadd r0.y, r0.y, r9.x
-      iadd r0.y, r7.z, r0.y
-      iadd r0.y, r7.w, r0.y
-      ishr r0.zw, r5.yyyz, l(3)
-      ishr r2.z, r5.z, l(1)
-      ishr r2.w, r5.z, l(2)
-      ishl r7.x, r0.z, l(12)
-      ishl r7.y, r2.z, l(30)
-      ishl r0.z, r2.w, l(31)
-      and r2.zw, r7.xxxy, l(0, 0, 4096, 0x40000000)
-      iadd r0.y, r0.y, r2.z
-      ishl r7.x, r4.x, l(13)
-      ishl r7.y, r4.y, l(23)
-      and r4.zw, r7.xxxy, l(0, 0, 8192, 0x00800000)
-      iadd r0.y, r0.y, r4.z
-      ishr r2.z, r4.x, l(1)
-      ishr r4.z, r4.x, l(2)
-      ishr r6.z, r4.x, l(3)
-      ishr r6.w, r4.x, l(4)
-      ishl r7.x, r2.z, l(14)
-      ishl r7.y, r4.z, l(15)
-      ishl r7.z, r6.z, l(16)
-      ishl r7.w, r6.w, l(17)
-      and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-      iadd r0.y, r0.y, r7.x
-      iadd r0.y, r7.y, r0.y
-      iadd r0.y, r7.z, r0.y
-      iadd r0.y, r7.w, r0.y
-      ishl r7.x, r6.y, l(18)
-      ishl r7.y, r6.x, l(19)
-      and r6.zw, r7.xxxy, l(0, 0, 0x00040000, 0x00080000)
-      iadd r0.y, r0.y, r6.z
-      iadd r0.y, r6.w, r0.y
-      iadd r0.y, r8.y, r0.y
-      iadd r0.y, r8.z, r0.y
-      iadd r0.y, r8.w, r0.y
-      iadd r0.y, r4.w, r0.y
-      ishr r2.z, r4.y, l(1)
-      ishr r4.z, r4.y, l(2)
-      ishr r4.w, r4.y, l(3)
-      ishr r6.z, r4.y, l(4)
-      ishl r7.x, r2.z, l(24)
-      ishl r7.y, r4.z, l(25)
-      ishl r7.z, r4.w, l(26)
-      ishl r7.w, r6.z, l(27)
-      and r7.xyzw, r7.xyzw, l(0x01000000, 0x02000000, 0x04000000, 0x08000000)
-      iadd r0.y, r0.y, r7.x
-      iadd r0.y, r7.y, r0.y
-      iadd r0.y, r7.z, r0.y
-      iadd r0.y, r7.w, r0.y
-      ishr r2.z, r6.y, l(1)
-      ishr r4.z, r6.y, l(2)
-      ishr r4.w, r6.y, l(3)
-      ishl r7.x, r2.z, l(28)
-      ishl r7.y, r4.z, l(6)
-      ishl r7.z, r4.w, l(12)
-      and r7.xyz, r7.xyzx, l(0x10000000, 64, 4096, 0)
-      iadd r0.y, r0.y, r7.x
-      iadd r0.y, r9.y, r0.y
-      iadd r0.y, r2.w, r0.y
-      iadd r3.z, r0.z, r0.y
-      and r0.y, r0.w, l(1)
-      iadd r0.y, r0.y, r3.w
-      iadd r0.y, r9.z, r0.y
-      ishr r0.z, r5.x, l(1)
-      ishr r0.w, r5.x, l(2)
-      ishr r2.z, r5.x, l(3)
-      ishr r2.w, r5.x, l(4)
-      ishl r8.x, r0.z, l(2)
-      ishl r8.y, r0.w, l(3)
-      ishl r8.z, r2.z, l(4)
-      ishl r8.w, r2.w, l(5)
-      and r8.xyzw, r8.xyzw, l(4, 8, 16, 32)
-      iadd r0.y, r0.y, r8.x
-      iadd r0.y, r8.y, r0.y
-      iadd r0.y, r8.z, r0.y
-      iadd r0.y, r8.w, r0.y
-      iadd r0.y, r7.y, r0.y
-      iadd r0.y, r9.w, r0.y
-      ishr r0.z, r5.w, l(1)
-      ishr r0.w, r5.w, l(2)
-      ishr r2.z, r5.w, l(3)
-      ishr r2.w, r5.w, l(4)
-      ishl r8.x, r0.z, l(8)
-      ishl r8.y, r0.w, l(9)
-      ishl r8.z, r2.z, l(10)
-      ishl r8.w, r2.w, l(11)
-      and r8.xyzw, r8.xyzw, l(256, 512, 1024, 2048)
-      iadd r0.y, r0.y, r8.x
-      iadd r0.y, r8.y, r0.y
-      iadd r0.y, r8.z, r0.y
-      iadd r0.y, r8.w, r0.y
-      iadd r0.y, r7.z, r0.y
-      ishl r0.z, r2.y, l(13)
-      and r0.z, r0.z, l(8192)
-      iadd r0.y, r0.z, r0.y
-      ushr r0.z, r2.y, l(1)
-      ushr r0.w, r2.y, l(2)
-      ushr r2.z, r2.y, l(3)
-      ushr r2.w, r2.y, l(4)
-      ishl r7.x, r0.z, l(14)
-      ishl r7.y, r0.w, l(15)
-      ishl r7.z, r2.z, l(16)
-      ishl r7.w, r2.w, l(17)
-      and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-      iadd r0.y, r0.y, r7.x
-      iadd r0.y, r7.y, r0.y
-      iadd r0.y, r7.z, r0.y
-      iadd r3.w, r7.w, r0.y
-    else 
-      ieq r0.y, r2.x, l(2)
-      if_nz r0.y
-        ishr r0.yz, r5.yyzy, l(5)
-        ishr r2.zw, r5.zzzy, l(4)
-        ishl r7.x, r0.y, l(2)
-        ishl r7.y, r2.z, l(14)
-        ishl r7.z, r0.z, l(22)
-        ishl r7.w, r2.w, l(24)
-        and r7.xyzw, r7.xyzw, l(4, 0x00004000, 0x00400000, 0x01000000)
-        iadd r0.y, r7.x, l(1)
-        ishr r0.z, r6.x, l(4)
-        ishr r0.w, r6.x, l(5)
-        ishr r2.z, r6.y, l(1)
-        ishr r2.w, r6.y, l(2)
-        ishl r8.x, r0.z, l(3)
-        ishl r8.y, r0.w, l(4)
-        ishl r8.z, r2.z, l(13)
-        ishl r8.w, r2.w, l(23)
-        and r8.xyzw, r8.xyzw, l(8, 16, 8192, 0x00800000)
-        iadd r0.y, r0.y, r8.x
-        iadd r0.y, r8.y, r0.y
-        ishl r9.x, r1.x, l(5)
-        ishl r9.y, r1.y, l(15)
-        ishl r9.z, r1.z, l(25)
-        ishl r9.w, r1.w, l(3)
-        and r9.xyzw, r9.xyzw, l(32, 0x00008000, 0x02000000, 8)
-        iadd r0.y, r0.y, r9.x
-        ishr r0.z, r1.x, l(1)
-        ishr r0.w, r1.x, l(2)
-        ishr r2.z, r1.x, l(3)
-        ishr r2.w, r1.x, l(4)
-        ishl r10.x, r0.z, l(6)
-        ishl r10.y, r0.w, l(7)
-        ishl r10.z, r2.z, l(8)
-        ishl r10.w, r2.w, l(9)
-        and r10.xyzw, r10.xyzw, l(64, 128, 256, 512)
-        iadd r0.y, r0.y, r10.x
-        iadd r0.y, r10.y, r0.y
-        iadd r0.y, r10.z, r0.y
-        iadd r0.y, r10.w, r0.y
-        ishr r0.z, r1.x, l(5)
-        ishr r0.w, r1.x, l(6)
-        ishr r2.z, r1.y, l(1)
-        ishr r2.w, r1.y, l(2)
-        ishl r10.x, r0.z, l(10)
-        ishl r10.y, r0.w, l(11)
-        ishl r10.z, r2.z, l(16)
-        ishl r10.w, r2.w, l(17)
-        and r10.xyzw, r10.xyzw, l(1024, 2048, 0x00010000, 0x00020000)
-        iadd r0.y, r0.y, r10.x
-        iadd r0.y, r10.y, r0.y
-        ishl r8.x, r6.y, l(12)
-        ishl r8.y, r6.x, l(19)
-        and r0.zw, r8.xxxy, l(0, 0, 4096, 0x00080000)
-        iadd r0.y, r0.z, r0.y
-        iadd r0.y, r8.z, r0.y
-        iadd r0.y, r7.y, r0.y
-        iadd r0.y, r9.y, r0.y
-        iadd r0.y, r10.z, r0.y
-        iadd r0.y, r10.w, r0.y
-        ishr r0.z, r1.y, l(3)
-        ishr r2.z, r1.y, l(4)
-        ishr r2.w, r1.y, l(5)
-        ishr r4.z, r1.y, l(6)
-        ishl r10.x, r0.z, l(18)
-        ishl r10.y, r2.z, l(19)
-        ishl r10.z, r2.w, l(20)
-        ishl r10.w, r4.z, l(21)
-        and r10.xyzw, r10.xyzw, l(0x00040000, 0x00080000, 0x00100000, 0x00200000)
-        iadd r0.y, r0.y, r10.x
-        iadd r0.y, r10.y, r0.y
-        iadd r0.y, r10.z, r0.y
-        iadd r0.y, r10.w, r0.y
-        iadd r0.y, r7.z, r0.y
-        iadd r0.y, r8.w, r0.y
-        iadd r0.y, r7.w, r0.y
-        iadd r0.y, r9.z, r0.y
-        ishr r0.z, r1.z, l(1)
-        ishr r2.z, r1.z, l(2)
-        ishr r2.w, r1.z, l(3)
-        ishr r4.z, r1.z, l(4)
-        ishl r7.x, r0.z, l(26)
-        ishl r7.y, r2.z, l(27)
-        ishl r7.z, r2.w, l(28)
-        ishl r7.w, r4.z, l(29)
-        and r7.xyzw, r7.xyzw, l(0x04000000, 0x08000000, 0x10000000, 0x20000000)
-        iadd r0.y, r0.y, r7.x
-        iadd r0.y, r7.y, r0.y
-        iadd r0.y, r7.z, r0.y
-        iadd r0.y, r7.w, r0.y
-        ishr r0.z, r1.z, l(5)
-        ishr r2.z, r1.z, l(6)
-        ishr r2.w, r1.w, l(1)
-        ishr r4.z, r1.w, l(2)
-        ishl r7.x, r0.z, l(30)
-        ishl r0.z, r2.z, l(31)
-        ishl r7.z, r2.w, l(4)
-        ishl r7.w, r4.z, l(5)
-        and r7.xyz, r7.xzwx, l(0x40000000, 16, 32, 0)
-        iadd r0.y, r0.y, r7.x
-        iadd r3.x, r0.z, r0.y
-        ishr r0.y, r6.y, l(3)
-        ishr r0.z, r6.y, l(5)
-        ishr r2.z, r6.y, l(4)
-        ishr r2.w, r6.x, l(1)
-        and r0.y, r0.y, l(1)
-        ishl r8.x, r0.z, l(1)
-        ishl r8.y, r2.z, l(2)
-        ishl r8.z, r2.w, l(20)
-        and r8.xyz, r8.xyzx, l(2, 4, 0x00100000, 0)
-        iadd r0.y, r0.y, r8.x
-        iadd r0.y, r8.y, r0.y
-        iadd r0.y, r9.w, r0.y
-        iadd r0.y, r7.y, r0.y
-        iadd r0.y, r7.z, r0.y
-        ishr r0.z, r1.w, l(3)
-        ishr r2.z, r1.w, l(4)
-        ishr r2.w, r1.w, l(5)
-        ishl r7.x, r0.z, l(6)
-        ishl r7.y, r2.z, l(7)
-        ishl r7.z, r2.w, l(8)
-        and r7.xyz, r7.xyzx, l(64, 128, 256, 0)
-        iadd r0.y, r0.y, r7.x
-        iadd r0.y, r7.y, r0.y
-        iadd r0.y, r7.z, r0.y
-        ishl r7.x, r5.y, l(9)
-        ishl r7.y, r5.z, l(29)
-        ishl r7.z, r5.x, l(1)
-        ishl r7.w, r5.w, l(7)
-        and r7.xyzw, r7.xyzw, l(512, 0x20000000, 2, 128)
-        iadd r0.y, r0.y, r7.x
-        ishr r2.zw, r5.yyyz, l(1)
-        ishr r0.z, r5.y, l(2)
-        ishr r4.z, r5.y, l(3)
-        ishl r9.x, r2.z, l(10)
-        ishl r9.y, r0.z, l(11)
-        ishl r9.z, r4.z, l(12)
-        ishl r9.w, r2.w, l(30)
-        and r9.xyzw, r9.xyzw, l(1024, 2048, 4096, 0x40000000)
-        iadd r0.y, r0.y, r9.x
-        iadd r0.y, r9.y, r0.y
-        iadd r0.y, r9.z, r0.y
-        ishl r8.x, r4.x, l(13)
-        ishl r8.y, r4.y, l(23)
-        and r2.zw, r8.xxxy, l(0, 0, 8192, 0x00800000)
-        iadd r0.y, r0.y, r2.z
-        ishr r0.z, r4.x, l(1)
-        ishr r2.z, r4.x, l(2)
-        ishr r4.z, r4.x, l(3)
-        ishr r4.w, r4.x, l(4)
-        ishl r10.x, r0.z, l(14)
-        ishl r10.y, r2.z, l(15)
-        ishl r10.z, r4.z, l(16)
-        ishl r10.w, r4.w, l(17)
-        and r10.xyzw, r10.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-        iadd r0.y, r0.y, r10.x
-        iadd r0.y, r10.y, r0.y
-        iadd r0.y, r10.z, r0.y
-        iadd r0.y, r10.w, r0.y
-        ishr r0.z, r4.x, l(5)
-        ishr r2.z, r4.y, l(1)
-        ishr r4.z, r4.y, l(2)
-        ishr r4.w, r4.y, l(3)
-        ishl r10.x, r0.z, l(18)
-        ishl r10.y, r2.z, l(24)
-        ishl r10.z, r4.z, l(25)
-        ishl r10.w, r4.w, l(26)
-        and r10.xyzw, r10.xyzw, l(0x00040000, 0x01000000, 0x02000000, 0x04000000)
-        iadd r0.y, r0.y, r10.x
-        iadd r0.y, r0.w, r0.y
-        iadd r0.y, r8.z, r0.y
-        ishr r0.z, r6.x, l(2)
-        ishr r0.w, r6.x, l(3)
-        ishl r8.x, r0.z, l(21)
-        ishl r8.y, r0.w, l(22)
-        and r0.zw, r8.xxxy, l(0, 0, 0x00200000, 0x00400000)
-        iadd r0.y, r0.z, r0.y
-        iadd r0.y, r0.w, r0.y
-        iadd r0.y, r2.w, r0.y
-        iadd r0.y, r10.y, r0.y
-        iadd r0.y, r10.z, r0.y
-        iadd r0.y, r10.w, r0.y
-        ishr r0.z, r4.y, l(4)
-        ishr r0.w, r4.y, l(5)
-        ishl r8.x, r0.z, l(27)
-        ishl r8.y, r0.w, l(28)
-        and r0.zw, r8.xxxy, l(0, 0, 0x08000000, 0x10000000)
-        iadd r0.y, r0.z, r0.y
-        iadd r0.y, r0.w, r0.y
-        iadd r0.y, r7.y, r0.y
-        iadd r0.y, r9.w, r0.y
-        ishr r0.zw, r5.zzzx, l(2)
-        ishr r2.z, r5.z, l(3)
-        ishr r2.w, r5.x, l(1)
-        ishl r8.x, r0.z, l(31)
-        ishl r8.y, r2.w, l(2)
-        ishl r8.z, r0.w, l(3)
-        iadd r3.z, r0.y, r8.x
-        and r0.y, r2.z, l(1)
-        iadd r0.y, r0.y, r3.w
-        iadd r0.y, r7.z, r0.y
-        and r0.zw, r8.yyyz, l(0, 0, 4, 8)
-        iadd r0.y, r0.z, r0.y
-        iadd r0.y, r0.w, r0.y
-        ishr r0.z, r5.x, l(3)
-        ishr r0.w, r5.x, l(4)
-        ishr r2.z, r5.x, l(5)
-        ishr r2.w, r5.w, l(1)
-        ishl r8.x, r0.z, l(4)
-        ishl r8.y, r0.w, l(5)
-        ishl r8.z, r2.z, l(6)
-        ishl r8.w, r2.w, l(8)
-        and r8.xyzw, r8.xyzw, l(16, 32, 64, 256)
-        iadd r0.y, r0.y, r8.x
-        iadd r0.y, r8.y, r0.y
-        iadd r0.y, r8.z, r0.y
-        iadd r0.y, r7.w, r0.y
-        iadd r0.y, r8.w, r0.y
-        ishr r0.z, r5.w, l(2)
-        ishr r0.w, r5.w, l(3)
-        ishr r2.z, r5.w, l(4)
-        ishr r2.w, r5.w, l(5)
-        ishl r7.x, r0.z, l(9)
-        ishl r7.y, r0.w, l(10)
-        ishl r7.z, r2.z, l(11)
-        ishl r7.w, r2.w, l(12)
-        and r7.xyzw, r7.xyzw, l(512, 1024, 2048, 4096)
-        iadd r0.y, r0.y, r7.x
-        iadd r0.y, r7.y, r0.y
-        iadd r0.y, r7.z, r0.y
-        iadd r0.y, r7.w, r0.y
-        ishl r0.z, r2.y, l(13)
-        and r0.z, r0.z, l(8192)
-        iadd r0.y, r0.z, r0.y
-        ushr r0.z, r2.y, l(1)
-        ushr r0.w, r2.y, l(2)
-        ushr r2.z, r2.y, l(3)
-        ushr r2.w, r2.y, l(4)
-        ishl r7.x, r0.z, l(14)
-        ishl r7.y, r0.w, l(15)
-        ishl r7.z, r2.z, l(16)
-        ishl r7.w, r2.w, l(17)
-        and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-        iadd r0.y, r0.y, r7.x
-        iadd r0.y, r7.y, r0.y
-        iadd r0.y, r7.z, r0.y
-        iadd r3.w, r7.w, r0.y
-      else 
-        ieq r0.y, r2.x, l(3)
-        if_nz r0.y
-          ishl r7.x, r1.x, l(5)
-          ishl r7.y, r1.y, l(15)
-          ishl r7.z, r1.z, l(25)
-          ishl r7.w, r1.w, l(3)
-          and r7.xyzw, r7.xyzw, l(32, 0x00008000, 0x02000000, 8)
-          iadd r0.y, r7.x, l(2)
-          ishr r0.z, r1.x, l(1)
-          ishr r0.w, r1.x, l(2)
-          ishr r2.z, r1.x, l(3)
-          ishr r2.w, r1.x, l(4)
-          ishl r8.x, r0.z, l(6)
-          ishl r8.y, r0.w, l(7)
-          ishl r8.z, r2.z, l(8)
-          ishl r8.w, r2.w, l(9)
-          and r8.xyzw, r8.xyzw, l(64, 128, 256, 512)
-          iadd r0.y, r0.y, r8.x
-          iadd r0.y, r8.y, r0.y
-          iadd r0.y, r8.z, r0.y
-          iadd r0.y, r8.w, r0.y
-          ishr r0.z, r1.x, l(5)
-          ishr r0.w, r1.x, l(6)
-          ishr r2.z, r1.x, l(7)
-          ishr r2.w, r1.x, l(8)
-          ishl r8.x, r0.z, l(10)
-          ishl r8.y, r0.w, l(11)
-          ishl r8.z, r2.z, l(12)
-          ishl r8.w, r2.w, l(13)
-          and r8.xyzw, r8.xyzw, l(1024, 2048, 4096, 8192)
-          iadd r0.y, r0.y, r8.x
-          iadd r0.y, r8.y, r0.y
-          iadd r0.y, r8.z, r0.y
-          iadd r0.y, r8.w, r0.y
-          ishr r0.z, r1.x, l(9)
-          ishr r0.w, r1.y, l(1)
-          ishr r2.z, r1.y, l(2)
-          ishr r2.w, r1.y, l(3)
-          ishl r8.x, r0.z, l(14)
-          ishl r8.y, r0.w, l(16)
-          ishl r8.z, r2.z, l(17)
-          ishl r8.w, r2.w, l(18)
-          and r8.xyzw, r8.xyzw, l(0x00004000, 0x00010000, 0x00020000, 0x00040000)
-          iadd r0.y, r0.y, r8.x
-          iadd r0.y, r7.y, r0.y
-          iadd r0.y, r8.y, r0.y
-          iadd r0.y, r8.z, r0.y
-          iadd r0.y, r8.w, r0.y
-          ishr r0.z, r1.y, l(4)
-          ishr r0.w, r1.y, l(5)
-          ishr r2.z, r1.y, l(6)
-          ishr r2.w, r1.y, l(7)
-          ishl r8.x, r0.z, l(19)
-          ishl r8.y, r0.w, l(20)
-          ishl r8.z, r2.z, l(21)
-          ishl r8.w, r2.w, l(22)
-          and r8.xyzw, r8.xyzw, l(0x00080000, 0x00100000, 0x00200000, 0x00400000)
-          iadd r0.y, r0.y, r8.x
-          iadd r0.y, r8.y, r0.y
-          iadd r0.y, r8.z, r0.y
-          iadd r0.y, r8.w, r0.y
-          ishr r0.z, r1.y, l(8)
-          ishr r0.w, r1.y, l(9)
-          ishr r2.z, r1.z, l(1)
-          ishr r2.w, r1.z, l(2)
-          ishl r8.x, r0.z, l(23)
-          ishl r8.y, r0.w, l(24)
-          ishl r8.z, r2.z, l(26)
-          ishl r8.w, r2.w, l(27)
-          and r8.xyzw, r8.xyzw, l(0x00800000, 0x01000000, 0x04000000, 0x08000000)
-          iadd r0.y, r0.y, r8.x
-          iadd r0.y, r8.y, r0.y
-          iadd r0.y, r7.z, r0.y
-          iadd r0.y, r8.z, r0.y
-          iadd r0.y, r8.w, r0.y
-          ishr r0.z, r1.z, l(3)
-          ishr r0.w, r1.z, l(4)
-          ishr r2.z, r1.z, l(5)
-          ishr r2.w, r1.z, l(6)
-          ishl r7.x, r0.z, l(28)
-          ishl r7.y, r0.w, l(29)
-          ishl r7.z, r2.z, l(30)
-          ishl r0.z, r2.w, l(31)
-          and r7.xyz, r7.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-          iadd r0.y, r0.y, r7.x
-          iadd r0.y, r7.y, r0.y
-          iadd r0.y, r7.z, r0.y
-          iadd r3.x, r0.z, r0.y
-          ishr r0.y, r1.z, l(7)
-          ishr r0.z, r1.z, l(8)
-          ishr r0.w, r1.z, l(9)
-          ishr r2.z, r1.w, l(1)
-          and r0.y, r0.y, l(1)
-          ishl r7.x, r0.z, l(1)
-          ishl r7.y, r0.w, l(2)
-          ishl r7.z, r2.z, l(4)
-          and r7.xyz, r7.xyzx, l(2, 4, 16, 0)
-          iadd r0.y, r0.y, r7.x
-          iadd r0.y, r7.y, r0.y
-          iadd r0.y, r7.w, r0.y
-          iadd r0.y, r7.z, r0.y
-          ishr r0.z, r1.w, l(2)
-          ishr r0.w, r1.w, l(3)
-          ishr r2.z, r1.w, l(4)
-          ishr r2.w, r1.x, l(10)
-          ishl r7.x, r0.z, l(5)
-          ishl r7.y, r0.w, l(6)
-          ishl r7.z, r2.z, l(7)
-          ishl r7.w, r2.w, l(8)
-          and r7.xyzw, r7.xyzw, l(32, 64, 128, 256)
-          iadd r0.y, r0.y, r7.x
-          iadd r0.y, r7.y, r0.y
-          iadd r0.y, r7.z, r0.y
-          iadd r0.y, r7.w, r0.y
-          ishl r7.x, r5.y, l(9)
-          ishl r7.y, r5.z, l(29)
-          ishl r7.z, r5.x, l(1)
-          ishl r7.w, r5.w, l(7)
-          and r7.xyzw, r7.xyzw, l(512, 0x20000000, 2, 128)
-          iadd r0.y, r0.y, r7.x
-          ishr r0.zw, r5.yyyz, l(1)
-          ishr r2.z, r5.y, l(2)
-          ishr r2.w, r5.y, l(3)
-          ishl r8.x, r0.z, l(10)
-          ishl r8.y, r2.z, l(11)
-          ishl r8.z, r2.w, l(12)
-          ishl r8.w, r0.w, l(30)
-          and r8.xyzw, r8.xyzw, l(1024, 2048, 4096, 0x40000000)
-          iadd r0.y, r0.y, r8.x
-          iadd r0.y, r8.y, r0.y
-          iadd r0.y, r8.z, r0.y
-          ishl r8.x, r4.x, l(13)
-          ishl r8.y, r4.y, l(23)
-          and r0.zw, r8.xxxy, l(0, 0, 8192, 0x00800000)
-          iadd r0.y, r0.z, r0.y
-          ishr r2.zw, r4.xxxy, l(1)
-          ishr r0.z, r4.x, l(2)
-          ishr r4.z, r4.x, l(3)
-          ishl r9.x, r2.z, l(14)
-          ishl r9.y, r0.z, l(15)
-          ishl r9.z, r4.z, l(16)
-          ishl r9.w, r2.w, l(24)
-          and r9.xyzw, r9.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x01000000)
-          iadd r0.y, r0.y, r9.x
-          iadd r0.y, r9.y, r0.y
-          iadd r0.y, r9.z, r0.y
-          ishr r2.zw, r1.yyyz, l(10)
-          ishl r8.x, r2.z, l(17)
-          ishl r8.y, r2.w, l(27)
-          and r2.zw, r8.xxxy, l(0, 0, 0x00020000, 0x08000000)
-          iadd r0.y, r0.y, r2.z
-          ishl r8.x, r6.y, l(18)
-          ishl r8.y, r6.x, l(19)
-          and r4.zw, r8.xxxy, l(0, 0, 0x00040000, 0x00080000)
-          iadd r0.y, r0.y, r4.z
-          iadd r0.y, r4.w, r0.y
-          ishr r4.zw, r6.xxxy, l(1)
-          ishr r0.z, r6.x, l(2)
-          ishr r2.z, r6.x, l(3)
-          ishl r10.x, r4.z, l(20)
-          ishl r10.y, r0.z, l(21)
-          ishl r10.z, r2.z, l(22)
-          ishl r10.w, r4.w, l(28)
-          and r10.xyzw, r10.xyzw, l(0x00100000, 0x00200000, 0x00400000, 0x10000000)
-          iadd r0.y, r0.y, r10.x
-          iadd r0.y, r10.y, r0.y
-          iadd r0.y, r10.z, r0.y
-          iadd r0.y, r0.w, r0.y
-          iadd r0.y, r9.w, r0.y
-          ishr r0.z, r4.y, l(2)
-          ishr r0.w, r4.y, l(3)
-          ishl r8.x, r0.z, l(25)
-          ishl r8.y, r0.w, l(26)
-          and r0.zw, r8.xxxy, l(0, 0, 0x02000000, 0x04000000)
-          iadd r0.y, r0.z, r0.y
-          iadd r0.y, r0.w, r0.y
-          iadd r0.y, r2.w, r0.y
-          iadd r0.y, r10.w, r0.y
-          iadd r0.y, r7.y, r0.y
-          iadd r0.y, r8.w, r0.y
-          ishr r0.zw, r5.zzzx, l(2)
-          ishr r2.z, r5.z, l(3)
-          ishr r2.w, r5.x, l(1)
-          ishl r8.x, r0.z, l(31)
-          ishl r8.y, r2.w, l(2)
-          ishl r8.z, r0.w, l(3)
-          iadd r3.z, r0.y, r8.x
-          and r0.y, r2.z, l(1)
-          iadd r0.y, r0.y, r3.w
-          iadd r0.y, r7.z, r0.y
-          and r0.zw, r8.yyyz, l(0, 0, 4, 8)
-          iadd r0.y, r0.z, r0.y
-          iadd r0.y, r0.w, r0.y
-          ishr r0.z, r5.x, l(3)
-          ishr r0.w, r5.x, l(4)
-          ishr r2.z, r5.w, l(1)
-          ishr r2.w, r5.w, l(2)
-          ishl r8.x, r0.z, l(4)
-          ishl r8.y, r0.w, l(5)
-          ishl r8.z, r2.z, l(8)
-          ishl r8.w, r2.w, l(9)
-          and r8.xyzw, r8.xyzw, l(16, 32, 256, 512)
-          iadd r0.y, r0.y, r8.x
-          iadd r0.y, r8.y, r0.y
-          ishr r0.z, r6.y, l(2)
-          ishr r0.w, r6.y, l(3)
-          ishl r7.x, r0.z, l(6)
-          ishl r7.y, r0.w, l(12)
-          and r0.zw, r7.xxxy, l(0, 0, 64, 4096)
-          iadd r0.y, r0.z, r0.y
-          iadd r0.y, r7.w, r0.y
-          iadd r0.y, r8.z, r0.y
-          iadd r0.y, r8.w, r0.y
-          ishr r0.z, r5.w, l(3)
-          ishr r2.z, r5.w, l(4)
-          ishl r7.x, r0.z, l(10)
-          ishl r7.y, r2.z, l(11)
-          and r2.zw, r7.xxxy, l(0, 0, 1024, 2048)
-          iadd r0.y, r0.y, r2.z
-          iadd r0.y, r2.w, r0.y
-          iadd r0.y, r0.w, r0.y
-          ishl r0.z, r2.y, l(13)
-          and r0.z, r0.z, l(8192)
-          iadd r0.y, r0.z, r0.y
-          ushr r0.z, r2.y, l(1)
-          ushr r0.w, r2.y, l(2)
-          ushr r2.z, r2.y, l(3)
-          ushr r2.w, r2.y, l(4)
-          ishl r7.x, r0.z, l(14)
-          ishl r7.y, r0.w, l(15)
-          ishl r7.z, r2.z, l(16)
-          ishl r7.w, r2.w, l(17)
-          and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-          iadd r0.y, r0.y, r7.x
-          iadd r0.y, r7.y, r0.y
-          iadd r0.y, r7.z, r0.y
-          iadd r3.w, r7.w, r0.y
-        else 
-          ieq r0.y, r2.x, l(4)
-          if_nz r0.y
-            ishl r7.x, r1.x, l(5)
-            ishl r7.y, r1.y, l(15)
-            ishl r7.z, r1.z, l(25)
-            ishl r7.w, r1.w, l(3)
-            and r7.xyzw, r7.xyzw, l(32, 0x00008000, 0x02000000, 8)
-            iadd r0.y, r7.x, l(6)
-            ishr r0.z, r1.x, l(1)
-            ishr r0.w, r1.x, l(2)
-            ishr r2.z, r1.x, l(3)
-            ishr r2.w, r1.x, l(4)
-            ishl r8.x, r0.z, l(6)
-            ishl r8.y, r0.w, l(7)
-            ishl r8.z, r2.z, l(8)
-            ishl r8.w, r2.w, l(9)
-            and r8.xyzw, r8.xyzw, l(64, 128, 256, 512)
-            iadd r0.y, r0.y, r8.x
-            iadd r0.y, r8.y, r0.y
-            iadd r0.y, r8.z, r0.y
-            iadd r0.y, r8.w, r0.y
-            ishr r0.z, r1.x, l(5)
-            ishr r0.w, r1.x, l(6)
-            ishr r2.z, r1.x, l(7)
-            ishr r2.w, r1.x, l(8)
-            ishl r8.x, r0.z, l(10)
-            ishl r8.y, r0.w, l(11)
-            ishl r8.z, r2.z, l(12)
-            ishl r8.w, r2.w, l(13)
-            and r8.xyzw, r8.xyzw, l(1024, 2048, 4096, 8192)
-            iadd r0.y, r0.y, r8.x
-            iadd r0.y, r8.y, r0.y
-            iadd r0.y, r8.z, r0.y
-            iadd r0.y, r8.w, r0.y
-            ishr r0.z, r1.x, l(9)
-            ishr r0.w, r1.y, l(1)
-            ishr r2.z, r1.y, l(2)
-            ishr r2.w, r1.y, l(3)
-            ishl r8.x, r0.z, l(14)
-            ishl r8.y, r0.w, l(16)
-            ishl r8.z, r2.z, l(17)
-            ishl r8.w, r2.w, l(18)
-            and r8.xyzw, r8.xyzw, l(0x00004000, 0x00010000, 0x00020000, 0x00040000)
-            iadd r0.y, r0.y, r8.x
-            iadd r0.y, r7.y, r0.y
-            iadd r0.y, r8.y, r0.y
-            iadd r0.y, r8.z, r0.y
-            iadd r0.y, r8.w, r0.y
-            ishr r0.z, r1.y, l(4)
-            ishr r0.w, r1.y, l(5)
-            ishr r2.z, r1.y, l(6)
-            ishr r2.w, r1.y, l(7)
-            ishl r8.x, r0.z, l(19)
-            ishl r8.y, r0.w, l(20)
-            ishl r8.z, r2.z, l(21)
-            ishl r8.w, r2.w, l(22)
-            and r8.xyzw, r8.xyzw, l(0x00080000, 0x00100000, 0x00200000, 0x00400000)
-            iadd r0.y, r0.y, r8.x
-            iadd r0.y, r8.y, r0.y
-            iadd r0.y, r8.z, r0.y
-            iadd r0.y, r8.w, r0.y
-            ishr r0.z, r1.y, l(8)
-            ishr r0.w, r1.y, l(9)
-            ishr r2.z, r1.z, l(1)
-            ishr r2.w, r1.z, l(2)
-            ishl r8.x, r0.z, l(23)
-            ishl r8.y, r0.w, l(24)
-            ishl r8.z, r2.z, l(26)
-            ishl r8.w, r2.w, l(27)
-            and r8.xyzw, r8.xyzw, l(0x00800000, 0x01000000, 0x04000000, 0x08000000)
-            iadd r0.y, r0.y, r8.x
-            iadd r0.y, r8.y, r0.y
-            iadd r0.y, r7.z, r0.y
-            iadd r0.y, r8.z, r0.y
-            iadd r0.y, r8.w, r0.y
-            ishr r0.z, r1.z, l(3)
-            ishr r0.w, r1.z, l(4)
-            ishr r2.z, r1.z, l(5)
-            ishr r2.w, r1.z, l(6)
-            ishl r7.x, r0.z, l(28)
-            ishl r7.y, r0.w, l(29)
-            ishl r7.z, r2.z, l(30)
-            ishl r0.z, r2.w, l(31)
-            and r7.xyz, r7.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-            iadd r0.y, r0.y, r7.x
-            iadd r0.y, r7.y, r0.y
-            iadd r0.y, r7.z, r0.y
-            iadd r3.x, r0.z, r0.y
-            ishr r0.y, r1.z, l(7)
-            ishr r0.z, r1.z, l(8)
-            ishr r0.w, r1.z, l(9)
-            ishr r2.z, r1.w, l(1)
-            and r0.y, r0.y, l(1)
-            ishl r7.x, r0.z, l(1)
-            ishl r7.y, r0.w, l(2)
-            ishl r7.z, r2.z, l(4)
-            and r7.xyz, r7.xyzx, l(2, 4, 16, 0)
-            iadd r0.y, r0.y, r7.x
-            iadd r0.y, r7.y, r0.y
-            iadd r0.y, r7.w, r0.y
-            iadd r0.y, r7.z, r0.y
-            ishr r0.z, r1.w, l(2)
-            ishr r0.w, r1.w, l(3)
-            ishr r2.zw, r1.xxxy, l(10)
-            ishl r7.x, r0.z, l(5)
-            ishl r7.y, r0.w, l(6)
-            ishl r7.z, r2.z, l(7)
-            ishl r7.w, r2.w, l(18)
-            and r7.xyzw, r7.xyzw, l(32, 64, 128, 0x00040000)
-            iadd r0.y, r0.y, r7.x
-            iadd r0.y, r7.y, r0.y
-            iadd r0.y, r7.z, r0.y
-            ishr r0.z, r6.x, l(4)
-            ishr r0.w, r6.x, l(1)
-            ishr r2.z, r6.x, l(2)
-            ishr r2.w, r6.x, l(3)
-            ishl r8.x, r0.z, l(8)
-            ishl r8.y, r0.w, l(20)
-            ishl r8.z, r2.z, l(21)
-            ishl r8.w, r2.w, l(22)
-            and r8.xyzw, r8.xyzw, l(256, 0x00100000, 0x00200000, 0x00400000)
-            iadd r0.y, r0.y, r8.x
-            ishl r9.x, r5.y, l(9)
-            ishl r9.y, r5.z, l(29)
-            ishl r9.z, r5.x, l(1)
-            ishl r9.w, r5.w, l(7)
-            and r9.xyzw, r9.xyzw, l(512, 0x20000000, 2, 128)
-            iadd r0.y, r0.y, r9.x
-            ishr r0.zw, r5.yyyz, l(1)
-            ishr r2.z, r5.y, l(2)
-            ishr r2.w, r5.y, l(3)
-            ishl r10.x, r0.z, l(10)
-            ishl r10.y, r2.z, l(11)
-            ishl r10.z, r2.w, l(12)
-            ishl r10.w, r0.w, l(30)
-            and r10.xyzw, r10.xyzw, l(1024, 2048, 4096, 0x40000000)
-            iadd r0.y, r0.y, r10.x
-            iadd r0.y, r10.y, r0.y
-            iadd r0.y, r10.z, r0.y
-            ishl r7.x, r4.x, l(13)
-            ishl r7.y, r4.y, l(23)
-            and r0.zw, r7.xxxy, l(0, 0, 8192, 0x00800000)
-            iadd r0.y, r0.z, r0.y
-            ishr r0.z, r4.x, l(1)
-            ishr r2.z, r4.x, l(2)
-            ishr r2.w, r4.x, l(3)
-            ishr r4.z, r4.x, l(4)
-            ishl r11.x, r0.z, l(14)
-            ishl r11.y, r2.z, l(15)
-            ishl r11.z, r2.w, l(16)
-            ishl r11.w, r4.z, l(17)
-            and r11.xyzw, r11.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-            iadd r0.y, r0.y, r11.x
-            iadd r0.y, r11.y, r0.y
-            iadd r0.y, r11.z, r0.y
-            iadd r0.y, r11.w, r0.y
-            iadd r0.y, r7.w, r0.y
-            ishl r7.x, r6.x, l(19)
-            ishl r7.y, r6.y, l(5)
-            and r2.zw, r7.xxxy, l(0, 0, 0x00080000, 32)
-            iadd r0.y, r0.y, r2.z
-            iadd r0.y, r8.y, r0.y
-            iadd r0.y, r8.z, r0.y
-            iadd r0.y, r8.w, r0.y
-            iadd r0.y, r0.w, r0.y
-            ishr r0.z, r4.y, l(1)
-            ishr r0.w, r4.y, l(2)
-            ishr r2.z, r4.y, l(3)
-            ishl r7.x, r0.z, l(24)
-            ishl r7.y, r0.w, l(25)
-            ishl r7.z, r2.z, l(26)
-            and r7.xyz, r7.xyzx, l(0x01000000, 0x02000000, 0x04000000, 0)
-            iadd r0.y, r0.y, r7.x
-            iadd r0.y, r7.y, r0.y
-            iadd r0.y, r7.z, r0.y
-            ishr r0.z, r1.z, l(10)
-            ishl r0.z, r0.z, l(27)
-            and r0.z, r0.z, l(0x08000000)
-            iadd r0.y, r0.z, r0.y
-            ishr r0.z, r6.y, l(1)
-            ishr r0.w, r6.y, l(2)
-            ishr r2.z, r6.y, l(3)
-            ishl r7.x, r0.z, l(28)
-            ishl r7.y, r0.w, l(6)
-            ishl r7.z, r2.z, l(12)
-            and r7.xyz, r7.xyzx, l(0x10000000, 64, 4096, 0)
-            iadd r0.y, r0.y, r7.x
-            iadd r0.y, r9.y, r0.y
-            iadd r0.y, r10.w, r0.y
-            ishr r0.zw, r5.zzzx, l(2)
-            ishr r2.z, r5.z, l(3)
-            ishr r4.z, r5.x, l(1)
-            ishl r8.x, r0.z, l(31)
-            ishl r8.y, r4.z, l(2)
-            ishl r8.z, r0.w, l(3)
-            iadd r3.z, r0.y, r8.x
-            and r0.y, r2.z, l(1)
-            iadd r0.y, r0.y, r3.w
-            iadd r0.y, r9.z, r0.y
-            and r0.zw, r8.yyyz, l(0, 0, 4, 8)
-            iadd r0.y, r0.z, r0.y
-            iadd r0.y, r0.w, r0.y
-            ishr r0.zw, r5.xxxw, l(3)
-            ishr r2.z, r5.w, l(1)
-            ishr r4.z, r5.w, l(2)
-            ishl r8.x, r0.z, l(4)
-            ishl r8.y, r2.z, l(8)
-            ishl r8.z, r4.z, l(9)
-            ishl r8.w, r0.w, l(10)
-            and r8.xyzw, r8.xyzw, l(16, 256, 512, 1024)
-            iadd r0.y, r0.y, r8.x
-            iadd r0.y, r2.w, r0.y
-            iadd r0.y, r7.y, r0.y
-            iadd r0.y, r9.w, r0.y
-            iadd r0.y, r8.y, r0.y
-            iadd r0.y, r8.z, r0.y
-            iadd r0.y, r8.w, r0.y
-            ishr r0.z, r5.y, l(4)
-            ishl r0.z, r0.z, l(11)
-            and r0.z, r0.z, l(2048)
-            iadd r0.y, r0.z, r0.y
-            iadd r0.y, r7.z, r0.y
-            ishl r0.z, r2.y, l(13)
-            and r0.z, r0.z, l(8192)
-            iadd r0.y, r0.z, r0.y
-            ushr r0.z, r2.y, l(1)
-            ushr r0.w, r2.y, l(2)
-            ushr r2.z, r2.y, l(3)
-            ushr r2.w, r2.y, l(4)
-            ishl r7.x, r0.z, l(14)
-            ishl r7.y, r0.w, l(15)
-            ishl r7.z, r2.z, l(16)
-            ishl r7.w, r2.w, l(17)
-            and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-            iadd r0.y, r0.y, r7.x
-            iadd r0.y, r7.y, r0.y
-            iadd r0.y, r7.z, r0.y
-            iadd r3.w, r7.w, r0.y
-          else 
-            ieq r0.y, r2.x, l(5)
-            if_nz r0.y
-              ishl r7.x, r1.x, l(5)
-              ishl r7.y, r1.y, l(15)
-              ishl r7.z, r1.z, l(25)
-              ishl r7.w, r1.w, l(3)
-              and r7.xyzw, r7.xyzw, l(32, 0x00008000, 0x02000000, 8)
-              iadd r0.y, r7.x, l(10)
-              ishr r0.z, r1.x, l(1)
-              ishr r0.w, r1.x, l(2)
-              ishr r2.z, r1.x, l(3)
-              ishr r2.w, r1.x, l(4)
-              ishl r8.x, r0.z, l(6)
-              ishl r8.y, r0.w, l(7)
-              ishl r8.z, r2.z, l(8)
-              ishl r8.w, r2.w, l(9)
-              and r8.xyzw, r8.xyzw, l(64, 128, 256, 512)
-              iadd r0.y, r0.y, r8.x
-              iadd r0.y, r8.y, r0.y
-              iadd r0.y, r8.z, r0.y
-              iadd r0.y, r8.w, r0.y
-              ishr r0.z, r1.x, l(5)
-              ishr r0.w, r1.x, l(6)
-              ishr r2.z, r1.x, l(7)
-              ishr r2.w, r1.x, l(8)
-              ishl r8.x, r0.z, l(10)
-              ishl r8.y, r0.w, l(11)
-              ishl r8.z, r2.z, l(12)
-              ishl r8.w, r2.w, l(13)
-              and r8.xyzw, r8.xyzw, l(1024, 2048, 4096, 8192)
-              iadd r0.y, r0.y, r8.x
-              iadd r0.y, r8.y, r0.y
-              iadd r0.y, r8.z, r0.y
-              iadd r0.y, r8.w, r0.y
-              ishr r0.z, r1.x, l(9)
-              ishr r0.w, r1.y, l(1)
-              ishr r2.z, r1.y, l(2)
-              ishr r2.w, r1.y, l(3)
-              ishl r8.x, r0.z, l(14)
-              ishl r8.y, r0.w, l(16)
-              ishl r8.z, r2.z, l(17)
-              ishl r8.w, r2.w, l(18)
-              and r8.xyzw, r8.xyzw, l(0x00004000, 0x00010000, 0x00020000, 0x00040000)
-              iadd r0.y, r0.y, r8.x
-              iadd r0.y, r7.y, r0.y
-              iadd r0.y, r8.y, r0.y
-              iadd r0.y, r8.z, r0.y
-              iadd r0.y, r8.w, r0.y
-              ishr r0.z, r1.y, l(4)
-              ishr r0.w, r1.y, l(5)
-              ishr r2.z, r1.y, l(6)
-              ishr r2.w, r1.y, l(7)
-              ishl r8.x, r0.z, l(19)
-              ishl r8.y, r0.w, l(20)
-              ishl r8.z, r2.z, l(21)
-              ishl r8.w, r2.w, l(22)
-              and r8.xyzw, r8.xyzw, l(0x00080000, 0x00100000, 0x00200000, 0x00400000)
-              iadd r0.y, r0.y, r8.x
-              iadd r0.y, r8.y, r0.y
-              iadd r0.y, r8.z, r0.y
-              iadd r0.y, r8.w, r0.y
-              ishr r0.z, r1.y, l(8)
-              ishr r0.w, r1.y, l(9)
-              ishr r2.z, r1.z, l(1)
-              ishr r2.w, r1.z, l(2)
-              ishl r8.x, r0.z, l(23)
-              ishl r8.y, r0.w, l(24)
-              ishl r8.z, r2.z, l(26)
-              ishl r8.w, r2.w, l(27)
-              and r8.xyzw, r8.xyzw, l(0x00800000, 0x01000000, 0x04000000, 0x08000000)
-              iadd r0.y, r0.y, r8.x
-              iadd r0.y, r8.y, r0.y
-              iadd r0.y, r7.z, r0.y
-              iadd r0.y, r8.z, r0.y
-              iadd r0.y, r8.w, r0.y
-              ishr r0.z, r1.z, l(3)
-              ishr r0.w, r1.z, l(4)
-              ishr r2.z, r1.z, l(5)
-              ishr r2.w, r1.z, l(6)
-              ishl r7.x, r0.z, l(28)
-              ishl r7.y, r0.w, l(29)
-              ishl r7.z, r2.z, l(30)
-              ishl r0.z, r2.w, l(31)
-              and r7.xyz, r7.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-              iadd r0.y, r0.y, r7.x
-              iadd r0.y, r7.y, r0.y
-              iadd r0.y, r7.z, r0.y
-              iadd r3.x, r0.z, r0.y
-              ishr r0.y, r1.z, l(7)
-              ishr r0.z, r1.z, l(8)
-              ishr r0.w, r1.z, l(9)
-              ishr r2.z, r1.w, l(1)
-              and r0.y, r0.y, l(1)
-              ishl r7.x, r0.z, l(1)
-              ishl r7.y, r0.w, l(2)
-              ishl r7.z, r2.z, l(4)
-              and r7.xyz, r7.xyzx, l(2, 4, 16, 0)
-              iadd r0.y, r0.y, r7.x
-              iadd r0.y, r7.y, r0.y
-              iadd r0.y, r7.w, r0.y
-              iadd r0.y, r7.z, r0.y
-              ishr r0.z, r1.w, l(2)
-              ishr r0.w, r1.w, l(3)
-              ishr r2.zw, r1.xxxy, l(10)
-              ishl r7.x, r0.z, l(5)
-              ishl r7.y, r0.w, l(6)
-              ishl r7.z, r2.z, l(7)
-              ishl r7.w, r2.w, l(17)
-              and r7.xyzw, r7.xyzw, l(32, 64, 128, 0x00020000)
-              iadd r0.y, r0.y, r7.x
-              iadd r0.y, r7.y, r0.y
-              iadd r0.y, r7.z, r0.y
-              ishr r0.z, r5.z, l(4)
-              ishr r0.w, r5.y, l(1)
-              ishr r2.z, r5.y, l(2)
-              ishr r2.w, r5.y, l(3)
-              ishl r8.x, r0.z, l(8)
-              ishl r8.y, r0.w, l(10)
-              ishl r8.z, r2.z, l(11)
-              ishl r8.w, r2.w, l(12)
-              and r8.xyzw, r8.xyzw, l(256, 1024, 2048, 4096)
-              iadd r0.y, r0.y, r8.x
-              ishl r9.x, r5.y, l(9)
-              ishl r9.y, r5.z, l(29)
-              ishl r9.z, r5.x, l(1)
-              ishl r9.w, r5.w, l(7)
-              and r9.xyzw, r9.xyzw, l(512, 0x20000000, 2, 128)
-              iadd r0.y, r0.y, r9.x
-              iadd r0.y, r8.y, r0.y
-              iadd r0.y, r8.z, r0.y
-              iadd r0.y, r8.w, r0.y
-              ishl r7.x, r4.x, l(13)
-              ishl r7.y, r4.y, l(23)
-              and r0.zw, r7.xxxy, l(0, 0, 8192, 0x00800000)
-              iadd r0.y, r0.z, r0.y
-              ishr r2.zw, r4.xxxy, l(1)
-              ishr r0.z, r4.x, l(2)
-              ishr r4.z, r4.x, l(3)
-              ishl r8.x, r2.z, l(14)
-              ishl r8.y, r0.z, l(15)
-              ishl r8.z, r4.z, l(16)
-              ishl r8.w, r2.w, l(24)
-              and r8.xyzw, r8.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x01000000)
-              iadd r0.y, r0.y, r8.x
-              iadd r0.y, r8.y, r0.y
-              iadd r0.y, r8.z, r0.y
-              iadd r0.y, r7.w, r0.y
-              ishl r7.x, r6.y, l(18)
-              ishl r7.y, r6.x, l(19)
-              and r2.zw, r7.xxxy, l(0, 0, 0x00040000, 0x00080000)
-              iadd r0.y, r0.y, r2.z
-              iadd r0.y, r2.w, r0.y
-              ishr r2.zw, r6.xxxy, l(1)
-              ishr r0.z, r6.x, l(2)
-              ishr r4.z, r6.x, l(3)
-              ishl r7.x, r2.z, l(20)
-              ishl r7.y, r0.z, l(21)
-              ishl r7.z, r4.z, l(22)
-              ishl r7.w, r2.w, l(5)
-              and r7.xyzw, r7.xyzw, l(0x00100000, 0x00200000, 0x00400000, 32)
-              iadd r0.y, r0.y, r7.x
-              iadd r0.y, r7.y, r0.y
-              iadd r0.y, r7.z, r0.y
-              iadd r0.y, r0.w, r0.y
-              iadd r0.y, r8.w, r0.y
-              ishr r0.z, r4.y, l(2)
-              ishr r0.w, r4.y, l(3)
-              ishr r2.z, r4.y, l(4)
-              ishl r7.x, r0.z, l(25)
-              ishl r7.y, r0.w, l(26)
-              ishl r7.z, r2.z, l(27)
-              and r7.xyz, r7.xyzx, l(0x02000000, 0x04000000, 0x08000000, 0)
-              iadd r0.y, r0.y, r7.x
-              iadd r0.y, r7.y, r0.y
-              iadd r0.y, r7.z, r0.y
-              ishr r0.z, r1.z, l(10)
-              ishl r0.z, r0.z, l(28)
-              and r0.z, r0.z, l(0x10000000)
-              iadd r0.y, r0.z, r0.y
-              iadd r0.y, r9.y, r0.y
-              ishr r0.zw, r5.zzzx, l(1)
-              ishr r2.z, r5.z, l(2)
-              ishr r2.w, r5.z, l(3)
-              ishl r7.x, r0.z, l(30)
-              ishl r0.z, r2.z, l(31)
-              ishl r7.z, r0.w, l(2)
-              and r4.zw, r7.xxxz, l(0, 0, 0x40000000, 4)
-              iadd r0.y, r0.y, r4.z
-              iadd r3.z, r0.z, r0.y
-              and r0.y, r2.w, l(1)
-              iadd r0.y, r0.y, r3.w
-              iadd r0.y, r9.z, r0.y
-              iadd r0.y, r4.w, r0.y
-              ishr r0.zw, r5.xxxw, l(2)
-              ishr r2.z, r5.x, l(3)
-              ishr r2.w, r5.w, l(1)
-              ishl r8.x, r0.z, l(3)
-              ishl r8.y, r2.z, l(4)
-              ishl r8.z, r2.w, l(8)
-              ishl r8.w, r0.w, l(9)
-              and r8.xyzw, r8.xyzw, l(8, 16, 256, 512)
-              iadd r0.y, r0.y, r8.x
-              iadd r0.y, r8.y, r0.y
-              iadd r0.y, r7.w, r0.y
-              ishr r0.z, r6.y, l(2)
-              ishr r0.w, r6.y, l(4)
-              ishr r2.z, r6.y, l(3)
-              ishl r7.x, r0.z, l(6)
-              ishl r7.y, r0.w, l(11)
-              ishl r7.z, r2.z, l(12)
-              and r7.xyz, r7.xyzx, l(64, 2048, 4096, 0)
-              iadd r0.y, r0.y, r7.x
-              iadd r0.y, r9.w, r0.y
-              iadd r0.y, r8.z, r0.y
-              iadd r0.y, r8.w, r0.y
-              ishr r0.z, r5.w, l(3)
-              ishl r0.z, r0.z, l(10)
-              and r0.z, r0.z, l(1024)
-              iadd r0.y, r0.z, r0.y
-              iadd r0.y, r7.y, r0.y
-              iadd r0.y, r7.z, r0.y
-              ishl r0.z, r2.y, l(13)
-              and r0.z, r0.z, l(8192)
-              iadd r0.y, r0.z, r0.y
-              ushr r0.z, r2.y, l(1)
-              ushr r0.w, r2.y, l(2)
-              ushr r2.z, r2.y, l(3)
-              ushr r2.w, r2.y, l(4)
-              ishl r7.x, r0.z, l(14)
-              ishl r7.y, r0.w, l(15)
-              ishl r7.z, r2.z, l(16)
-              ishl r7.w, r2.w, l(17)
-              and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-              iadd r0.y, r0.y, r7.x
-              iadd r0.y, r7.y, r0.y
-              iadd r0.y, r7.z, r0.y
-              iadd r3.w, r7.w, r0.y
-            else 
-              ieq r0.y, r2.x, l(6)
-              if_nz r0.y
-                ishl r7.x, r1.x, l(5)
-                ishl r7.y, r1.y, l(15)
-                ishl r7.z, r1.z, l(25)
-                ishl r7.w, r1.w, l(3)
-                and r7.xyzw, r7.xyzw, l(32, 0x00008000, 0x02000000, 8)
-                iadd r0.y, r7.x, l(14)
-                ishr r0.z, r1.x, l(1)
-                ishr r0.w, r1.x, l(2)
-                ishr r2.z, r1.x, l(3)
-                ishr r2.w, r1.x, l(4)
-                ishl r8.x, r0.z, l(6)
-                ishl r8.y, r0.w, l(7)
-                ishl r8.z, r2.z, l(8)
-                ishl r8.w, r2.w, l(9)
-                and r8.xyzw, r8.xyzw, l(64, 128, 256, 512)
-                iadd r0.y, r0.y, r8.x
-                iadd r0.y, r8.y, r0.y
-                iadd r0.y, r8.z, r0.y
-                iadd r0.y, r8.w, r0.y
-                ishr r0.z, r1.x, l(5)
-                ishr r0.w, r1.x, l(6)
-                ishr r2.z, r1.x, l(7)
-                ishr r2.w, r1.x, l(8)
-                ishl r8.x, r0.z, l(10)
-                ishl r8.y, r0.w, l(11)
-                ishl r8.z, r2.z, l(12)
-                ishl r8.w, r2.w, l(13)
-                and r8.xyzw, r8.xyzw, l(1024, 2048, 4096, 8192)
-                iadd r0.y, r0.y, r8.x
-                iadd r0.y, r8.y, r0.y
-                iadd r0.y, r8.z, r0.y
-                iadd r0.y, r8.w, r0.y
-                ishr r0.zw, r5.zzzy, l(4)
-                ishr r2.z, r5.y, l(1)
-                ishr r2.w, r5.y, l(2)
-                ishl r8.x, r0.z, l(14)
-                ishl r8.y, r0.w, l(24)
-                ishl r8.z, r2.z, l(10)
-                ishl r8.w, r2.w, l(11)
-                and r8.xyzw, r8.xyzw, l(0x00004000, 0x01000000, 1024, 2048)
-                iadd r0.y, r0.y, r8.x
-                iadd r0.y, r7.y, r0.y
-                ishr r0.z, r1.y, l(1)
-                ishr r0.w, r1.y, l(2)
-                ishr r2.z, r1.y, l(3)
-                ishr r2.w, r1.y, l(4)
-                ishl r9.x, r0.z, l(16)
-                ishl r9.y, r0.w, l(17)
-                ishl r9.z, r2.z, l(18)
-                ishl r9.w, r2.w, l(19)
-                and r9.xyzw, r9.xyzw, l(0x00010000, 0x00020000, 0x00040000, 0x00080000)
-                iadd r0.y, r0.y, r9.x
-                iadd r0.y, r9.y, r0.y
-                iadd r0.y, r9.z, r0.y
-                iadd r0.y, r9.w, r0.y
-                ishr r0.z, r1.y, l(5)
-                ishr r0.w, r1.y, l(6)
-                ishr r2.z, r1.y, l(7)
-                ishr r2.w, r1.y, l(8)
-                ishl r9.x, r0.z, l(20)
-                ishl r9.y, r0.w, l(21)
-                ishl r9.z, r2.z, l(22)
-                ishl r9.w, r2.w, l(23)
-                and r9.xyzw, r9.xyzw, l(0x00100000, 0x00200000, 0x00400000, 0x00800000)
-                iadd r0.y, r0.y, r9.x
-                iadd r0.y, r9.y, r0.y
-                iadd r0.y, r9.z, r0.y
-                iadd r0.y, r9.w, r0.y
-                iadd r0.y, r8.y, r0.y
-                iadd r0.y, r7.z, r0.y
-                ishr r0.z, r1.z, l(1)
-                ishr r0.w, r1.z, l(2)
-                ishr r2.z, r1.z, l(3)
-                ishr r2.w, r1.z, l(4)
-                ishl r9.x, r0.z, l(26)
-                ishl r9.y, r0.w, l(27)
-                ishl r9.z, r2.z, l(28)
-                ishl r9.w, r2.w, l(29)
-                and r9.xyzw, r9.xyzw, l(0x04000000, 0x08000000, 0x10000000, 0x20000000)
-                iadd r0.y, r0.y, r9.x
-                iadd r0.y, r9.y, r0.y
-                iadd r0.y, r9.z, r0.y
-                iadd r0.y, r9.w, r0.y
-                ishr r0.z, r1.z, l(5)
-                ishr r0.w, r1.z, l(6)
-                ishr r2.z, r1.z, l(7)
-                ishr r2.w, r1.z, l(8)
-                ishl r7.x, r0.z, l(30)
-                ishl r0.z, r0.w, l(31)
-                ishl r7.z, r2.w, l(1)
-                and r4.zw, r7.xxxz, l(0, 0, 0x40000000, 2)
-                iadd r0.y, r0.y, r4.z
-                iadd r3.x, r0.z, r0.y
-                and r0.y, r2.z, l(1)
-                iadd r0.y, r4.w, r0.y
-                ishr r0.zw, r6.yyyx, l(4)
-                ishr r2.z, r6.x, l(1)
-                ishr r2.w, r6.x, l(2)
-                ishl r9.x, r0.z, l(2)
-                ishl r9.y, r0.w, l(8)
-                ishl r9.z, r2.z, l(20)
-                ishl r9.w, r2.w, l(21)
-                and r9.xyzw, r9.xyzw, l(4, 256, 0x00100000, 0x00200000)
-                iadd r0.y, r0.y, r9.x
-                iadd r0.y, r7.w, r0.y
-                ishr r0.z, r1.w, l(1)
-                ishr r0.w, r1.w, l(2)
-                ishr r2.z, r1.w, l(3)
-                ishr r2.w, r1.w, l(4)
-                ishl r7.x, r0.z, l(4)
-                ishl r7.y, r0.w, l(5)
-                ishl r7.z, r2.z, l(6)
-                ishl r7.w, r2.w, l(7)
-                and r7.xyzw, r7.xyzw, l(16, 32, 64, 128)
-                iadd r0.y, r0.y, r7.x
-                iadd r0.y, r7.y, r0.y
-                iadd r0.y, r7.z, r0.y
-                iadd r0.y, r7.w, r0.y
-                iadd r0.y, r9.y, r0.y
-                ishl r7.x, r5.y, l(9)
-                ishl r7.y, r5.z, l(29)
-                ishl r7.z, r5.x, l(1)
-                ishl r7.w, r5.w, l(7)
-                and r7.xyzw, r7.xyzw, l(512, 0x20000000, 2, 128)
-                iadd r0.y, r0.y, r7.x
-                iadd r0.y, r8.z, r0.y
-                iadd r0.y, r8.w, r0.y
-                ishr r0.zw, r5.yyyz, l(3)
-                ishr r2.z, r5.z, l(1)
-                ishr r2.w, r5.z, l(2)
-                ishl r8.x, r0.z, l(12)
-                ishl r8.y, r2.z, l(30)
-                ishl r0.z, r2.w, l(31)
-                and r2.zw, r8.xxxy, l(0, 0, 4096, 0x40000000)
-                iadd r0.y, r0.y, r2.z
-                ishl r8.x, r4.x, l(13)
-                ishl r8.y, r4.y, l(23)
-                and r4.zw, r8.xxxy, l(0, 0, 8192, 0x00800000)
-                iadd r0.y, r0.y, r4.z
-                ishr r2.z, r4.x, l(1)
-                ishr r4.z, r4.x, l(2)
-                ishr r6.z, r4.x, l(3)
-                ishr r6.w, r4.x, l(4)
-                ishl r8.x, r2.z, l(14)
-                ishl r8.y, r4.z, l(15)
-                ishl r8.z, r6.z, l(16)
-                ishl r8.w, r6.w, l(17)
-                and r8.xyzw, r8.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                iadd r0.y, r0.y, r8.x
-                iadd r0.y, r8.y, r0.y
-                iadd r0.y, r8.z, r0.y
-                iadd r0.y, r8.w, r0.y
-                ishl r8.x, r6.y, l(18)
-                ishl r8.y, r6.x, l(19)
-                and r6.zw, r8.xxxy, l(0, 0, 0x00040000, 0x00080000)
-                iadd r0.y, r0.y, r6.z
-                iadd r0.y, r6.w, r0.y
-                iadd r0.y, r9.z, r0.y
-                iadd r0.y, r9.w, r0.y
-                ishr r6.zw, r6.xxxy, l(3)
-                ishr r2.z, r6.y, l(1)
-                ishr r4.z, r6.y, l(2)
-                ishl r8.x, r6.z, l(22)
-                ishl r8.y, r2.z, l(28)
-                ishl r8.z, r4.z, l(6)
-                ishl r8.w, r6.w, l(12)
-                and r8.xyzw, r8.xyzw, l(0x00400000, 0x10000000, 64, 4096)
-                iadd r0.y, r0.y, r8.x
-                iadd r0.y, r4.w, r0.y
-                ishr r2.z, r4.y, l(1)
-                ishr r4.z, r4.y, l(2)
-                ishr r4.w, r4.y, l(3)
-                ishr r6.z, r4.y, l(4)
-                ishl r9.x, r2.z, l(24)
-                ishl r9.y, r4.z, l(25)
-                ishl r9.z, r4.w, l(26)
-                ishl r9.w, r6.z, l(27)
-                and r9.xyzw, r9.xyzw, l(0x01000000, 0x02000000, 0x04000000, 0x08000000)
-                iadd r0.y, r0.y, r9.x
-                iadd r0.y, r9.y, r0.y
-                iadd r0.y, r9.z, r0.y
-                iadd r0.y, r9.w, r0.y
-                iadd r0.y, r8.y, r0.y
-                iadd r0.y, r7.y, r0.y
-                iadd r0.y, r2.w, r0.y
-                iadd r3.z, r0.z, r0.y
-                and r0.y, r0.w, l(1)
-                iadd r0.y, r0.y, r3.w
-                iadd r0.y, r7.z, r0.y
-                ishr r0.z, r5.x, l(1)
-                ishr r0.w, r5.x, l(2)
-                ishr r2.z, r5.x, l(3)
-                ishr r2.w, r5.x, l(4)
-                ishl r9.x, r0.z, l(2)
-                ishl r9.y, r0.w, l(3)
-                ishl r9.z, r2.z, l(4)
-                ishl r9.w, r2.w, l(5)
-                and r9.xyzw, r9.xyzw, l(4, 8, 16, 32)
-                iadd r0.y, r0.y, r9.x
-                iadd r0.y, r9.y, r0.y
-                iadd r0.y, r9.z, r0.y
-                iadd r0.y, r9.w, r0.y
-                iadd r0.y, r8.z, r0.y
-                iadd r0.y, r7.w, r0.y
-                ishr r0.z, r5.w, l(1)
-                ishr r0.w, r5.w, l(2)
-                ishr r2.z, r5.w, l(3)
-                ishr r2.w, r5.w, l(4)
-                ishl r7.x, r0.z, l(8)
-                ishl r7.y, r0.w, l(9)
-                ishl r7.z, r2.z, l(10)
-                ishl r7.w, r2.w, l(11)
-                and r7.xyzw, r7.xyzw, l(256, 512, 1024, 2048)
-                iadd r0.y, r0.y, r7.x
-                iadd r0.y, r7.y, r0.y
-                iadd r0.y, r7.z, r0.y
-                iadd r0.y, r7.w, r0.y
-                iadd r0.y, r8.w, r0.y
-                ishl r0.z, r2.y, l(13)
-                and r0.z, r0.z, l(8192)
-                iadd r0.y, r0.z, r0.y
-                ushr r0.z, r2.y, l(1)
-                ushr r0.w, r2.y, l(2)
-                ushr r2.z, r2.y, l(3)
-                ushr r2.w, r2.y, l(4)
-                ishl r7.x, r0.z, l(14)
-                ishl r7.y, r0.w, l(15)
-                ishl r7.z, r2.z, l(16)
-                ishl r7.w, r2.w, l(17)
-                and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                iadd r0.y, r0.y, r7.x
-                iadd r0.y, r7.y, r0.y
-                iadd r0.y, r7.z, r0.y
-                iadd r3.w, r7.w, r0.y
-              else 
-                ieq r0.y, r2.x, l(7)
-                if_nz r0.y
-                  ishl r7.x, r1.x, l(5)
-                  ishl r7.y, r1.y, l(15)
-                  ishl r7.z, r1.z, l(25)
-                  ishl r7.w, r1.w, l(3)
-                  and r7.xyzw, r7.xyzw, l(32, 0x00008000, 0x02000000, 8)
-                  iadd r0.y, r7.x, l(18)
-                  ishr r0.z, r1.x, l(1)
-                  ishr r0.w, r1.x, l(2)
-                  ishr r2.z, r1.x, l(3)
-                  ishr r2.w, r1.x, l(4)
-                  ishl r8.x, r0.z, l(6)
-                  ishl r8.y, r0.w, l(7)
-                  ishl r8.z, r2.z, l(8)
-                  ishl r8.w, r2.w, l(9)
-                  and r8.xyzw, r8.xyzw, l(64, 128, 256, 512)
-                  iadd r0.y, r0.y, r8.x
-                  iadd r0.y, r8.y, r0.y
-                  iadd r0.y, r8.z, r0.y
-                  iadd r0.y, r8.w, r0.y
-                  ishr r0.z, r1.x, l(5)
-                  ishr r0.w, r1.x, l(6)
-                  ishr r2.z, r1.x, l(7)
-                  ishr r2.w, r1.y, l(1)
-                  ishl r8.x, r0.z, l(10)
-                  ishl r8.y, r0.w, l(11)
-                  ishl r8.z, r2.z, l(12)
-                  ishl r8.w, r2.w, l(16)
-                  and r8.xyzw, r8.xyzw, l(1024, 2048, 4096, 0x00010000)
-                  iadd r0.y, r0.y, r8.x
-                  iadd r0.y, r8.y, r0.y
-                  iadd r0.y, r8.z, r0.y
-                  ishr r0.zw, r6.xxxy, l(4)
-                  ishr r2.z, r6.y, l(2)
-                  ishr r2.w, r6.y, l(3)
-                  ishl r9.x, r0.z, l(13)
-                  ishl r9.y, r2.z, l(23)
-                  ishl r9.z, r2.w, l(1)
-                  ishl r9.w, r0.w, l(2)
-                  and r9.xyzw, r9.xyzw, l(8192, 0x00800000, 2, 4)
-                  iadd r0.y, r0.y, r9.x
-                  ishr r0.zw, r5.zzzy, l(4)
-                  ishr r2.z, r5.y, l(1)
-                  ishr r2.w, r5.y, l(2)
-                  ishl r10.x, r0.z, l(14)
-                  ishl r10.y, r0.w, l(24)
-                  ishl r10.z, r2.z, l(10)
-                  ishl r10.w, r2.w, l(11)
-                  and r10.xyzw, r10.xyzw, l(0x00004000, 0x01000000, 1024, 2048)
-                  iadd r0.y, r0.y, r10.x
-                  iadd r0.y, r7.y, r0.y
-                  iadd r0.y, r8.w, r0.y
-                  ishr r0.z, r1.y, l(2)
-                  ishr r0.w, r1.y, l(3)
-                  ishr r2.z, r1.y, l(4)
-                  ishr r2.w, r1.y, l(5)
-                  ishl r8.x, r0.z, l(17)
-                  ishl r8.y, r0.w, l(18)
-                  ishl r8.z, r2.z, l(19)
-                  ishl r8.w, r2.w, l(20)
-                  and r8.xyzw, r8.xyzw, l(0x00020000, 0x00040000, 0x00080000, 0x00100000)
-                  iadd r0.y, r0.y, r8.x
-                  iadd r0.y, r8.y, r0.y
-                  iadd r0.y, r8.z, r0.y
-                  iadd r0.y, r8.w, r0.y
-                  ishr r0.z, r1.y, l(6)
-                  ishr r0.w, r1.y, l(7)
-                  ishr r2.z, r1.z, l(1)
-                  ishr r2.w, r1.z, l(2)
-                  ishl r8.x, r0.z, l(21)
-                  ishl r8.y, r0.w, l(22)
-                  ishl r8.z, r2.z, l(26)
-                  ishl r8.w, r2.w, l(27)
-                  and r8.xyzw, r8.xyzw, l(0x00200000, 0x00400000, 0x04000000, 0x08000000)
-                  iadd r0.y, r0.y, r8.x
-                  iadd r0.y, r8.y, r0.y
-                  iadd r0.y, r9.y, r0.y
-                  iadd r0.y, r10.y, r0.y
-                  iadd r0.y, r7.z, r0.y
-                  iadd r0.y, r8.z, r0.y
-                  iadd r0.y, r8.w, r0.y
-                  ishr r0.z, r1.z, l(3)
-                  ishr r0.w, r1.z, l(4)
-                  ishr r2.z, r1.z, l(5)
-                  ishr r2.w, r1.z, l(6)
-                  ishl r7.x, r0.z, l(28)
-                  ishl r7.y, r0.w, l(29)
-                  ishl r7.z, r2.z, l(30)
-                  ishl r0.z, r2.w, l(31)
-                  and r7.xyz, r7.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-                  iadd r0.y, r0.y, r7.x
-                  iadd r0.y, r7.y, r0.y
-                  iadd r0.y, r7.z, r0.y
-                  iadd r3.x, r0.z, r0.y
-                  ishr r0.y, r1.z, l(7)
-                  ishr r0.z, r1.w, l(1)
-                  ishr r0.w, r1.w, l(2)
-                  ishr r2.z, r1.w, l(3)
-                  and r0.y, r0.y, l(1)
-                  iadd r0.y, r9.z, r0.y
-                  iadd r0.y, r9.w, r0.y
-                  iadd r0.y, r7.w, r0.y
-                  ishl r7.x, r0.z, l(4)
-                  ishl r7.y, r0.w, l(5)
-                  ishl r7.z, r2.z, l(6)
-                  and r7.xyz, r7.xyzx, l(16, 32, 64, 0)
-                  iadd r0.y, r0.y, r7.x
-                  iadd r0.y, r7.y, r0.y
-                  iadd r0.y, r7.z, r0.y
-                  ishr r0.z, r1.w, l(4)
-                  ishr r0.w, r1.w, l(5)
-                  ishl r7.x, r0.z, l(7)
-                  ishl r7.y, r0.w, l(8)
-                  and r0.zw, r7.xxxy, l(0, 0, 128, 256)
-                  iadd r0.y, r0.z, r0.y
-                  iadd r0.y, r0.w, r0.y
-                  ishl r7.x, r5.y, l(9)
-                  ishl r7.y, r5.z, l(29)
-                  ishl r7.z, r5.x, l(1)
-                  ishl r7.w, r5.w, l(7)
-                  and r7.xyzw, r7.xyzw, l(512, 0x20000000, 2, 128)
-                  iadd r0.y, r0.y, r7.x
-                  iadd r0.y, r10.z, r0.y
-                  iadd r0.y, r10.w, r0.y
-                  ishr r0.zw, r5.yyyz, l(3)
-                  ishr r2.z, r5.z, l(1)
-                  ishr r2.w, r5.z, l(2)
-                  ishl r8.x, r0.z, l(12)
-                  ishl r8.y, r2.z, l(30)
-                  ishl r0.z, r2.w, l(31)
-                  and r2.zw, r8.xxxy, l(0, 0, 4096, 0x40000000)
-                  iadd r0.y, r0.y, r2.z
-                  ishl r8.x, r4.x, l(13)
-                  ishl r8.y, r4.y, l(23)
-                  and r4.zw, r8.xxxy, l(0, 0, 8192, 0x00800000)
-                  iadd r0.y, r0.y, r4.z
-                  ishr r2.z, r4.x, l(1)
-                  ishr r4.z, r4.x, l(2)
-                  ishr r6.z, r4.x, l(3)
-                  ishr r6.w, r4.x, l(4)
-                  ishl r8.x, r2.z, l(14)
-                  ishl r8.y, r4.z, l(15)
-                  ishl r8.z, r6.z, l(16)
-                  ishl r8.w, r6.w, l(17)
-                  and r8.xyzw, r8.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                  iadd r0.y, r0.y, r8.x
-                  iadd r0.y, r8.y, r0.y
-                  iadd r0.y, r8.z, r0.y
-                  iadd r0.y, r8.w, r0.y
-                  ishl r8.x, r6.y, l(18)
-                  ishl r8.y, r6.x, l(19)
-                  and r6.zw, r8.xxxy, l(0, 0, 0x00040000, 0x00080000)
-                  iadd r0.y, r0.y, r6.z
-                  iadd r0.y, r6.w, r0.y
-                  ishr r6.zw, r6.xxxy, l(1)
-                  ishr r2.z, r6.x, l(2)
-                  ishr r4.z, r6.x, l(3)
-                  ishl r8.x, r6.z, l(20)
-                  ishl r8.y, r2.z, l(21)
-                  ishl r8.z, r4.z, l(22)
-                  ishl r8.w, r6.w, l(28)
-                  and r8.xyzw, r8.xyzw, l(0x00100000, 0x00200000, 0x00400000, 0x10000000)
-                  iadd r0.y, r0.y, r8.x
-                  iadd r0.y, r8.y, r0.y
-                  iadd r0.y, r8.z, r0.y
-                  iadd r0.y, r4.w, r0.y
-                  ishr r2.z, r4.y, l(1)
-                  ishr r4.z, r4.y, l(2)
-                  ishr r4.w, r4.y, l(3)
-                  ishr r6.z, r4.y, l(4)
-                  ishl r9.x, r2.z, l(24)
-                  ishl r9.y, r4.z, l(25)
-                  ishl r9.z, r4.w, l(26)
-                  ishl r9.w, r6.z, l(27)
-                  and r9.xyzw, r9.xyzw, l(0x01000000, 0x02000000, 0x04000000, 0x08000000)
-                  iadd r0.y, r0.y, r9.x
-                  iadd r0.y, r9.y, r0.y
-                  iadd r0.y, r9.z, r0.y
-                  iadd r0.y, r9.w, r0.y
-                  iadd r0.y, r8.w, r0.y
-                  iadd r0.y, r7.y, r0.y
-                  iadd r0.y, r2.w, r0.y
-                  iadd r3.z, r0.z, r0.y
-                  and r0.y, r0.w, l(1)
-                  iadd r0.y, r0.y, r3.w
-                  iadd r0.y, r7.z, r0.y
-                  ishr r0.z, r5.x, l(1)
-                  ishr r0.w, r5.x, l(2)
-                  ishr r2.z, r5.x, l(3)
-                  ishr r2.w, r5.x, l(4)
-                  ishl r8.x, r0.z, l(2)
-                  ishl r8.y, r0.w, l(3)
-                  ishl r8.z, r2.z, l(4)
-                  ishl r8.w, r2.w, l(5)
-                  and r8.xyzw, r8.xyzw, l(4, 8, 16, 32)
-                  iadd r0.y, r0.y, r8.x
-                  iadd r0.y, r8.y, r0.y
-                  iadd r0.y, r8.z, r0.y
-                  iadd r0.y, r8.w, r0.y
-                  ishr r0.z, r5.x, l(5)
-                  ishr r0.w, r5.w, l(1)
-                  ishr r2.z, r5.w, l(2)
-                  ishr r2.w, r5.w, l(3)
-                  ishl r8.x, r0.z, l(6)
-                  ishl r8.y, r0.w, l(8)
-                  ishl r8.z, r2.z, l(9)
-                  ishl r8.w, r2.w, l(10)
-                  and r8.xyzw, r8.xyzw, l(64, 256, 512, 1024)
-                  iadd r0.y, r0.y, r8.x
-                  iadd r0.y, r7.w, r0.y
-                  iadd r0.y, r8.y, r0.y
-                  iadd r0.y, r8.z, r0.y
-                  iadd r0.y, r8.w, r0.y
-                  ishr r0.z, r5.w, l(4)
-                  ishr r0.w, r5.w, l(5)
-                  ishl r7.x, r0.z, l(11)
-                  ishl r7.y, r0.w, l(12)
-                  and r0.zw, r7.xxxy, l(0, 0, 2048, 4096)
-                  iadd r0.y, r0.z, r0.y
-                  iadd r0.y, r0.w, r0.y
-                  ishl r0.z, r2.y, l(13)
-                  and r0.z, r0.z, l(8192)
-                  iadd r0.y, r0.z, r0.y
-                  ushr r0.z, r2.y, l(1)
-                  ushr r0.w, r2.y, l(2)
-                  ushr r2.z, r2.y, l(3)
-                  ushr r2.w, r2.y, l(4)
-                  ishl r7.x, r0.z, l(14)
-                  ishl r7.y, r0.w, l(15)
-                  ishl r7.z, r2.z, l(16)
-                  ishl r7.w, r2.w, l(17)
-                  and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                  iadd r0.y, r0.y, r7.x
-                  iadd r0.y, r7.y, r0.y
-                  iadd r0.y, r7.z, r0.y
-                  iadd r3.w, r7.w, r0.y
-                else 
-                  ieq r0.y, r2.x, l(8)
-                  if_nz r0.y
-                    ishl r7.x, r1.x, l(5)
-                    ishl r7.y, r1.y, l(15)
-                    ishl r7.z, r1.z, l(25)
-                    ishl r7.w, r1.w, l(3)
-                    and r7.xyzw, r7.xyzw, l(32, 0x00008000, 0x02000000, 8)
-                    iadd r0.y, r7.x, l(22)
-                    ishr r0.z, r1.x, l(1)
-                    ishr r0.w, r1.x, l(2)
-                    ishr r2.z, r1.x, l(3)
-                    ishr r2.w, r1.x, l(4)
-                    ishl r8.x, r0.z, l(6)
-                    ishl r8.y, r0.w, l(7)
-                    ishl r8.z, r2.z, l(8)
-                    ishl r8.w, r2.w, l(9)
-                    and r8.xyzw, r8.xyzw, l(64, 128, 256, 512)
-                    iadd r0.y, r0.y, r8.x
-                    iadd r0.y, r8.y, r0.y
-                    iadd r0.y, r8.z, r0.y
-                    iadd r0.y, r8.w, r0.y
-                    ishr r0.z, r1.x, l(5)
-                    ishr r0.w, r1.x, l(6)
-                    ishr r2.z, r1.x, l(7)
-                    ishr r2.w, r1.y, l(1)
-                    ishl r8.x, r0.z, l(10)
-                    ishl r8.y, r0.w, l(11)
-                    ishl r8.z, r2.z, l(12)
-                    ishl r8.w, r2.w, l(16)
-                    and r8.xyzw, r8.xyzw, l(1024, 2048, 4096, 0x00010000)
-                    iadd r0.y, r0.y, r8.x
-                    iadd r0.y, r8.y, r0.y
-                    iadd r0.y, r8.z, r0.y
-                    ishl r8.x, r6.y, l(13)
-                    ishl r8.y, r6.x, l(19)
-                    and r0.zw, r8.xxxy, l(0, 0, 8192, 0x00080000)
-                    iadd r0.y, r0.z, r0.y
-                    ishr r2.zw, r5.zzzy, l(4)
-                    ishr r0.z, r5.y, l(5)
-                    ishr r4.z, r5.y, l(1)
-                    ishl r9.x, r2.z, l(14)
-                    ishl r9.y, r0.z, l(23)
-                    ishl r9.z, r2.w, l(24)
-                    ishl r9.w, r4.z, l(10)
-                    and r9.xyzw, r9.xyzw, l(0x00004000, 0x00800000, 0x01000000, 1024)
-                    iadd r0.y, r0.y, r9.x
-                    iadd r0.y, r7.y, r0.y
-                    iadd r0.y, r8.w, r0.y
-                    ishr r0.z, r1.y, l(2)
-                    ishr r2.z, r1.y, l(3)
-                    ishr r2.w, r1.y, l(4)
-                    ishr r4.z, r1.y, l(5)
-                    ishl r8.x, r0.z, l(17)
-                    ishl r8.y, r2.z, l(18)
-                    ishl r8.z, r2.w, l(19)
-                    ishl r8.w, r4.z, l(20)
-                    and r8.xyzw, r8.xyzw, l(0x00020000, 0x00040000, 0x00080000, 0x00100000)
-                    iadd r0.y, r0.y, r8.x
-                    iadd r0.y, r8.y, r0.y
-                    iadd r0.y, r8.z, r0.y
-                    iadd r0.y, r8.w, r0.y
-                    ishr r0.z, r1.y, l(6)
-                    ishr r2.z, r1.y, l(7)
-                    ishr r2.w, r1.z, l(1)
-                    ishr r4.z, r1.z, l(2)
-                    ishl r8.x, r0.z, l(21)
-                    ishl r8.y, r2.z, l(22)
-                    ishl r8.z, r2.w, l(26)
-                    ishl r8.w, r4.z, l(27)
-                    and r8.xyzw, r8.xyzw, l(0x00200000, 0x00400000, 0x04000000, 0x08000000)
-                    iadd r0.y, r0.y, r8.x
-                    iadd r0.y, r8.y, r0.y
-                    iadd r0.y, r9.y, r0.y
-                    iadd r0.y, r9.z, r0.y
-                    iadd r0.y, r7.z, r0.y
-                    iadd r0.y, r8.z, r0.y
-                    iadd r0.y, r8.w, r0.y
-                    ishr r0.z, r1.z, l(3)
-                    ishr r2.z, r1.z, l(4)
-                    ishr r2.w, r1.z, l(5)
-                    ishr r4.z, r1.z, l(6)
-                    ishl r7.x, r0.z, l(28)
-                    ishl r7.y, r2.z, l(29)
-                    ishl r7.z, r2.w, l(30)
-                    ishl r0.z, r4.z, l(31)
-                    and r7.xyz, r7.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-                    iadd r0.y, r0.y, r7.x
-                    iadd r0.y, r7.y, r0.y
-                    iadd r0.y, r7.z, r0.y
-                    iadd r3.x, r0.z, r0.y
-                    ishr r0.y, r1.z, l(7)
-                    ishr r0.z, r1.w, l(1)
-                    ishr r2.z, r1.w, l(2)
-                    ishr r2.w, r1.w, l(3)
-                    and r0.y, r0.y, l(1)
-                    ishr r4.z, r6.x, l(5)
-                    ishr r6.zw, r6.yyyx, l(4)
-                    ishr r4.w, r6.x, l(1)
-                    ishl r8.x, r4.z, l(1)
-                    ishl r8.y, r6.z, l(2)
-                    ishl r8.z, r6.w, l(8)
-                    ishl r8.w, r4.w, l(20)
-                    and r8.xyzw, r8.xyzw, l(2, 4, 256, 0x00100000)
-                    iadd r0.y, r0.y, r8.x
-                    iadd r0.y, r8.y, r0.y
-                    iadd r0.y, r7.w, r0.y
-                    ishl r7.x, r0.z, l(4)
-                    ishl r7.y, r2.z, l(5)
-                    ishl r7.z, r2.w, l(6)
-                    and r7.xyz, r7.xyzx, l(16, 32, 64, 0)
-                    iadd r0.y, r0.y, r7.x
-                    iadd r0.y, r7.y, r0.y
-                    iadd r0.y, r7.z, r0.y
-                    ishr r0.z, r1.w, l(4)
-                    ishl r0.z, r0.z, l(7)
-                    and r0.z, r0.z, l(128)
-                    iadd r0.y, r0.z, r0.y
-                    iadd r0.y, r8.z, r0.y
-                    ishl r7.x, r5.y, l(9)
-                    ishl r7.y, r5.z, l(29)
-                    ishl r7.z, r5.x, l(1)
-                    ishl r7.w, r5.w, l(7)
-                    and r7.xyzw, r7.xyzw, l(512, 0x20000000, 2, 128)
-                    iadd r0.y, r0.y, r7.x
-                    iadd r0.y, r9.w, r0.y
-                    ishr r2.zw, r5.yyyz, l(2)
-                    ishr r0.z, r5.y, l(3)
-                    ishr r4.z, r5.z, l(1)
-                    ishl r8.x, r2.z, l(11)
-                    ishl r8.y, r0.z, l(12)
-                    ishl r8.z, r4.z, l(30)
-                    ishl r0.z, r2.w, l(31)
-                    and r8.xyz, r8.xyzx, l(2048, 4096, 0x40000000, 0)
-                    iadd r0.y, r0.y, r8.x
-                    iadd r0.y, r8.y, r0.y
-                    ishl r8.x, r4.x, l(13)
-                    ishl r8.y, r4.y, l(23)
-                    and r2.zw, r8.xxxy, l(0, 0, 8192, 0x00800000)
-                    iadd r0.y, r0.y, r2.z
-                    ishr r2.z, r4.x, l(1)
-                    ishr r4.z, r4.x, l(2)
-                    ishr r4.w, r4.x, l(3)
-                    ishr r6.z, r4.x, l(4)
-                    ishl r9.x, r2.z, l(14)
-                    ishl r9.y, r4.z, l(15)
-                    ishl r9.z, r4.w, l(16)
-                    ishl r9.w, r6.z, l(17)
-                    and r9.xyzw, r9.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                    iadd r0.y, r0.y, r9.x
-                    iadd r0.y, r9.y, r0.y
-                    iadd r0.y, r9.z, r0.y
-                    iadd r0.y, r9.w, r0.y
-                    ishr r2.z, r4.x, l(5)
-                    ishr r4.z, r4.y, l(1)
-                    ishr r4.w, r4.y, l(2)
-                    ishr r6.z, r4.y, l(3)
-                    ishl r9.x, r2.z, l(18)
-                    ishl r9.y, r4.z, l(24)
-                    ishl r9.z, r4.w, l(25)
-                    ishl r9.w, r6.z, l(26)
-                    and r9.xyzw, r9.xyzw, l(0x00040000, 0x01000000, 0x02000000, 0x04000000)
-                    iadd r0.y, r0.y, r9.x
-                    iadd r0.y, r0.w, r0.y
-                    iadd r0.y, r8.w, r0.y
-                    ishr r4.zw, r6.xxxy, l(2)
-                    ishr r0.w, r6.x, l(3)
-                    ishr r2.z, r6.y, l(1)
-                    ishl r10.x, r4.z, l(21)
-                    ishl r10.y, r0.w, l(22)
-                    ishl r10.z, r2.z, l(28)
-                    ishl r10.w, r4.w, l(6)
-                    and r10.xyzw, r10.xyzw, l(0x00200000, 0x00400000, 0x10000000, 64)
-                    iadd r0.y, r0.y, r10.x
-                    iadd r0.y, r10.y, r0.y
-                    iadd r0.y, r2.w, r0.y
-                    iadd r0.y, r9.y, r0.y
-                    iadd r0.y, r9.z, r0.y
-                    iadd r0.y, r9.w, r0.y
-                    ishr r0.w, r4.y, l(4)
-                    ishl r0.w, r0.w, l(27)
-                    and r0.w, r0.w, l(0x08000000)
-                    iadd r0.y, r0.w, r0.y
-                    iadd r0.y, r10.z, r0.y
-                    iadd r0.y, r7.y, r0.y
-                    iadd r0.y, r8.z, r0.y
-                    iadd r3.z, r0.z, r0.y
-                    ishr r0.yz, r5.zzxz, l(3)
-                    ishr r0.w, r5.x, l(1)
-                    ishr r2.z, r5.x, l(2)
-                    and r0.y, r0.y, l(1)
-                    iadd r0.y, r0.y, r3.w
-                    iadd r0.y, r7.z, r0.y
-                    ishl r7.x, r0.w, l(2)
-                    ishl r7.y, r2.z, l(3)
-                    ishl r7.z, r0.z, l(4)
-                    and r7.xyz, r7.xyzx, l(4, 8, 16, 0)
-                    iadd r0.y, r0.y, r7.x
-                    iadd r0.y, r7.y, r0.y
-                    iadd r0.y, r7.z, r0.y
-                    ishr r0.z, r5.x, l(4)
-                    ishr r0.w, r5.w, l(1)
-                    ishr r2.z, r5.w, l(2)
-                    ishr r2.w, r5.w, l(3)
-                    ishl r8.x, r0.z, l(5)
-                    ishl r8.y, r0.w, l(8)
-                    ishl r8.z, r2.z, l(9)
-                    ishl r8.w, r2.w, l(10)
-                    and r8.xyzw, r8.xyzw, l(32, 256, 512, 1024)
-                    iadd r0.y, r0.y, r8.x
-                    iadd r0.y, r10.w, r0.y
-                    iadd r0.y, r7.w, r0.y
-                    iadd r0.y, r8.y, r0.y
-                    iadd r0.y, r8.z, r0.y
-                    iadd r0.y, r8.w, r0.y
-                    ishr r0.z, r5.w, l(4)
-                    ishl r0.z, r0.z, l(11)
-                    and r0.z, r0.z, l(2048)
-                    iadd r0.y, r0.z, r0.y
-                    ishr r0.z, r6.y, l(3)
-                    ishl r0.z, r0.z, l(12)
-                    and r0.z, r0.z, l(4096)
-                    iadd r0.y, r0.z, r0.y
-                    ishl r0.z, r2.y, l(13)
-                    and r0.z, r0.z, l(8192)
-                    iadd r0.y, r0.z, r0.y
-                    ushr r0.z, r2.y, l(1)
-                    ushr r0.w, r2.y, l(2)
-                    ushr r2.z, r2.y, l(3)
-                    ushr r2.w, r2.y, l(4)
-                    ishl r7.x, r0.z, l(14)
-                    ishl r7.y, r0.w, l(15)
-                    ishl r7.z, r2.z, l(16)
-                    ishl r7.w, r2.w, l(17)
-                    and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                    iadd r0.y, r0.y, r7.x
-                    iadd r0.y, r7.y, r0.y
-                    iadd r0.y, r7.z, r0.y
-                    iadd r3.w, r7.w, r0.y
-                  else 
-                    ieq r0.y, r2.x, l(9)
-                    if_nz r0.y
-                      ishl r7.x, r1.x, l(5)
-                      ishl r7.y, r1.y, l(15)
-                      ishl r7.z, r1.z, l(25)
-                      ishl r7.w, r1.w, l(3)
-                      and r7.xyzw, r7.xyzw, l(32, 0x00008000, 0x02000000, 8)
-                      iadd r0.y, r7.x, l(26)
-                      ishr r0.z, r1.x, l(1)
-                      ishr r0.w, r1.x, l(2)
-                      ishr r2.z, r1.x, l(3)
-                      ishr r2.w, r1.x, l(4)
-                      ishl r8.x, r0.z, l(6)
-                      ishl r8.y, r0.w, l(7)
-                      ishl r8.z, r2.z, l(8)
-                      ishl r8.w, r2.w, l(9)
-                      and r8.xyzw, r8.xyzw, l(64, 128, 256, 512)
-                      iadd r0.y, r0.y, r8.x
-                      iadd r0.y, r8.y, r0.y
-                      iadd r0.y, r8.z, r0.y
-                      iadd r0.y, r8.w, r0.y
-                      ishr r0.z, r1.x, l(5)
-                      ishr r0.w, r1.x, l(6)
-                      ishr r2.z, r1.x, l(7)
-                      ishr r2.w, r1.y, l(1)
-                      ishl r8.x, r0.z, l(10)
-                      ishl r8.y, r0.w, l(11)
-                      ishl r8.z, r2.z, l(12)
-                      ishl r8.w, r2.w, l(16)
-                      and r8.xyzw, r8.xyzw, l(1024, 2048, 4096, 0x00010000)
-                      iadd r0.y, r0.y, r8.x
-                      iadd r0.y, r8.y, r0.y
-                      iadd r0.y, r8.z, r0.y
-                      ishr r0.z, r6.y, l(1)
-                      ishr r0.w, r6.y, l(5)
-                      ishr r2.zw, r6.yyyx, l(4)
-                      ishl r9.x, r0.z, l(13)
-                      ishl r9.y, r0.w, l(1)
-                      ishl r9.z, r2.z, l(2)
-                      ishl r9.w, r2.w, l(8)
-                      and r9.xyzw, r9.xyzw, l(8192, 2, 4, 256)
-                      iadd r0.y, r0.y, r9.x
-                      ishr r0.zw, r5.zzzy, l(4)
-                      ishr r2.z, r5.z, l(5)
-                      ishr r2.w, r5.y, l(1)
-                      ishl r10.x, r0.z, l(14)
-                      ishl r10.y, r2.z, l(23)
-                      ishl r10.z, r0.w, l(24)
-                      ishl r10.w, r2.w, l(10)
-                      and r10.xyzw, r10.xyzw, l(0x00004000, 0x00800000, 0x01000000, 1024)
-                      iadd r0.y, r0.y, r10.x
-                      iadd r0.y, r7.y, r0.y
-                      iadd r0.y, r8.w, r0.y
-                      ishr r0.z, r1.y, l(2)
-                      ishr r0.w, r1.y, l(3)
-                      ishr r2.z, r1.y, l(4)
-                      ishr r2.w, r1.y, l(5)
-                      ishl r8.x, r0.z, l(17)
-                      ishl r8.y, r0.w, l(18)
-                      ishl r8.z, r2.z, l(19)
-                      ishl r8.w, r2.w, l(20)
-                      and r8.xyzw, r8.xyzw, l(0x00020000, 0x00040000, 0x00080000, 0x00100000)
-                      iadd r0.y, r0.y, r8.x
-                      iadd r0.y, r8.y, r0.y
-                      iadd r0.y, r8.z, r0.y
-                      iadd r0.y, r8.w, r0.y
-                      ishr r0.z, r1.y, l(6)
-                      ishr r0.w, r1.y, l(7)
-                      ishr r2.z, r1.z, l(1)
-                      ishr r2.w, r1.z, l(2)
-                      ishl r8.x, r0.z, l(21)
-                      ishl r8.y, r0.w, l(22)
-                      ishl r8.z, r2.z, l(26)
-                      ishl r8.w, r2.w, l(27)
-                      and r8.xyzw, r8.xyzw, l(0x00200000, 0x00400000, 0x04000000, 0x08000000)
-                      iadd r0.y, r0.y, r8.x
-                      iadd r0.y, r8.y, r0.y
-                      iadd r0.y, r10.y, r0.y
-                      iadd r0.y, r10.z, r0.y
-                      iadd r0.y, r7.z, r0.y
-                      iadd r0.y, r8.z, r0.y
-                      iadd r0.y, r8.w, r0.y
-                      ishr r0.z, r1.z, l(3)
-                      ishr r0.w, r1.z, l(4)
-                      ishr r2.z, r1.z, l(5)
-                      ishr r2.w, r1.z, l(6)
-                      ishl r7.x, r0.z, l(28)
-                      ishl r7.y, r0.w, l(29)
-                      ishl r7.z, r2.z, l(30)
-                      ishl r0.z, r2.w, l(31)
-                      and r7.xyz, r7.xyzx, l(0x10000000, 0x20000000, 0x40000000, 0)
-                      iadd r0.y, r0.y, r7.x
-                      iadd r0.y, r7.y, r0.y
-                      iadd r0.y, r7.z, r0.y
-                      iadd r3.x, r0.z, r0.y
-                      ishr r0.y, r1.z, l(7)
-                      ishr r0.z, r1.w, l(1)
-                      ishr r0.w, r1.w, l(2)
-                      ishr r2.z, r1.w, l(3)
-                      and r0.y, r0.y, l(1)
-                      iadd r0.y, r9.y, r0.y
-                      iadd r0.y, r9.z, r0.y
-                      iadd r0.y, r7.w, r0.y
-                      ishl r7.x, r0.z, l(4)
-                      ishl r7.y, r0.w, l(5)
-                      ishl r7.z, r2.z, l(6)
-                      and r7.xyz, r7.xyzx, l(16, 32, 64, 0)
-                      iadd r0.y, r0.y, r7.x
-                      iadd r0.y, r7.y, r0.y
-                      iadd r0.y, r7.z, r0.y
-                      ishr r0.z, r1.w, l(4)
-                      ishl r0.z, r0.z, l(7)
-                      and r0.z, r0.z, l(128)
-                      iadd r0.y, r0.z, r0.y
-                      iadd r0.y, r9.w, r0.y
-                      ishl r7.x, r5.y, l(9)
-                      ishl r7.y, r5.z, l(29)
-                      ishl r7.z, r5.x, l(1)
-                      ishl r7.w, r5.w, l(7)
-                      and r7.xyzw, r7.xyzw, l(512, 0x20000000, 2, 128)
-                      iadd r0.y, r0.y, r7.x
-                      iadd r0.y, r10.w, r0.y
-                      ishr r0.zw, r5.yyyz, l(2)
-                      ishr r2.z, r5.y, l(3)
-                      ishr r2.w, r5.z, l(1)
-                      ishl r8.x, r0.z, l(11)
-                      ishl r8.y, r2.z, l(12)
-                      ishl r8.z, r2.w, l(30)
-                      ishl r0.z, r0.w, l(31)
-                      and r8.xyz, r8.xyzx, l(2048, 4096, 0x40000000, 0)
-                      iadd r0.y, r0.y, r8.x
-                      iadd r0.y, r8.y, r0.y
-                      ishl r8.x, r4.x, l(13)
-                      ishl r8.y, r4.y, l(23)
-                      and r2.zw, r8.xxxy, l(0, 0, 8192, 0x00800000)
-                      iadd r0.y, r0.y, r2.z
-                      ishr r0.w, r4.x, l(1)
-                      ishr r2.z, r4.x, l(2)
-                      ishr r4.z, r4.x, l(3)
-                      ishr r4.w, r4.x, l(4)
-                      ishl r9.x, r0.w, l(14)
-                      ishl r9.y, r2.z, l(15)
-                      ishl r9.z, r4.z, l(16)
-                      ishl r9.w, r4.w, l(17)
-                      and r9.xyzw, r9.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                      iadd r0.y, r0.y, r9.x
-                      iadd r0.y, r9.y, r0.y
-                      iadd r0.y, r9.z, r0.y
-                      iadd r0.y, r9.w, r0.y
-                      ishl r8.x, r6.y, l(18)
-                      ishl r8.y, r6.x, l(19)
-                      and r4.zw, r8.xxxy, l(0, 0, 0x00040000, 0x00080000)
-                      iadd r0.y, r0.y, r4.z
-                      iadd r0.y, r4.w, r0.y
-                      ishr r0.w, r6.x, l(1)
-                      ishr r4.zw, r6.xxxy, l(2)
-                      ishr r2.z, r6.x, l(3)
-                      ishl r9.x, r0.w, l(20)
-                      ishl r9.y, r4.z, l(21)
-                      ishl r9.z, r2.z, l(22)
-                      ishl r9.w, r4.w, l(6)
-                      and r9.xyzw, r9.xyzw, l(0x00100000, 0x00200000, 0x00400000, 64)
-                      iadd r0.y, r0.y, r9.x
-                      iadd r0.y, r9.y, r0.y
-                      iadd r0.y, r9.z, r0.y
-                      iadd r0.y, r2.w, r0.y
-                      ishr r0.w, r4.y, l(1)
-                      ishr r2.z, r4.y, l(2)
-                      ishr r2.w, r4.y, l(3)
-                      ishr r4.z, r4.y, l(4)
-                      ishl r10.x, r0.w, l(24)
-                      ishl r10.y, r2.z, l(25)
-                      ishl r10.z, r2.w, l(26)
-                      ishl r10.w, r4.z, l(27)
-                      and r10.xyzw, r10.xyzw, l(0x01000000, 0x02000000, 0x04000000, 0x08000000)
-                      iadd r0.y, r0.y, r10.x
-                      iadd r0.y, r10.y, r0.y
-                      iadd r0.y, r10.z, r0.y
-                      iadd r0.y, r10.w, r0.y
-                      ishr r0.w, r4.y, l(5)
-                      ishl r0.w, r0.w, l(28)
-                      and r0.w, r0.w, l(0x10000000)
-                      iadd r0.y, r0.w, r0.y
-                      iadd r0.y, r7.y, r0.y
-                      iadd r0.y, r8.z, r0.y
-                      iadd r3.z, r0.z, r0.y
-                      ishr r0.yz, r5.zzxz, l(3)
-                      ishr r0.w, r5.x, l(1)
-                      ishr r2.z, r5.x, l(2)
-                      and r0.y, r0.y, l(1)
-                      iadd r0.y, r0.y, r3.w
-                      iadd r0.y, r7.z, r0.y
-                      ishl r7.x, r0.w, l(2)
-                      ishl r7.y, r2.z, l(3)
-                      ishl r7.z, r0.z, l(4)
-                      and r7.xyz, r7.xyzx, l(4, 8, 16, 0)
-                      iadd r0.y, r0.y, r7.x
-                      iadd r0.y, r7.y, r0.y
-                      iadd r0.y, r7.z, r0.y
-                      ishr r0.z, r5.x, l(4)
-                      ishr r0.w, r5.w, l(1)
-                      ishr r2.z, r5.w, l(2)
-                      ishr r2.w, r5.w, l(3)
-                      ishl r8.x, r0.z, l(5)
-                      ishl r8.y, r0.w, l(8)
-                      ishl r8.z, r2.z, l(9)
-                      ishl r8.w, r2.w, l(10)
-                      and r8.xyzw, r8.xyzw, l(32, 256, 512, 1024)
-                      iadd r0.y, r0.y, r8.x
-                      iadd r0.y, r9.w, r0.y
-                      iadd r0.y, r7.w, r0.y
-                      iadd r0.y, r8.y, r0.y
-                      iadd r0.y, r8.z, r0.y
-                      iadd r0.y, r8.w, r0.y
-                      ishr r0.z, r5.w, l(4)
-                      ishl r0.z, r0.z, l(11)
-                      and r0.z, r0.z, l(2048)
-                      iadd r0.y, r0.z, r0.y
-                      ishr r0.z, r6.y, l(3)
-                      ishl r0.z, r0.z, l(12)
-                      and r0.z, r0.z, l(4096)
-                      iadd r0.y, r0.z, r0.y
-                      ishl r0.z, r2.y, l(13)
-                      and r0.z, r0.z, l(8192)
-                      iadd r0.y, r0.z, r0.y
-                      ushr r0.z, r2.y, l(1)
-                      ushr r0.w, r2.y, l(2)
-                      ushr r2.z, r2.y, l(3)
-                      ushr r2.w, r2.y, l(4)
-                      ishl r7.x, r0.z, l(14)
-                      ishl r7.y, r0.w, l(15)
-                      ishl r7.z, r2.z, l(16)
-                      ishl r7.w, r2.w, l(17)
-                      and r7.xyzw, r7.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                      iadd r0.y, r0.y, r7.x
-                      iadd r0.y, r7.y, r0.y
-                      iadd r0.y, r7.z, r0.y
-                      iadd r3.w, r7.w, r0.y
-                    else 
-                      ieq r0.y, r2.x, l(10)
-                      if_nz r0.y
-                        ishl r7.x, r1.x, l(5)
-                        ishl r7.y, r1.y, l(15)
-                        ishl r7.z, r1.z, l(25)
-                        ishl r7.w, r1.w, l(3)
-                        and r7.xyzw, r7.xyzw, l(32, 0x00008000, 0x02000000, 8)
-                        iadd r0.y, r7.x, l(30)
-                        ishr r0.z, r1.x, l(1)
-                        ishr r0.w, r1.x, l(2)
-                        ishr r2.x, r1.x, l(3)
-                        ishr r2.z, r1.x, l(4)
-                        ishl r8.x, r0.z, l(6)
-                        ishl r8.y, r0.w, l(7)
-                        ishl r8.z, r2.x, l(8)
-                        ishl r8.w, r2.z, l(9)
-                        and r8.xyzw, r8.xyzw, l(64, 128, 256, 512)
-                        iadd r0.y, r0.y, r8.x
-                        iadd r0.y, r8.y, r0.y
-                        iadd r0.y, r8.z, r0.y
-                        iadd r0.y, r8.w, r0.y
-                        ishr r0.z, r1.x, l(5)
-                        ishr r0.w, r1.y, l(1)
-                        ishr r1.x, r1.y, l(2)
-                        ishr r2.x, r1.y, l(3)
-                        ishl r8.x, r0.z, l(10)
-                        ishl r8.y, r0.w, l(16)
-                        ishl r8.z, r1.x, l(17)
-                        ishl r8.w, r2.x, l(18)
-                        and r8.xyzw, r8.xyzw, l(1024, 0x00010000, 0x00020000, 0x00040000)
-                        iadd r0.y, r0.y, r8.x
-                        ishr r0.z, r6.x, l(4)
-                        ishr r0.w, r6.y, l(1)
-                        ishr r1.x, r6.y, l(2)
-                        ishr r2.x, r6.x, l(5)
-                        ishl r9.x, r0.z, l(11)
-                        ishl r9.y, r0.w, l(13)
-                        ishl r9.z, r1.x, l(23)
-                        ishl r0.z, r2.x, l(31)
-                        and r2.xzw, r9.xxyz, l(2048, 0, 8192, 0x00800000)
-                        iadd r0.y, r0.y, r2.x
-                        ishl r9.x, r6.y, l(12)
-                        ishl r9.y, r6.x, l(19)
-                        and r4.zw, r9.xxxy, l(0, 0, 4096, 0x00080000)
-                        iadd r0.y, r0.y, r4.z
-                        iadd r0.y, r2.z, r0.y
-                        ishr r2.xz, r5.zzyz, l(4)
-                        ishr r6.zw, r5.yyyz, l(5)
-                        ishl r9.x, r2.x, l(14)
-                        ishl r9.y, r6.z, l(21)
-                        ishl r9.z, r6.w, l(22)
-                        ishl r9.w, r2.z, l(24)
-                        and r9.xyzw, r9.xyzw, l(0x00004000, 0x00200000, 0x00400000, 0x01000000)
-                        iadd r0.y, r0.y, r9.x
-                        iadd r0.y, r7.y, r0.y
-                        iadd r0.y, r8.y, r0.y
-                        iadd r0.y, r8.z, r0.y
-                        iadd r0.y, r8.w, r0.y
-                        ishr r0.w, r1.y, l(4)
-                        ishr r1.x, r1.y, l(5)
-                        ishr r1.y, r1.z, l(1)
-                        ishr r2.x, r1.z, l(2)
-                        ishl r8.x, r0.w, l(19)
-                        ishl r8.y, r1.x, l(20)
-                        ishl r8.z, r1.y, l(26)
-                        ishl r8.w, r2.x, l(27)
-                        and r8.xyzw, r8.xyzw, l(0x00080000, 0x00100000, 0x04000000, 0x08000000)
-                        iadd r0.y, r0.y, r8.x
-                        iadd r0.y, r8.y, r0.y
-                        iadd r0.y, r9.y, r0.y
-                        iadd r0.y, r9.z, r0.y
-                        iadd r0.y, r2.w, r0.y
-                        iadd r0.y, r9.w, r0.y
-                        iadd r0.y, r7.z, r0.y
-                        iadd r0.y, r8.z, r0.y
-                        iadd r0.y, r8.w, r0.y
-                        ishr r0.w, r1.z, l(3)
-                        ishr r1.x, r1.z, l(4)
-                        ishr r1.y, r1.z, l(5)
-                        ishr r1.z, r1.w, l(1)
-                        ishl r8.x, r0.w, l(28)
-                        ishl r8.y, r1.x, l(29)
-                        ishl r8.z, r1.y, l(30)
-                        ishl r8.w, r1.z, l(4)
-                        and r8.xyzw, r8.xyzw, l(0x10000000, 0x20000000, 0x40000000, 16)
-                        iadd r0.y, r0.y, r8.x
-                        iadd r0.y, r8.y, r0.y
-                        iadd r0.y, r8.z, r0.y
-                        iadd r3.x, r0.z, r0.y
-                        ishr r0.y, r6.y, l(3)
-                        ishr r0.z, r6.y, l(5)
-                        ishr r0.w, r6.y, l(4)
-                        ishr r1.x, r6.x, l(1)
-                        and r0.y, r0.y, l(1)
-                        ishl r7.x, r0.z, l(1)
-                        ishl r7.y, r0.w, l(2)
-                        ishl r7.z, r1.x, l(20)
-                        and r1.xyz, r7.xyzx, l(2, 4, 0x00100000, 0)
-                        iadd r0.y, r0.y, r1.x
-                        iadd r0.y, r1.y, r0.y
-                        iadd r0.y, r7.w, r0.y
-                        iadd r0.y, r8.w, r0.y
-                        ishr r0.z, r1.w, l(2)
-                        ishr r0.w, r1.w, l(3)
-                        ishr r1.x, r1.w, l(4)
-                        ishr r1.y, r1.w, l(5)
-                        ishl r7.x, r0.z, l(5)
-                        ishl r7.y, r0.w, l(6)
-                        ishl r7.z, r1.x, l(7)
-                        ishl r7.w, r1.y, l(8)
-                        and r7.xyzw, r7.xyzw, l(32, 64, 128, 256)
-                        iadd r0.y, r0.y, r7.x
-                        iadd r0.y, r7.y, r0.y
-                        iadd r0.y, r7.z, r0.y
-                        iadd r0.y, r7.w, r0.y
-                        ishl r7.x, r5.y, l(9)
-                        ishl r7.y, r5.z, l(29)
-                        ishl r7.z, r5.x, l(1)
-                        ishl r7.w, r5.w, l(7)
-                        and r7.xyzw, r7.xyzw, l(512, 0x20000000, 2, 128)
-                        iadd r0.y, r0.y, r7.x
-                        ishr r0.zw, r5.yyyz, l(1)
-                        ishr r1.x, r5.y, l(2)
-                        ishr r1.y, r5.y, l(3)
-                        ishl r8.x, r0.z, l(10)
-                        ishl r8.y, r1.x, l(11)
-                        ishl r8.z, r1.y, l(12)
-                        ishl r8.w, r0.w, l(30)
-                        and r8.xyzw, r8.xyzw, l(1024, 2048, 4096, 0x40000000)
-                        iadd r0.y, r0.y, r8.x
-                        iadd r0.y, r8.y, r0.y
-                        iadd r0.y, r8.z, r0.y
-                        ishl r1.x, r4.x, l(13)
-                        ishl r1.y, r4.y, l(23)
-                        and r0.zw, r1.xxxy, l(0, 0, 8192, 0x00800000)
-                        iadd r0.y, r0.z, r0.y
-                        ishr r0.z, r4.x, l(1)
-                        ishr r1.x, r4.x, l(2)
-                        ishr r1.y, r4.x, l(3)
-                        ishr r1.w, r4.x, l(4)
-                        ishl r9.x, r0.z, l(14)
-                        ishl r9.y, r1.x, l(15)
-                        ishl r9.z, r1.y, l(16)
-                        ishl r9.w, r1.w, l(17)
-                        and r9.xyzw, r9.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                        iadd r0.y, r0.y, r9.x
-                        iadd r0.y, r9.y, r0.y
-                        iadd r0.y, r9.z, r0.y
-                        iadd r0.y, r9.w, r0.y
-                        ishr r0.z, r4.x, l(5)
-                        ishr r1.x, r4.y, l(1)
-                        ishr r1.y, r4.y, l(2)
-                        ishr r1.w, r4.y, l(3)
-                        ishl r9.x, r0.z, l(18)
-                        ishl r9.y, r1.x, l(24)
-                        ishl r9.z, r1.y, l(25)
-                        ishl r9.w, r1.w, l(26)
-                        and r9.xyzw, r9.xyzw, l(0x00040000, 0x01000000, 0x02000000, 0x04000000)
-                        iadd r0.y, r0.y, r9.x
-                        iadd r0.y, r4.w, r0.y
-                        iadd r0.y, r1.z, r0.y
-                        ishr r0.z, r6.x, l(2)
-                        ishr r1.x, r6.x, l(3)
-                        ishl r6.x, r0.z, l(21)
-                        ishl r6.y, r1.x, l(22)
-                        and r1.xy, r6.xyxx, l(0x00200000, 0x00400000, 0, 0)
-                        iadd r0.y, r0.y, r1.x
-                        iadd r0.y, r1.y, r0.y
-                        iadd r0.y, r0.w, r0.y
-                        iadd r0.y, r9.y, r0.y
-                        iadd r0.y, r9.z, r0.y
-                        iadd r0.y, r9.w, r0.y
-                        ishr r0.z, r4.y, l(4)
-                        ishr r0.w, r4.y, l(5)
-                        ishl r1.x, r0.z, l(27)
-                        ishl r1.y, r0.w, l(28)
-                        and r0.zw, r1.xxxy, l(0, 0, 0x08000000, 0x10000000)
-                        iadd r0.y, r0.z, r0.y
-                        iadd r0.y, r0.w, r0.y
-                        iadd r0.y, r7.y, r0.y
-                        iadd r0.y, r8.w, r0.y
-                        ishr r0.zw, r5.zzzx, l(2)
-                        ishr r1.x, r5.z, l(3)
-                        ishr r1.y, r5.x, l(1)
-                        ishl r4.x, r0.z, l(31)
-                        ishl r4.y, r1.y, l(2)
-                        ishl r4.z, r0.w, l(3)
-                        iadd r3.z, r0.y, r4.x
-                        and r0.y, r1.x, l(1)
-                        iadd r0.y, r0.y, r3.w
-                        iadd r0.y, r7.z, r0.y
-                        and r0.zw, r4.yyyz, l(0, 0, 4, 8)
-                        iadd r0.y, r0.z, r0.y
-                        iadd r0.y, r0.w, r0.y
-                        ishr r0.z, r5.x, l(3)
-                        ishr r0.w, r5.x, l(4)
-                        ishr r1.x, r5.x, l(5)
-                        ishr r1.y, r5.w, l(1)
-                        ishl r4.x, r0.z, l(4)
-                        ishl r4.y, r0.w, l(5)
-                        ishl r4.z, r1.x, l(6)
-                        ishl r4.w, r1.y, l(8)
-                        and r1.xyzw, r4.xyzw, l(16, 32, 64, 256)
-                        iadd r0.y, r0.y, r1.x
-                        iadd r0.y, r1.y, r0.y
-                        iadd r0.y, r1.z, r0.y
-                        iadd r0.y, r7.w, r0.y
-                        iadd r0.y, r1.w, r0.y
-                        ishr r0.z, r5.w, l(2)
-                        ishr r0.w, r5.w, l(3)
-                        ishr r1.x, r5.w, l(4)
-                        ishr r1.y, r5.w, l(5)
-                        ishl r4.x, r0.z, l(9)
-                        ishl r4.y, r0.w, l(10)
-                        ishl r4.z, r1.x, l(11)
-                        ishl r4.w, r1.y, l(12)
-                        and r1.xyzw, r4.xyzw, l(512, 1024, 2048, 4096)
-                        iadd r0.y, r0.y, r1.x
-                        iadd r0.y, r1.y, r0.y
-                        iadd r0.y, r1.z, r0.y
-                        iadd r0.y, r1.w, r0.y
-                        ishl r0.z, r2.y, l(13)
-                        and r0.z, r0.z, l(8192)
-                        iadd r0.y, r0.z, r0.y
-                        ushr r0.z, r2.y, l(1)
-                        ushr r0.w, r2.y, l(2)
-                        ushr r1.x, r2.y, l(3)
-                        ushr r1.y, r2.y, l(4)
-                        ishl r2.x, r0.z, l(14)
-                        ishl r2.y, r0.w, l(15)
-                        ishl r2.z, r1.x, l(16)
-                        ishl r2.w, r1.y, l(17)
-                        and r1.xyzw, r2.xyzw, l(0x00004000, 0x00008000, 0x00010000, 0x00020000)
-                        iadd r0.y, r0.y, r1.x
-                        iadd r0.y, r1.y, r0.y
-                        iadd r0.y, r1.z, r0.y
-                        iadd r3.w, r1.w, r0.y
-                      else 
-                        mov r3.xz, l(0,0,0,0)
-                      endif 
-                    endif 
-                  endif 
-                endif 
-              endif 
-            endif 
-          endif 
-        endif 
-      endif 
-    endif 
-  endif 
-  store_structured u0.xyzw, r0.x, l(0), r3.xzwy
-endif 
-ret 
-// Approximately 0 instruction slots used
-#endif
-
-const BYTE BC6HEncode_EncodeBlockCS[] =
-{
-     68,  88,  66,  67, 106, 242, 
-     47,  44,  29, 251, 192, 175, 
-    230,  64, 141,  23, 223, 196, 
-     86,  63,   1,   0,   0,   0, 
-     28, 173,   1,   0,   3,   0, 
-      0,   0,  44,   0,   0,   0, 
-     60,   0,   0,   0,  76,   0, 
-      0,   0,  73,  83,  71,  78, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     79,  83,  71,  78,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  83,  72, 
-     69,  88, 200, 172,   1,   0, 
-     64,   0,   5,   0,  50, 107, 
-      0,   0, 106,   8,   0,   1, 
-     53,  24,   0,   0,  58,   1, 
-      0,   0, 204, 204,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    136, 136,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 238, 238, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 200, 236,   0,   0, 
-     15,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-    128, 200,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0, 236, 254, 
-      0,   0,  15,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0, 200, 254,   0,   0, 
-     15,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-    128, 236,   0,   0,  15,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,   0, 200, 
-      0,   0,  15,   0,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0, 236, 255,   0,   0, 
-     15,   0,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,   0, 
-    128, 254,   0,   0,  15,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,   0, 232, 
-      0,   0,  15,   0,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0, 232, 255,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0, 255,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      1,   0,   0,   0, 240, 255, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   2,   0, 
-      0,   0,   0, 240,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   2,   0,   0,   0, 
-     16, 247,   0,   0,  15,   0, 
-      0,   0,   4,   0,   0,   0, 
-      2,   0,   0,   0, 142,   0, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,   0,   0,   2,   0, 
-      0,   0,   0, 113,   0,   0, 
-      8,   0,   0,   0,   4,   0, 
-      0,   0,   2,   0,   0,   0, 
-    206,   8,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-      2,   0,   0,   0, 140,   0, 
-      0,   0,   2,   0,   0,   0, 
-      5,   0,   0,   0,   2,   0, 
-      0,   0,  16, 115,   0,   0, 
-      8,   0,   0,   0,   5,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,  49,   0,   0,   8,   0, 
-      0,   0,   5,   0,   0,   0, 
-      2,   0,   0,   0, 206, 140, 
-      0,   0,  15,   0,   0,   0, 
-      5,   0,   0,   0,   3,   0, 
-      0,   0, 140,   8,   0,   0, 
-      2,   0,   0,   0,   6,   0, 
-      0,   0,   3,   0,   0,   0, 
-     16,  49,   0,   0,   8,   0, 
-      0,   0,   6,   0,   0,   0, 
-      3,   0,   0,   0, 102, 102, 
-      0,   0,   2,   0,   0,   0, 
-      6,   0,   0,   0,   3,   0, 
-      0,   0, 108,  54,   0,   0, 
-      2,   0,   0,   0,   6,   0, 
-      0,   0,   3,   0,   0,   0, 
-    232,  23,   0,   0,   8,   0, 
-      0,   0,   6,   0,   0,   0, 
-      3,   0,   0,   0, 240,  15, 
-      0,   0,   8,   0,   0,   0, 
-      7,   0,   0,   0,   3,   0, 
-      0,   0, 142, 113,   0,   0, 
-      2,   0,   0,   0,   7,   0, 
-      0,   0,   3,   0,   0,   0, 
-    156,  57,   0,   0,   2,   0, 
-      0,   0,   7,   0,   0,   0, 
-      3,   0,   0,   0, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-      7,   0,   0,   0,   3,   0, 
-      0,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,   4,   0,   0,   0, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-      4,   0,   0,   0, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-      8,   0,   0,   0,   4,   0, 
-      0,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,   4,   0,   0,   0, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-      4,   0,   0,   0, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-      9,   0,   0,   0,   4,   0, 
-      0,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0,   9,   0, 
-      0,   0,   4,   0,   0,   0, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   5,   0,   0,   0, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-      5,   0,   0,   0, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-     10,   0,   0,   0,   5,   0, 
-      0,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  11,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     11,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  11,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  11,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     12,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  12,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     12,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  13,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  13,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  13,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  14,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  14,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  14,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   7,   0,   0,   0, 
-     10,   0,   0,   0,   5,   0, 
-      0,   0,   5,   0,   0,   0, 
-      5,   0,   0,   0,   7,   0, 
-      0,   0,   6,   0,   0,   0, 
-      6,   0,   0,   0,   6,   0, 
-      0,   0,  11,   0,   0,   0, 
-      5,   0,   0,   0,   4,   0, 
-      0,   0,   4,   0,   0,   0, 
-     11,   0,   0,   0,   4,   0, 
-      0,   0,   5,   0,   0,   0, 
-      4,   0,   0,   0,  11,   0, 
-      0,   0,   4,   0,   0,   0, 
-      4,   0,   0,   0,   5,   0, 
-      0,   0,   9,   0,   0,   0, 
-      5,   0,   0,   0,   5,   0, 
-      0,   0,   5,   0,   0,   0, 
-      8,   0,   0,   0,   6,   0, 
-      0,   0,   5,   0,   0,   0, 
-      5,   0,   0,   0,   8,   0, 
-      0,   0,   5,   0,   0,   0, 
-      6,   0,   0,   0,   5,   0, 
-      0,   0,   8,   0,   0,   0, 
-      5,   0,   0,   0,   5,   0, 
-      0,   0,   6,   0,   0,   0, 
-      6,   0,   0,   0,   6,   0, 
-      0,   0,   6,   0,   0,   0, 
-      6,   0,   0,   0,  10,   0, 
-      0,   0,  10,   0,   0,   0, 
-     10,   0,   0,   0,  10,   0, 
-      0,   0,  11,   0,   0,   0, 
-      9,   0,   0,   0,   9,   0, 
-      0,   0,   9,   0,   0,   0, 
-     12,   0,   0,   0,   8,   0, 
-      0,   0,   8,   0,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   0,   4,   0,   0,   0, 
-      4,   0,   0,   0,   4,   0, 
-      0,   0,  89,   0,   0,   4, 
-     70, 142,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     88,  24,   0,   4,   0, 112, 
-     16,   0,   0,   0,   0,   0, 
-     85,  85,   0,   0, 162,   0, 
-      0,   4,   0, 112,  16,   0, 
-      1,   0,   0,   0,  16,   0, 
-      0,   0, 158,   0,   0,   4, 
-      0, 224,  17,   0,   0,   0, 
-      0,   0,  16,   0,   0,   0, 
-     95,   0,   0,   2,   0,  64, 
-      2,   0,  95,   0,   0,   2, 
-     18,  16,   2,   0, 104,   0, 
-      0,   2,  18,   0,   0,   0, 
-    160,   0,   0,   5,   0, 240, 
-     17,   0,   0,   0,   0,   0, 
-     84,   0,   0,   0,  64,   0, 
-      0,   0, 155,   0,   0,   4, 
-     64,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   6,  18,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  16,   2,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   8,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10, 128,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16, 128,  65,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,  79,   0, 
-      0,  10, 242,   0,  16,   0, 
-      1,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-      2,   0,   0,   0,   8,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  78,   0,   0,   9, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,   0, 208,   0,   0, 
-     10,   0,  16,   0,   0,   0, 
-      0,   0,  26, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  35,   0,   0,  11, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16, 128, 
-     65,   0,   0,   0,   0,   0, 
-      0,   0,  26, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   8, 194,   0,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     45,   0,   0,   7, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   2,   0, 
-      0,   0,  70, 126,  16,   0, 
-      0,   0,   0,   0,  16,   0, 
-      0,  10, 130,   0,  16,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0, 208, 179, 
-     89,  62,  89,  23,  55,  63, 
-    152, 221, 147,  61,   0,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-      6,   5,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 127, 255, 255, 
-    127,   0, 255, 255, 255, 127, 
-    255, 255, 127,   0,  79,   0, 
-      0,  10,  50,   0,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0, 255, 239, 255,  71, 
-    255, 239, 255,  71,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    134,   0,  16,   0,   4,   0, 
-      0,   0,  79,   0,   0,  10, 
-     50,   0,  16,   0,   5,   0, 
-      0,   0, 134,   0,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 128,  56, 
-      0,   0, 128,  56,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 194,   0, 
-     16,   0,   5,   0,   0,   0, 
-      6,   8,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  30,   0, 
-      0,  11, 194,   0,  16,   0, 
-      5,   0,   0,   0, 166,  14, 
-     16, 128,  65,   0,   0,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 113,   0, 
-      0,   0, 113,   0,   0,   0, 
-     30,   0,   0,  10, 162,   0, 
-     16,   0,   4,   0,   0,   0, 
-     86,  13,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    128,   0,   0,   0,   0,   0, 
-      0,   0, 128,   0,  85,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  85,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,  10,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-    134,   0,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0, 200,   0,   0, 
-      0, 200,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9,  50,   0,  16,   0, 
-      4,   0,   0,   0,  70,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   0,  16,   0,   6,   0, 
-      0,   0,  70,   0,  16,   0, 
-      4,   0,   0,   0,  30,   0, 
-      0,  10, 194,   0,  16,   0, 
-      4,   0,   0,   0,   6,   4, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    255,  15,   0,   0, 255,  15, 
-      0,   0,  85,   0,   0,   7, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  70,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,  10,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   0,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  50,   0,  16,   0, 
-      4,   0,   0,   0,  70,   0, 
-     16,   0,   4,   0,   0,   0, 
-    230,  10,  16,   0,   4,   0, 
-      0,   0,  85,   0,   0,   7, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  70,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,  10,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   0,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  12,  50,   0,  16,   0, 
-      2,   0,   0,   0,  70,   0, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  70,   0,  16,   0, 
-      4,   0,   0,   0,  30,   0, 
-      0,   7,  50,   0,  16,   0, 
-      4,   0,   0,   0,  70,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   0,  16,   0,   2,   0, 
-      0,   0,   1,   0,   0,  10, 
-     50,   0,  16,   0,   2,   0, 
-      0,   0, 166,  10,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 127, 
-    255, 255, 127,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 255, 239, 
-    255,  71,  10,   0,  16,   0, 
-      2,   0,   0,   0,  79,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-    128,  56,  85,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     30,   0,   0,   8, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16, 128,  65,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0, 113,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0, 128,   0, 
-     85,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0, 200,  55,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0, 255,  15,   0,   0, 
-     85,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0, 255, 127, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0, 255, 127,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     32,   0,   0,   8, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  95,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     78,   0,   0,  11, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-      0, 208,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-     31,   0,   0,   0,   0,   0, 
-      0,   0,  79,   0,   0,  10, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 123,   0,   0, 255, 123, 
-      0,   0, 255, 123,   0,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  78,   0,   0,  11, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,   0, 208,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,   0,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0, 224, 255, 
-     15,   0, 224, 255,  15,   0, 
-    224, 255,  15,   0,   0,   0, 
-      0,   0,  78,   0,   0,  11, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,   0, 208,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,   0,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-      0,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1, 128, 255, 255,   1, 128, 
-    255, 255,   1, 128, 255, 255, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  70, 112,  16,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5, 242,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   5, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-    150,  15,  16,   0,   3,   0, 
-      0,   0,  18,   0,   0,   1, 
-     85,   0,   0,   8,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10, 144, 144,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     55,   0,   0,  12, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-     86,   5,  16,   0,   1,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 127, 255, 255, 
-    255, 127, 255, 255, 255, 127, 
-      0,   0,   0, 128,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     55,   0,   0,  12, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     86,   5,  16,   0,   1,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128, 255, 255, 127, 127, 
-    255, 255, 127, 255, 150,  15, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1,  18,   0, 
-      0,   1,  80,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     85,   0,   0,   8, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10, 144, 144,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     32,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,  12, 242,   0,  16,   0, 
-      4,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 127, 255, 255, 
-    255, 127, 255, 255, 255, 127, 
-      0,   0,   0, 128,  55,   0, 
-      0,  12, 242,   0,  16,   0, 
-      5,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-    150,  15,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128, 255, 255, 127, 127, 
-    255, 255, 127, 255,  18,   0, 
-      0,   1,  54,   0,   0,   8, 
-    242,   0,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 127, 255, 255, 
-    255, 127, 255, 255, 255, 127, 
-      0,   0,   0, 128,  54,   0, 
-      0,   8, 242,   0,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0, 128, 
-      0,   0,   0, 128, 255, 255, 
-    127, 127, 255, 255, 127, 255, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,   1,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     79,   0,   0,  10, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      8,   0,   0,   0,   4,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      3,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  76,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  21,   0,   0,   1, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  49,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  80,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      3,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  76,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  21,   0,   0,   1, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  49,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  80,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      3,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  76,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  21,   0,   0,   1, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  49,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  80,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      3,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     80,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     80,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  32,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     80,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26, 144, 144,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  21,   0,   0,   1, 
-     30,   0,   0,   8, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16, 128,  65,   0, 
-      0,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,  43,   0,   0,   5, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  16,   0, 
-      0,   7,  34,   0,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   8, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16, 128,  65,   0, 
-      0,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  43,   0,   0,   5, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  16,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  49,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     29,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  56,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     14,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  28,   0, 
-      0,   5, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     55,   0,   0,   9, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  86,   9,  16,   0, 
-      3,   0,   0,   0,  86,   9, 
-     16,   0,   4,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0, 168,   0,   0,   8, 
-     50, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  68,   0, 
-      0,   0, 230,  10,  16,   0, 
-      2,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     79,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10, 144, 
-    144,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  21,   0, 
-      0,   1,  85,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      4,   0,   0,   0,  43,   0, 
-      0,   5, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-    167,   0,   0,   8, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16, 128, 
-     65,   0,   0,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  43,   0, 
-      0,   5, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     16,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  18,   0, 
-      0,   1, 167,   0,   0,   9, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      5,   0,   0,   0,  43,   0, 
-      0,   5, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-    167,   0,   0,   8, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16, 128, 
-     65,   0,   0,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  43,   0, 
-      0,   5, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     16,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  21,   0, 
-      0,   1,  16,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     29,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  29,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     49,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  56,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0, 253, 255, 
-    125,  66,  14,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     28,   0,   0,   5, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  55,   0,   0,  10, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  42, 144, 
-    144,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  79,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0, 224, 255, 
-    255, 255,  41,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     54,   0,   0,   8,  98,   0, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0, 166,  10,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   4,   0,   0,   0, 
-    166,  14,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   5, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9,  50,   0,  16,   0, 
-      3,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-    230,  10,  16,   0,   2,   0, 
-      0,   0,  70,   0,  16,   0, 
-      3,   0,   0,   0,  18,   0, 
-      0,   1,  29,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     29,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  49,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     56,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  14,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  28,   0,   0,   5, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,  10,  18,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58, 144, 144,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  31,   0,   0,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-     54,   0,   0,   5,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  18,   0,   0,   1, 
-     79,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      1,   0,   0,   0,  35,   0, 
-      0,   9,  18,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  54,   0,   0,   5, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  18,   0, 
-      0,   1,  39,   0,   0,   8, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  26, 144, 
-    144,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  32,   0, 
-      0,   8,  34,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     26, 144, 144,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   4,  16,   0,   1,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,  79,   0, 
-      0,   7,  34,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  35,   0,   0,   9, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  34,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  55,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-     34,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,  55,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,  79,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  35,   0,   0,  12, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0, 166,  10,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   3,   0,   0,   0, 
-    166,  14,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,  10, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0, 166,  14,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 240, 255, 
-    255, 255, 240, 255, 255, 255, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  55,   0,   0,   9, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9,  50,   0,  16,   0, 
-      3,   0,   0,   0,  86,   5, 
-     16,   0,   1,   0,   0,   0, 
-     70,   0,  16,   0,   4,   0, 
-      0,   0,  70,   0,  16,   0, 
-      5,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 168,   0,   0,   8, 
-     50, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  70,   0,  16,   0, 
-      3,   0,   0,   0,  18,   0, 
-      0,   1,  54,   0,   0,   8, 
-     50,   0,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   8,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     50,   0,  16,   0,   1,   0, 
-      0,   0,  70,   0,  16,   0, 
-      4,   0,   0,   0,  70,   0, 
-     16,   0,   5,   0,   0,   0, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     70,   0,  16,   0,   1,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  79,   0, 
-      0,  10,  50,   0,  16,   0, 
-      1,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   4,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7, 146,   0,  16,   0, 
-      1,   0,   0,   0,   6,   4, 
-     16,   0,   4,   0,   0,   0, 
-      6,   4,  16,   0,   5,   0, 
-      0,   0, 168,   0,   0,   8, 
-     50, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0, 198,   0,  16,   0, 
-      1,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   8,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-    146,   0,  16,   0,   1,   0, 
-      0,   0,   6,   4,  16,   0, 
-      4,   0,   0,   0,   6,   4, 
-     16,   0,   5,   0,   0,   0, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-    198,   0,  16,   0,   1,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   8,  50,   0,  16,   0, 
-      4,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  50,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   0,  16,   0,   4,   0, 
-      0,   0,  70,   0,  16,   0, 
-      5,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  32,   0, 
-      0,  10,  50,   0,  16,   0, 
-      1,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   2,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  32,   0,   0,   8, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  42, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     95,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      1,   0,   0,   0,  33,   0, 
-      0,   9,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10, 144, 
-    208,   0,  64,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  55,   0,   0,  15, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,  15, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,   6,   0,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-      6,   0,  16,   0,   1,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0,   0,   0, 
-      0,   0,  32,   0,   0,  10, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0,   0,   0,   0,   0, 
-     41,   0,   0,   9,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  10, 144, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  41,   0, 
-      0,   9, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     10, 144, 208,   0,  64,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   9, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     10, 144, 208,   0,  64,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,   6,   0,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   6,   0,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     18,   0,   0,   1,  33,   0, 
-      0,   9,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10, 144, 
-    208,   0,  64,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  55,   0,   0,  15, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,  15, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,   6,   0,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-      6,   0,  16,   0,   1,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  33,   0, 
-      0,  10, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   9, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  10, 144, 
-    208,   0,  64,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0, 166,  10, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0, 166,  10, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     17,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16, 128, 
-     65,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0, 246,  15,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0, 246,  15,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     21,   0,   0,   1,  30,   0, 
-      0,   8, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     55,   0,   0,  11, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-      6, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-    150,   5,  16,   0,   4,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,  10,  50,   0,  16,   0, 
-      1,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  80,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     32,   0,   0,   8,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  95,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  33,   0,   0,   9, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10, 144, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-      6,   0,  16,   0,   1,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  60,   0, 
-      0,   7, 178,   0,  16,   0, 
-      1,   0,   0,   0,   6,   0, 
-     16,   0,   1,   0,   0,   0, 
-     70,   8,  16,   0,   8,   0, 
-      0,   0,  32,   0,   0,  10, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   9,  66,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     10, 144, 208,   0,  64,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  41,   0,   0,   9, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  10, 144, 
-    208,   0,  64,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   9, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  10, 144, 
-    208,   0,  64,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-    166,  10,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-    166,  10,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  55,   0, 
-      0,   9, 178,   0,  16,   0, 
-      1,   0,   0,   0,  70,  12, 
-     16,   0,   1,   0,   0,   0, 
-     70,   8,  16,   0,   6,   0, 
-      0,   0,  70,   8,  16,   0, 
-      9,   0,   0,   0,  18,   0, 
-      0,   1,  33,   0,   0,   9, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10, 144, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-    166,  10,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-      9,   0,   0,   0, 166,  10, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     33,   0,   0,  10, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  32,   0,   0,  10, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   9,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  10, 144, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  41,   0,   0,   7, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0, 246,  15,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0, 246,  15,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     16,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  32,   0,   0,  10, 
-    114,   0,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,   2,  64, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   8, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16, 128,  65,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  16,   0,   0,   0, 
-    246,  15,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  17,   0,   0,   0, 
-    246,  15,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 178,   0,  16,   0, 
-      1,   0,   0,   0,  70,   8, 
-     16,   0,   9,   0,   0,   0, 
-     70,   8,  16,   0,   6,   0, 
-      0,   0,  70,   8,  16,   0, 
-     11,   0,   0,   0,  21,   0, 
-      0,   1,  30,   0,   0,   8, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16, 128, 
-     65,   0,   0,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   8, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      4,   0,   0,   0,  70,   3, 
-     16,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,  11, 242,   0,  16,   0, 
-      5,   0,   0,   0,   6, 144, 
-    208,   0,  32,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-     55,   0,   0,  11,  50,   0, 
-     16,   0,   1,   0,   0,   0, 
-      6, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0, 150,   5, 
-     16,   0,   4,   0,   0,   0, 
-    214,   5,  16,   0,   1,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0, 168,   0, 
-      0,   8,  50, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0,  70,   0, 
-     16,   0,   1,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   6,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0, 150, 240, 
-     17,   0,   0,   0,   0,   0, 
-     31,   0,   0,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   9,  18,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     10, 144, 208,   0,  64,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   9,  34,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     26, 144, 208,   0,  64,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   9,  66,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42, 144, 208,   0,  64,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   9, 130,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     58, 144, 208,   0,  64,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  33,   0, 
-      0,  10, 114,   0,  16,   0, 
-      6,   0,   0,   0,  38,   9, 
-     16,   0,   1,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,  12, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-      0,   0,   0,   0, 150, 151, 
-    208,   0,  64,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  33,   0,   0,   7, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  38,   9,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,  10, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  38,   9,  16,   0, 
-      1,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-      9,   0,   0,   0,  38,   9, 
-     16,   0,   1,   0,   0,   0, 
-     34,   0,   0,   7, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255,   1,   0,   0,   7, 
-    226,   0,  16,   0,   5,   0, 
-      0,   0, 166,   4,  16,   0, 
-      1,   0,   0,   0,  86,  14, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 226,   0, 
-     16,   0,   5,   0,   0,   0, 
-      6,   9,  16,   0,   9,   0, 
-      0,   0,   6,   9,  16,   0, 
-      8,   0,   0,   0,  86,  14, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 226,   0, 
-     16,   0,   5,   0,   0,   0, 
-      6,   9,  16,   0,   6,   0, 
-      0,   0,   6,   9,  16,   0, 
-      7,   0,   0,   0,  86,  14, 
-     16,   0,   5,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0,   6,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,   0,   0,   7, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   4,  16,   0,   1,   0, 
-      0,   0,   6,   0,  16,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   5, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  55,   0,   0,  11, 
-    242,   0,  16,   0,   4,   0, 
-      0,   0,   6, 144, 208,   0, 
-     32,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  55,   0, 
-      0,  11,  50,   0,  16,   0, 
-      1,   0,   0,   0,   6, 144, 
-    208,   0,  32,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0, 230,  10,  16,   0, 
-      5,   0,   0,   0, 230,  10, 
-     16,   0,   2,   0,   0,   0, 
-     18,   0,   0,   1,  31,   0, 
-      4,   5,  10, 144, 208,   0, 
-     32,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   9,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  10, 144, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   9,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  26, 144, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   9,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42, 144, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   9, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  58, 144, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,   1,   0, 
-      0,   7, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      6,   0,  16,   0,   5,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  38,   9,  16,   0, 
-      1,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,  12, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0, 150, 151, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     33,   0,   0,   7, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     38,   9,  16,   0,   1,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,  10, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     38,   9,  16,   0,   1,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  38,   9,  16,   0, 
-      1,   0,   0,   0,  34,   0, 
-      0,   7, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   1,   0,   0,   7, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  38,   9,  16,   0, 
-      1,   0,   0,   0, 150,   7, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   1,   0,   0,   0, 
-    150,   4,  16,   0,   6,   0, 
-      0,   0, 150,   4,  16,   0, 
-      7,   0,   0,   0, 150,   4, 
-     16,   0,   5,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,  18,   0,   0,   1, 
-     41,   0,   0,   9, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  10, 144, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,   0,   0,   7, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-    246,  15,  16,   0,   1,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0,   1,   0, 
-      0,   7,  50,   0,  16,   0, 
-      1,   0,   0,   0, 246,  15, 
-     16,   0,   1,   0,   0,   0, 
-     70,   0,  16,   0,   1,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1,  18,   0, 
-      0,   1,  80,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     31,   0,   4,   5,  10, 144, 
-    208,   0,  32,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,  12, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0, 150, 151, 208,   0, 
-     64,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     33,   0,   0,   7, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,  10, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  34,   0, 
-      0,   7, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  41,   0,   0,   9, 
-     18,   0,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  26, 144, 
-    208,   0,  64,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   9, 
-     34,   0,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42, 144, 
-    208,   0,  64,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   9, 
-     66,   0,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  58, 144, 
-    208,   0,  64,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,  10, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-      1,   0,   0,   7, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  33,   0, 
-      0,  10, 114,   0,  16,   0, 
-      5,   0,   0,   0,  38,   9, 
-     16,   0,   1,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,   7, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  38,   9,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  38,   9, 
-     16,   0,   1,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     38,   9,  16,   0,   1,   0, 
-      0,   0,  34,   0,   0,   7, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      1,   0,   0,   7, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     38,   9,  16,   0,   1,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      1,   0,   0,   0, 150,   4, 
-     16,   0,   5,   0,   0,   0, 
-    150,   4,  16,   0,   6,   0, 
-      0,   0, 150,   4,  16,   0, 
-      7,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     18,   0,   0,   1,  41,   0, 
-      0,   9, 130,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     10, 144, 208,   0,  64,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  54,   0,   0,   5, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   7, 242,   0,  16,   0, 
-      4,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,   1,   0,   0,   7, 
-     50,   0,  16,   0,   1,   0, 
-      0,   0, 246,  15,  16,   0, 
-      0,   0,   0,   0,  70,   0, 
-     16,   0,   1,   0,   0,   0, 
-     21,   0,   0,   1,  18,   0, 
-      0,   1,  54,   0,   0,   5, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-     50, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  68,   0, 
-      0,   0,  70,   0,  16,   0, 
-      1,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   0,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0, 254, 255, 
-    255, 255,  32,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   2,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-      0,  32,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,  64,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,  16,   0,   0, 
-      0,  32,   0,   0,   0,  64, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-     16,   0,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   2,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  32,   0,   0,   0,   0, 
-    128,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   0,  32,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-     64,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-      0,   4,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  27,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,   0,  32, 
-      0,   0,   0,  64,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  18,   0,   0,   1, 
-     32,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   2,   8,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-     64,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   2,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,   0,  32, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,   0,   0,   4,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,  16,   0,   0,   0,  32, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,   0,   0,  16,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-     32,   0,   0,   0,  64,   0, 
-      0,   0, 128,   0,   0,   0, 
-      0,   1,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   2, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,   0,   0,   0,  16, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   6,   4,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  32, 
-      0,   0,   0,   0, 128,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0, 128, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  19,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  20,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     21,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      4,   0,   0,   0,   8,   0, 
-      0,   0,  16,   0,   0,   0, 
-     32,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   4,   0,   0,   0, 
-     86,   9,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,  64,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  25,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,  16, 
-      0,   0,   0,  32,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  25,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-     32,   0,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   2, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,  64,   0, 
-      0,   0, 128,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,   0,   0,   0,  16, 
-      0,   0,   0,  32,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-      0,   0,   4,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  19,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  20,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     21,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  16,   0,   0,   0, 
-     32,   0,   0,   0,  64,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  27,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0, 128,   0,   0,   0, 
-      0,   1,   0,   0,   0,   4, 
-      0,   0,   0,   8,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,  16, 
-      0,   0,   0,  32,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      2,   0,   0,   0,   4,   0, 
-      0,   0,  16,   0,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   2,   0,   0, 
-      0,   4,   0,   0,   0,  16, 
-      0,   0,   0,   0,  32,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   8,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  32,   0,   0,   0,   0, 
-    128,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   0,   0,   1,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   4,   0, 
-      0,   0,  86,   9,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,  64,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   2,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   4,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  32, 
-      0,   0,   0,  64,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  25,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-     32,   0,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   2, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,  64,   0, 
-      0,   0, 128,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,   0,   0,   0,  16, 
-      0,   0,   0,  32,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-      0,   0,   4,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  19,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  20,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     21,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  16,   0,   0,   0, 
-     32,   0,   0,   0,  64,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  27,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0, 128,   0,   0,   0, 
-      0,   1,   0,   0,   0,   4, 
-      0,   0,   0,   8,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,  16, 
-      0,   0,   0,  32,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      2,   0,   0,   0,   4,   0, 
-      0,   0,  16,   0,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   2,   0,   0, 
-      0,   4,   0,   0,   0,  16, 
-      0,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   8,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  32,   0,   0,   0,   0, 
-    128,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   4,   0,   0,   0, 
-      6,   4,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   1,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   8,   0,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,  64,   0,   0,   0, 
-      0,   8,   0,   0,   0,  16, 
-      0,   0,   0,  32,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   6,   4,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   2,   0,   0,   0,   4, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,  64,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   8,  82,   0,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  18,   0, 
-      0,   1,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0, 252, 255,  32,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     98,   0,  16,   0,   0,   0, 
-      0,   0,  86,   6,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      4,   0,   0,   0,   8,   0, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   2,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-     64,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   2,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   9,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,   0,  32, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,   0,   0,   4,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,  16,   0,   0,   0,  32, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,   0,   0,  16,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   1, 
-      0,   0,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   2, 
-      0,   0,   0,   0,   0,  32, 
-      2,   0,   0,   0, 128,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,  86,   9,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   6,   4,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  16, 
-      0,   0,   0,   0,   0,  64, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   4,   0,   0,   0, 
-      6,   4,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  32,   0,   0, 
-      0,   0, 128,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  19,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   6,   0, 
-      0,   0,   6,   4,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   8,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,  16,  64,   0,   0,   0, 
-      0,  16,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   4,   0,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   1,   0,   0, 
-      0,   2,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,  32,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     98,   0,  16,   0,   0,   0, 
-      0,   0,  86,   6,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-    166,   6,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   4,   0,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-     64,   0,   0,   0,   0,   1, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   0,   0,  32,   0,   0, 
-      0,   0, 128,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   2,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     10,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,  14,  16,   0,  10,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,  10,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  19,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,   6,   4,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  16, 
-      0,   0,   0,   0,   8,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   8,   0,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     10,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-      0,  32,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0, 134,   3,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,  64, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,  64,   0, 
-      0,   0, 128,   0,   0,   0, 
-      0,   1,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   2,   0,   0,   0,   0, 
-      0,  32,   2,   0,   0,   0, 
-    128,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,  86,   9,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-      0,   0,   0,  64,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   9,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  32,   0,   0, 
-      0,   0, 128,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-     10,   0,   0,   0,  70,  14, 
-     16,   0,  10,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,  10,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   2,   0,   0,   0,   4, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     10,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      0,   0,   0,   0,   6,   4, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   8, 
-      0,   0,   0,  16,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0, 166,   2,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-     86,   9,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,  16,   0,   0,   0, 
-     32,   0,   0,   0,  64,   0, 
-      0,   0,   0,   1,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   2, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,   0,   0,   0,  16, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,  32, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   2,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-      0,  32,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,  64,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,  16,   0,   0, 
-      0,  32,   0,   0,   0,  64, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-     16,   0,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   2,   0,   0, 
-      0,   0,   0,  32,   2,   0, 
-      0,   0, 128,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      0,   0,   0,   0,  86,   9, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,   0,   0,   0,  16, 
-      0,   0,   0,   0,   0,  64, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,   6,   4,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  32, 
-      0,   0,   0,   0, 128,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   1, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-     86,   9,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  27,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   8,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      4,   0,   0,   0,   6,   4, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      8,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      4,   0,   0,   0,   6,   4, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,   0,   0,   0,  16, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     10,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  25,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   2, 
-      0,   0,   0,   4,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      0,   0,   0,   0, 166,   2, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,  86,   9,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,   6,   4,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  64,   0, 
-      0,   0,   0,  16,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   6,   4,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,  32, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   2,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-      0,  32,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,  64,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,  16,   0,   0, 
-      0,  32,   0,   0,   0,  64, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-     16,   0,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   6,   4,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   0, 
-      4,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   1, 
-      0,   0,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   2, 
-      0,   0,   0,   0,   0,  32, 
-      2,   0,   0,   0, 128,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-     86,   9,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-     10,   0,   0,   0,  70,  14, 
-     16,   0,  10,   0,   0,   0, 
-      2,  64,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,   0,   0, 
-      0,  64,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,  10,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      0,   0,   0,   0,   6,   4, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  32,   0,   0,   0,   0, 
-    128,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     11,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,  11,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  11,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     11,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,  11,   0, 
-      0,   0,  70,  14,  16,   0, 
-     11,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     11,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  11,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-     11,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  11,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,  32,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,   0,   4,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   8,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,  16,  64,   0, 
-      0,   0,   0,  16,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      0,   0,   0,   0, 166,   2, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,  86,   9,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,   6,  12,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-     16,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-      0,   4,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   8, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,  32,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0, 128, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  18,   0,   0,   1, 
-     32,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   2,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-     64,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   2,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,   0,  32, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,   0,   0,   4,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,  16,   0,   0,   0,  32, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,   0,   0,  16,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   4,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,   0,   0, 128,   0, 
-      0,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   1,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,   2,   0,   0, 
-      0,   0,   0,  32,   2,   0, 
-      0,   0, 128,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-      6,   4,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  32,   0,   0, 
-      0,   0, 128,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   6,   4,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0, 128, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   1,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      8,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,  32,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   2, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,  16, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0, 166,   2,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   4,   0, 
-      0,   0,   6,   8,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  64,   4,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-      6,  12,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   8,   0, 
-      0,   0,  16,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  64,   0,   0,   0, 
-      0,   8,   0,   0,   0,  16, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   4,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,  32,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0, 128, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  18,   0,   0,   1, 
-     32,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   2,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-     64,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   2,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,   0,  32, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-    166,   6,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0,   0,   0,   1, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,   0,   0,   4,   0, 
-      0,   0,   8,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   9,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-      0,  32,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      4,   0,   0,   0,   6,   8, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  64,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-     86,   1,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  20,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     21,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   4,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   0,  16,   0,   0,   0, 
-     32,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   2, 
-      0,   0,   0,   0,   0,  32, 
-      2,   0,   0,   0, 128,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,  86,   9,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   6,   4,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  16, 
-      0,   0,   0,   0,   0,  64, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   4,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  32,   0,   0, 
-      0,   0, 128,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  19,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   6,   0, 
-      0,   0,   6,   4,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   8,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      6,   0,   0,   0,   6,   4, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,  64,   0, 
-      0,   0,   0,  16,  64,   0, 
-      0,   0,   0,  16,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  25,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-      4,   0,   0,   0,   8,   0, 
-      0,   0,  16,   0,   0,   0, 
-     32,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   9,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,  32, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   2,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-      0,   0,   1,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      0,   0,   0,   0,   6,   4, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,  32,   0,   0, 
-      0,   0, 128,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      0,   0,   0,   0, 166,   6, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,   0,   1,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     10,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  27,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,   0,   0,   0,   4, 
-      0,   0,   0,   8,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,  16,   0,   0,   0,  32, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  16,   0,   0,   0, 
-     32,   0,   0,   0,  64,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      0,   0,   0,   0,   6,   4, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   2,   0,   0, 
-      0,   0,   0,  32,   2,   0, 
-      0,   0, 128,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-     86,   9,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  16,   0,   0, 
-      0,   0,   0,  64,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      4,   0,   0,   0,   6,   4, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  32,   0,   0,   0,   0, 
-    128,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   6,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   8,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   6,   0,   0,   0, 
-      6,   4,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,  64,   0,   0,   0, 
-      0,  16,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   4,   0, 
-      0,   0,   8,   0,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,  64,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,   0,   4,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-      6,   4,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,  32, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   2,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,  64,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-      0,   0,   1,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  32,   0,   0, 
-      0,   0,   8,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0, 166,   6,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   4,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   9,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  19,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  20,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,   0,   0,   8,   0, 
-      0,   0,  16,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     21,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-     32,   0,   0,   0,  64,   0, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,  16, 
-      0,   0,   0,  32,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      6,   0,   0,   0,  86,   1, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   1,   0,   0,   0,   0, 
-     16,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  16,   0,   0,   0, 
-     32,   0,   0,   0,  64,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0, 128,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   2,   0,   0,   0,   0, 
-      0,  32,   2,   0,   0,   0, 
-    128,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-     86,   9,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   8, 
-      0,   0,   0,  16,   0,   0, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  32,   0,   0, 
-      0,   0, 128,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   2,   0,   0,   0,   4, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 194,   0, 
-     16,   0,   4,   0,   0,   0, 
-      6,   4,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     21,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-     10,   0,   0,   0,  70,  14, 
-     16,   0,  10,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-     32,   0,   0,   0,  64,   0, 
-      0,   0,   0,  16,  64,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,  10,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   8,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  98,   0,  16,   0, 
-      0,   0,   0,   0, 166,   8, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   4,   0, 
-      0,   0,   8,   0,   0,   0, 
-     16,   0,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   2,   0,   0,   0,   4, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   8, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,  16,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,  32,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0, 128, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  18,   0,   0,   1, 
-     32,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   2,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-     64,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   2,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,   0,   0, 
-      1,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      2,   0,   0,   0,  86,   1, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  32,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   1,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0, 166,   6,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,  14,  16,   0,  10,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-    128,   0,   0,   0,   0,   1, 
-      0,   4,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,  10,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  19,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  20,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,   0,   0,   8,   0, 
-      0,   0,  16,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     21,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-     32,   0,   0,   0,  64,   0, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,  16, 
-      0,   0,   0,  32,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,  64,   0,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    128,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   2, 
-      0,   0,   0,   0,   0,  32, 
-      2,   0,   0,   0, 128,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      0,   0,   0,   0,  86,   9, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,   0,   0, 
-      0,  64,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  32,   0,   0,   0,   0, 
-    128,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   4,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   8,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      4,   0,   0,   0,   6,   4, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-     16,   0,   0,   0,  32,   0, 
-      0,   0,  64,   0,  64,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-      0,   4,   0,   0,   0,   8, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     10,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,  16,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     98,   0,  16,   0,   0,   0, 
-      0,   0, 166,   8,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   4,   0,   0,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,   0,   4,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   8,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,  16,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,  32,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  25,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-     32,   0,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   2, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,  64,   0, 
-      0,   0, 128,   0,   0,   0, 
-      0,   1,   0,   0,   0,   2, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   4,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,   0,   0,   4,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-      1,   0,   0,  10, 210,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   9,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   8,   0,   0,   0,   0, 
-      0,   0,   0,  32,   0,   0, 
-      0,   0, 128,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-      4,   0,   0,   0,   6,   4, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  16,   0,   0,   0,   0, 
-      8,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  82,   0,  16,   0, 
-      2,   0,   0,   0, 166,   9, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    194,   0,  16,   0,   6,   0, 
-      0,   0,  86,   9,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0,   0,  32,   0, 
-      0,   0,  64,   0,   0,   0, 
-      0,   1,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  27,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     16,   0,   0,   0,   0,   4, 
-      0,   0,   0,   8,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,  16,   0,   0, 
-      0,  32,   0,   0,   0,  64, 
-     16,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  42,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     42,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,   0,   0, 128,   0, 
-      0,   0,   0,   1,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   2,   0,   0, 
-      0,   0,   0,  32,   2,   0, 
-      0,   0, 128,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      0,   0,   0,   0,  86,   9, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   4,   0,   0, 
-      0,   8,   0,   0,   0,  16, 
-      0,   0,   0,   0,   0,  64, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,   6,   4,  16,   0, 
-      1,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  32, 
-      0,   0,   0,   0, 128,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0, 128, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   9,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     42,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7,  34,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   1, 
-      0,   0,   0,   2,   0,   0, 
-      0,   4,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-      1,   0,   0,  10,  50,   0, 
-     16,   0,   1,   0,   0,   0, 
-     70,   0,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,   6,   4,  16,   0, 
-      1,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   8,   0,   0,   0,  16, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 194,   0,  16,   0, 
-      0,   0,   0,   0, 166,   2, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,  86,   9,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      1,   0,   0,   0,  70,  14, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-     64,   0,   0,   0,   0,   1, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  42,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     42,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  42,   0, 
-      0,   7,  34,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   1,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   2,   0,   0,   0,   4, 
-      0,   0,   0,   8,   0,   0, 
-      0,  16,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,  32,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      1,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0,   0,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   8,  82,   0,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 168,   0,   0,   9, 
-    242, 224,  17,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-    134,   7,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-     62,   0,   0,   1
-};
diff --git a/thirdparty/directxtex/Shaders/Compiled/BC6HEncode_TryModeG10CS.inc b/thirdparty/directxtex/Shaders/Compiled/BC6HEncode_TryModeG10CS.inc
deleted file mode 100644
index 33f5ecc..0000000
--- a/thirdparty/directxtex/Shaders/Compiled/BC6HEncode_TryModeG10CS.inc
+++ /dev/null
@@ -1,3366 +0,0 @@
-#if 0
-//
-// Generated by Microsoft (R) D3D Shader Disassembler
-//
-//
-// Input signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Input
-//
-// Output signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Output
-cs_4_0
-dcl_globalFlags refactoringAllowed
-dcl_immediateConstantBuffer { { 10, 5, 5, 5},
-                              { 7, 6, 6, 6},
-                              { 11, 5, 4, 4},
-                              { 11, 4, 5, 4},
-                              { 11, 4, 4, 5},
-                              { 9, 5, 5, 5},
-                              { 8, 6, 5, 5},
-                              { 8, 5, 6, 5},
-                              { 8, 5, 5, 6},
-                              { 6, 6, 6, 6},
-                              { 10, 10, 10, 10},
-                              { 11, 9, 9, 9},
-                              { 12, 8, 8, 8},
-                              { 16, 4, 4, 4},
-                              { -1, 0, 0, 0},
-                              { -1, 0, 4, 0},
-                              { -1, 0, 9, 0},
-                              { -1, 1, 13, 0},
-                              { -1, 1, 17, 0},
-                              { -1, 1, 21, 0},
-                              { -1, 1, 26, 0},
-                              { -1, 2, 30, 0},
-                              { -1, 2, 34, 0},
-                              { 0, 2, 38, 0},
-                              { 0, 2, 43, 0},
-                              { -1, 2, 47, 0},
-                              { -1, 3, 51, 0},
-                              { -1, 3, 55, 0},
-                              { 0, 3, 60, 0},
-                              { 0, 3, 64, 0},
-                              { 0, 4, 0, 0},
-                              { 0, 4, 0, 0},
-                              { 0, 4, 0, 0},
-                              { 0, 4, 0, 0},
-                              { 0, 5, 0, 0},
-                              { 0, 5, 0, 0},
-                              { 0, 5, 0, 0},
-                              { 0, 5, 0, 0},
-                              { 0, 6, 0, 0},
-                              { 0, 6, 0, 0},
-                              { 0, 6, 0, 0},
-                              { 0, 6, 0, 0},
-                              { 0, 6, 0, 0},
-                              { 0, 7, 0, 0},
-                              { 0, 7, 0, 0},
-                              { 0, 7, 0, 0},
-                              { 0, 7, 0, 0},
-                              { 0, 8, 0, 0},
-                              { 0, 8, 0, 0},
-                              { 0, 8, 0, 0},
-                              { 0, 8, 0, 0},
-                              { 0, 9, 0, 0},
-                              { 0, 9, 0, 0},
-                              { 0, 9, 0, 0},
-                              { 0, 9, 0, 0},
-                              { 0, 10, 0, 0},
-                              { 0, 10, 0, 0},
-                              { 0, 10, 0, 0},
-                              { 0, 10, 0, 0},
-                              { 0, 10, 0, 0},
-                              { 0, 11, 0, 0},
-                              { 0, 11, 0, 0},
-                              { 0, 11, 0, 0},
-                              { 0, 11, 0, 0},
-                              { 0, 12, 0, 0},
-                              { 0, 12, 0, 0},
-                              { 0, 12, 0, 0},
-                              { 0, 12, 0, 0},
-                              { 0, 13, 0, 0},
-                              { 0, 13, 0, 0},
-                              { 0, 13, 0, 0},
-                              { 0, 13, 0, 0},
-                              { 0, 14, 0, 0},
-                              { 0, 14, 0, 0},
-                              { 0, 14, 0, 0},
-                              { 0, 14, 0, 0},
-                              { 0, 15, 0, 0},
-                              { 0, 15, 0, 0} }
-dcl_constantbuffer CB0[2], immediateIndexed
-dcl_resource_texture2d (float,float,float,float) t0
-dcl_uav_structured u0, 16
-dcl_input vThreadIDInGroupFlattened
-dcl_input vThreadGroupID.x
-dcl_temps 19
-dcl_tgsm_structured g0, 84, 64
-dcl_thread_group 64, 1, 1
-ushr r0.x, vThreadIDInGroupFlattened.x, l(4)
-ishl r0.y, vThreadGroupID.x, l(2)
-iadd r0.y, r0.y, cb0[1].x
-iadd r0.x, r0.x, r0.y
-and r0.y, vThreadIDInGroupFlattened.x, l(48)
-iadd r0.z, -r0.y, vThreadIDInGroupFlattened.x
-ult r1.xyzw, r0.zzzz, l(16, 8, 4, 2)
-if_nz r1.x
-  udiv r0.w, null, r0.x, cb0[0].y
-  imad r1.x, -r0.w, cb0[0].y, r0.x
-  ishl r1.x, r1.x, l(2)
-  ishl r0.w, r0.w, l(2)
-  and r2.x, r0.z, l(3)
-  iadd r2.x, r1.x, r2.x
-  ushr r1.x, r0.z, l(2)
-  iadd r2.y, r0.w, r1.x
-  mov r2.zw, l(0,0,0,0)
-  ld r2.xyzw, r2.xyzw, t0.xyzw
-  ushr r3.xyz, r2.xyzx, l(16)
-  and r3.xyz, r3.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  and r4.xyzw, r2.xxyy, l(0x7fffffff, 0x007fffff, 0x7fffffff, 0x007fffff)
-  ult r2.xy, l(0x47ffefff, 0x47ffefff, 0, 0), r4.xzxx
-  ult r5.xy, r4.xzxx, l(0x38800000, 0x38800000, 0, 0)
-  ushr r5.zw, r4.xxxz, l(23)
-  iadd r5.zw, -r5.zzzw, l(0, 0, 113, 113)
-  iadd r4.yw, r4.yyyw, l(0, 0x00800000, 0, 0x00800000)
-  ushr r6.x, r4.y, r5.z
-  ushr r6.y, r4.w, r5.w
-  iadd r4.xy, r4.xzxx, l(0xc8000000, 0xc8000000, 0, 0)
-  movc r4.xy, r5.xyxx, r6.xyxx, r4.xyxx
-  iadd r4.zw, r4.xxxy, l(0, 0, 4095, 4095)
-  ushr r4.xy, r4.xyxx, l(13)
-  and r4.xy, r4.xyxx, l(1, 1, 0, 0)
-  iadd r4.xy, r4.xyxx, r4.zwzz
-  ushr r4.xy, r4.xyxx, l(13)
-  and r4.xy, r4.xyxx, l(0x00007fff, 0x00007fff, 0, 0)
-  movc r2.xy, r2.xyxx, l(0x00007fff,0x00007fff,0,0), r4.xyxx
-  iadd r4.xy, r3.xyxx, r2.xyxx
-  and r2.xy, r2.zzzz, l(0x7fffffff, 0x007fffff, 0, 0)
-  ult r0.w, l(0x47ffefff), r2.x
-  ult r1.x, r2.x, l(0x38800000)
-  ushr r2.z, r2.x, l(23)
-  iadd r2.z, -r2.z, l(113)
-  iadd r2.y, r2.y, l(0x00800000)
-  ushr r2.y, r2.y, r2.z
-  iadd r2.x, r2.x, l(0xc8000000)
-  movc r1.x, r1.x, r2.y, r2.x
-  iadd r2.x, r1.x, l(4095)
-  ushr r1.x, r1.x, l(13)
-  and r1.x, r1.x, l(1)
-  iadd r1.x, r1.x, r2.x
-  ushr r1.x, r1.x, l(13)
-  and r1.x, r1.x, l(0x00007fff)
-  movc r0.w, r0.w, l(0x00007fff), r1.x
-  iadd r4.z, r3.z, r0.w
-  and r2.xyzw, r4.xxyy, l(1023, 0x00007c00, 1023, 0x00007c00)
-  if_nz r2.y
-    ushr r0.w, r4.x, l(10)
-    and r0.w, r0.w, l(31)
-  else 
-    if_nz r2.x
-      ishl r1.x, r2.x, l(1)
-      mov r2.y, r1.x
-      mov r0.w, l(0)
-      loop 
-        and r3.x, r2.y, l(1024)
-        breakc_nz r3.x
-        iadd r0.w, r0.w, l(-1)
-        ishl r2.y, r2.y, l(1)
-      endloop 
-      and r2.x, r2.y, l(1022)
-    else 
-      mov r2.x, l(0)
-      mov r0.w, l(-112)
-    endif 
-  endif 
-  ishl r3.xyz, r4.xyzx, l(16)
-  and r3.xyz, r3.xyzx, l(0x80000000, 0x80000000, 0x80000000, 0)
-  ishl r0.w, r0.w, l(23)
-  iadd r0.w, r0.w, l(0x38000000)
-  or r0.w, r0.w, r3.x
-  ishl r1.x, r2.x, l(13)
-  iadd r5.x, r0.w, r1.x
-  if_nz r2.w
-    ushr r0.w, r4.y, l(10)
-    and r0.w, r0.w, l(31)
-  else 
-    if_nz r2.z
-      ishl r1.x, r2.z, l(1)
-      mov r2.x, r1.x
-      mov r0.w, l(0)
-      loop 
-        and r2.y, r2.x, l(1024)
-        breakc_nz r2.y
-        iadd r0.w, r0.w, l(-1)
-        ishl r2.x, r2.x, l(1)
-      endloop 
-      and r2.z, r2.x, l(1022)
-    else 
-      mov r2.z, l(0)
-      mov r0.w, l(-112)
-    endif 
-  endif 
-  ishl r0.w, r0.w, l(23)
-  iadd r0.w, r0.w, l(0x38000000)
-  or r0.w, r0.w, r3.y
-  ishl r1.x, r2.z, l(13)
-  iadd r5.y, r0.w, r1.x
-  and r2.xy, r4.zzzz, l(1023, 0x00007c00, 0, 0)
-  if_nz r2.y
-    ushr r0.w, r4.z, l(10)
-    and r0.w, r0.w, l(31)
-  else 
-    if_nz r2.x
-      ishl r1.x, r2.x, l(1)
-      mov r2.y, r1.x
-      mov r0.w, l(0)
-      loop 
-        and r2.z, r2.y, l(1024)
-        breakc_nz r2.z
-        iadd r0.w, r0.w, l(-1)
-        ishl r2.y, r2.y, l(1)
-      endloop 
-      and r2.x, r2.y, l(1022)
-    else 
-      mov r2.x, l(0)
-      mov r0.w, l(-112)
-    endif 
-  endif 
-  ishl r0.w, r0.w, l(23)
-  iadd r0.w, r0.w, l(0x38000000)
-  or r0.w, r0.w, r3.z
-  ishl r1.x, r2.x, l(13)
-  iadd r5.z, r0.w, r1.x
-  store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(24), r5.xyzx
-  dp3 r2.w, r5.xyzx, l(0.212600, 0.715200, 0.072200, 0.000000)
-  ieq r0.w, cb0[0].z, l(95)
-  ishl r3.xyz, r4.xyzx, l(6)
-  udiv r3.xyz, null, r3.xyzx, l(31, 31, 31, 0)
-  ult r5.xyz, r4.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  ieq r6.xyz, r4.xyzx, l(0x00007bff, 0x00007bff, 0x00007bff, 0)
-  ishl r4.xyz, r4.xyzx, l(5)
-  udiv r7.xyz, null, r4.xyzx, l(31, 31, 31, 0)
-  movc r7.xyz, r6.xyzx, l(0x00007fff,0x00007fff,0x00007fff,0), r7.xyzx
-  and r4.xyz, r4.xyzx, l(0x000fffe0, 0x000fffe0, 0x000fffe0, 0)
-  udiv r4.xyz, null, r4.xyzx, l(31, 31, 31, 0)
-  ineg r4.xyz, r4.xyzx
-  movc r4.xyz, r6.xyzx, l(0xffff8001,0xffff8001,0xffff8001,0), r4.xyzx
-  movc r4.xyz, r5.xyzx, r7.xyzx, r4.xyzx
-  movc r2.xyz, r0.wwww, r3.xyzx, r4.xyzx
-  store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(12), r2.xyzx
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r2.xyzx
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(68), r2.yzww
-endif 
-sync_g_t
-if_nz r1.y
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(76), g0.xxxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r3.x, r0.w, l(76), g0.xxxx
-  lt r1.x, r3.x, r2.x
-  if_nz r1.x
-    ld_structured r2.xyz, r0.w, l(52), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(52), r2.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(76), r3.x
-  endif 
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(80), g0.xxxx
-  ld_structured r3.x, r0.w, l(80), g0.xxxx
-  lt r1.x, r2.x, r3.x
-  if_nz r1.x
-    ld_structured r2.xyz, r0.w, l(64), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(64), r2.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(80), r3.x
-  endif 
-endif 
-sync_g_t
-if_nz r1.z
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(76), g0.xxxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r3.x, r0.w, l(76), g0.xxxx
-  lt r1.x, r3.x, r2.x
-  if_nz r1.x
-    ld_structured r2.xyz, r0.w, l(52), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(52), r2.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(76), r3.x
-  endif 
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(80), g0.xxxx
-  ld_structured r3.x, r0.w, l(80), g0.xxxx
-  lt r1.x, r2.x, r3.x
-  if_nz r1.x
-    ld_structured r2.xyz, r0.w, l(64), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(64), r2.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(80), r3.x
-  endif 
-endif 
-sync_g_t
-if_nz r1.w
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(76), g0.xxxx
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r3.x, r0.w, l(76), g0.xxxx
-  lt r1.x, r3.x, r2.x
-  if_nz r1.x
-    ld_structured r2.xyz, r0.w, l(52), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(52), r2.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(76), r3.x
-  endif 
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(80), g0.xxxx
-  ld_structured r3.x, r0.w, l(80), g0.xxxx
-  lt r1.x, r2.x, r3.x
-  if_nz r1.x
-    ld_structured r2.xyz, r0.w, l(64), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(64), r2.xyzx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(80), r3.x
-  endif 
-endif 
-sync_g_t
-ult r0.w, r0.z, l(1)
-if_nz r0.w
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(76), g0.xxxx
-  iadd r1.x, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r3.x, r1.x, l(76), g0.xxxx
-  lt r1.y, r3.x, r2.x
-  if_nz r1.y
-    ld_structured r2.xyz, r1.x, l(52), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(52), r2.xyzx
-  endif 
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(80), g0.xxxx
-  ld_structured r3.x, r1.x, l(80), g0.xxxx
-  lt r1.y, r2.x, r3.x
-  if_nz r1.y
-    ld_structured r2.xyz, r1.x, l(64), g0.xyzx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(64), r2.xyzx
-  endif 
-endif 
-sync_g_t
-if_z r0.z
-  ld_structured r2.xyz, r0.y, l(52), g0.xyzx
-  ld_structured r3.xyz, r0.y, l(64), g0.xyzx
-  iadd r4.xyz, -r2.xyzx, r3.xyzx
-  itof r4.xyz, r4.xyzx
-  dp3 r1.x, r4.xyzx, r4.xyzx
-  ld_structured r5.xyz, r0.y, l(12), g0.xyzx
-  iadd r5.xyz, -r2.xyzx, r5.xyzx
-  itof r5.xyz, r5.xyzx
-  dp3 r1.y, r4.xyzx, r5.xyzx
-  lt r2.w, l(0.000000), r1.x
-  ge r4.x, r1.y, l(0.000000)
-  and r2.w, r2.w, r4.x
-  mul r1.y, r1.y, l(63.499989)
-  div r1.x, r1.y, r1.x
-  ftou r1.x, r1.x
-  ult r1.x, l(32), r1.x
-  and r1.x, r1.x, r2.w
-  if_nz r1.x
-    mov r3.w, r2.x
-    store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r3.xyzw
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(68), r2.yzyy
-  endif 
-endif 
-sync_g_t
-if_nz r1.z
-  ld_structured r2.xyz, r0.y, l(52), g0.xyzx
-  ld_structured r3.xyz, r0.y, l(64), g0.xyzx
-  ineg r1.xyz, r2.xyzx
-  iadd r4.xyz, r1.xyzx, r3.xyzx
-  itof r4.xyz, r4.xyzx
-  dp3 r2.w, r4.xyzx, r4.xyzx
-  iadd r5.yz, r0.zzzz, l(0, 10, 11, 0)
-  ieq r6.xy, cb0[0].zzzz, l(95, 96, 0, 0)
-  if_nz r6.x
-    ige r0.z, icb[r5.y + 0].x, l(15)
-    and r0.z, r0.z, l(1)
-    movc r7.xyz, r2.xyzx, l(0,0,0,0), l(1,1,1,0)
-    movc r8.xyz, r3.xyzx, l(0,0,0,0), l(1,1,1,0)
-    or r7.xyz, r0.zzzz, r7.xyzx
-    or r8.xyz, r0.zzzz, r8.xyzx
-    ieq r9.xyz, r2.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-    ieq r10.xyz, r3.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-    ishl r0.z, l(1), icb[r5.y + 0].x
-    iadd r0.z, r0.z, l(-1)
-    ishl r11.xyz, r2.xyzx, icb[r5.y + 0].x
-    ishl r12.xyz, r3.xyzx, icb[r5.y + 0].x
-    ishr r11.xyz, r11.xyzx, l(16)
-    ishr r12.xyz, r12.xyzx, l(16)
-    movc r9.xyz, r9.xyzx, r0.zzzz, r11.xyzx
-    movc r10.xyz, r10.xyzx, r0.zzzz, r12.xyzx
-    movc r7.xyz, r7.xyzx, r2.xyzx, r9.xyzx
-    movc r8.xyz, r8.xyzx, r3.xyzx, r10.xyzx
-  else 
-    ige r0.z, icb[r5.y + 0].x, l(16)
-    and r0.z, r0.z, l(1)
-    movc r9.xyz, r2.xyzx, l(0,0,0,0), l(1,1,1,0)
-    movc r10.xyz, r3.xyzx, l(0,0,0,0), l(1,1,1,0)
-    or r9.xyz, r0.zzzz, r9.xyzx
-    or r10.xyz, r0.zzzz, r10.xyzx
-    ige r11.xyz, r2.xyzx, l(0, 0, 0, 0)
-    ige r12.xyz, r3.xyzx, l(0, 0, 0, 0)
-    ieq r13.xyz, r2.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ieq r14.xyz, r3.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    iadd r0.z, l(-1), icb[r5.y + 0].x
-    ishl r3.w, l(1), r0.z
-    iadd r4.w, r3.w, l(-1)
-    ishl r15.xyz, r2.xyzx, r0.z
-    ishl r16.xyz, r3.xyzx, r0.z
-    ishr r15.xyz, r15.xyzx, l(15)
-    ishr r16.xyz, r16.xyzx, l(15)
-    movc r13.xyz, r13.xyzx, r4.wwww, r15.xyzx
-    movc r14.xyz, r14.xyzx, r4.wwww, r16.xyzx
-    ineg r15.xyz, r3.xyzx
-    ieq r16.xyz, r1.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ieq r17.xyz, r15.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    iadd r3.w, -r3.w, l(1)
-    ishl r18.xyz, r1.xyzx, r0.z
-    ishl r15.xyz, r15.xyzx, r0.z
-    ishr r18.xyz, r18.xyzx, l(15)
-    ishr r15.xyz, r15.xyzx, l(15)
-    ineg r18.xyz, r18.xyzx
-    ineg r15.xyz, r15.xyzx
-    movc r16.xyz, r16.xyzx, r3.wwww, r18.xyzx
-    movc r15.xyz, r17.xyzx, r3.wwww, r15.xyzx
-    movc r11.xyz, r11.xyzx, r13.xyzx, r16.xyzx
-    movc r12.xyz, r12.xyzx, r14.xyzx, r15.xyzx
-    movc r7.xyz, r9.xyzx, r2.xyzx, r11.xyzx
-    movc r8.xyz, r10.xyzx, r3.xyzx, r12.xyzx
-  endif 
-  iadd r2.xyz, -r7.xyzx, r8.xyzx
-  movc r2.xyz, icb[r5.y + 14].xxxx, r2.xyzx, r8.xyzx
-  ige r3.xyz, r2.xyzx, l(0, 0, 0, 0)
-  iadd r8.xyzw, l(-1, -1, -1, -1), icb[r5.y + 0].xyzw
-  ishl r9.x, l(1), r8.x
-  ishl r9.y, l(1), r8.y
-  ishl r9.z, l(1), r8.z
-  ishl r9.w, l(1), r8.w
-  ige r8.yzw, r2.xxyz, r9.yyzw
-  ineg r10.xyz, r2.xyzx
-  ilt r10.xyz, r9.yzwy, r10.xyzx
-  movc r11.xyz, r3.xyzx, r8.yzwy, r10.xyzx
-  or r0.z, r11.y, r11.x
-  or r11.x, r11.z, r0.z
-  ishl r12.x, l(1), icb[r5.y + 0].x
-  ishl r12.y, l(1), icb[r5.y + 0].y
-  ishl r12.z, l(1), icb[r5.y + 0].z
-  ishl r12.w, l(1), icb[r5.y + 0].w
-  iadd r12.xyzw, r12.xyzw, l(-1, -1, -1, -1)
-  and r7.xyz, r7.xyzx, r12.xxxx
-  iadd r13.xyzw, r9.yzwx, l(-1, -1, -1, -1)
-  movc r8.yzw, r8.yyzw, r13.xxyz, r2.xxyz
-  and r12.yzw, r2.xxyz, r12.yyzw
-  movc r10.xyz, r10.xyzx, r9.yzwy, r12.yzwy
-  movc r11.yzw, r3.xxyz, r8.yyzw, r10.xxyz
-  and r3.yzw, r2.xxyz, r12.xxxx
-  mov r3.x, l(0)
-  movc r3.xyzw, icb[r5.y + 14].xxxx, r11.xyzw, r3.xyzw
-  and r2.xyz, r9.xxxx, r7.xyzx
-  and r8.yzw, r7.xxyz, r13.wwww
-  iadd r8.yzw, -r9.xxxx, r8.yyzw
-  movc r2.xyz, r2.xyzx, r8.yzwy, r7.xyzx
-  movc r2.xyz, r6.yyyy, r2.xyzx, r7.xyzx
-  or r0.z, r6.y, icb[r5.y + 14].x
-  and r6.yzw, r9.yyzw, r3.yyzw
-  and r7.xyz, r13.xyzx, r3.yzwy
-  iadd r7.xyz, -r9.yzwy, r7.xyzx
-  movc r6.yzw, r6.yyzw, r7.xxyz, r3.yyzw
-  movc r3.yzw, r0.zzzz, r6.yyzw, r3.yyzw
-  iadd r6.yzw, r2.xxyz, r3.yyzw
-  movc r3.yzw, icb[r5.y + 14].xxxx, r6.yyzw, r3.yyzw
-  ult r6.yz, icb[r5.y + 0].xxxx, l(0, 15, 16, 0)
-  ieq r7.xyz, r12.xxxx, r2.xyzx
-  ieq r8.yzw, r12.xxxx, r3.yyzw
-  ishl r9.xyz, r2.xyzx, l(16)
-  ishl r10.xyz, r3.yzwy, l(16)
-  iadd r9.xyz, r9.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  iadd r10.xyz, r10.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  ushr r9.xyz, r9.xyzx, icb[r5.y + 0].x
-  ushr r10.xyz, r10.xyzx, icb[r5.y + 0].x
-  movc r7.xyz, r7.xyzx, l(0x0000ffff,0x0000ffff,0x0000ffff,0), r9.xyzx
-  movc r8.yzw, r8.yyzw, l(0,0x0000ffff,0x0000ffff,0x0000ffff), r10.xxyz
-  movc r7.xyz, r2.xyzx, r7.xyzx, l(0,0,0,0)
-  movc r8.yzw, r3.yyzw, r8.yyzw, l(0,0,0,0)
-  movc r7.xyz, r6.yyyy, r7.xyzx, r2.xyzx
-  movc r8.yzw, r6.yyyy, r8.yyzw, r3.yyzw
-  ige r9.xyz, r2.xyzx, l(0, 0, 0, 0)
-  ige r10.xyz, r3.yzwy, l(0, 0, 0, 0)
-  imax r11.xyz, -r2.xyzx, r2.xyzx
-  imax r12.xyz, -r3.yzwy, r3.yzwy
-  ige r13.xyz, r11.xyzx, r13.wwww
-  ige r14.xyz, r12.xyzx, r13.wwww
-  ishl r15.xyz, r11.xyzx, l(15)
-  ishl r16.xyz, r12.xyzx, l(15)
-  iadd r15.xyz, r15.xyzx, l(0x00004000, 0x00004000, 0x00004000, 0)
-  iadd r16.xyz, r16.xyzx, l(0x00004000, 0x00004000, 0x00004000, 0)
-  ushr r15.xyz, r15.xyzx, r8.x
-  ushr r16.xyz, r16.xyzx, r8.x
-  movc r13.xyz, r13.xyzx, l(0x00007fff,0x00007fff,0x00007fff,0), r15.xyzx
-  movc r14.xyz, r14.xyzx, l(0x00007fff,0x00007fff,0x00007fff,0), r16.xyzx
-  movc r11.xyz, r11.xyzx, r13.xyzx, l(0,0,0,0)
-  movc r12.xyz, r12.xyzx, r14.xyzx, l(0,0,0,0)
-  ineg r13.xyz, r11.xyzx
-  ineg r14.xyz, r12.xyzx
-  movc r9.xyz, r9.xyzx, r11.xyzx, r13.xyzx
-  movc r10.xyz, r10.xyzx, r12.xyzx, r14.xyzx
-  movc r2.xyz, r6.zzzz, r9.xyzx, r2.xyzx
-  movc r3.yzw, r6.zzzz, r10.xxyz, r3.yyzw
-  movc r2.xyz, r6.xxxx, r7.xyzx, r2.xyzx
-  movc r3.yzw, r6.xxxx, r8.yyzw, r3.yyzw
-  ge r0.z, l(0.000000), r2.w
-  mov r4.w, l(0)
-  mov r5.y, l(0)
-  loop 
-    uge r5.w, r5.y, l(16)
-    breakc_nz r5.w
-    iadd r5.w, r0.y, r5.y
-    ld_structured r7.xyz, r5.w, l(12), g0.xyzx
-    iadd r6.yzw, r1.xxyz, r7.xxyz
-    itof r6.yzw, r6.yyzw
-    dp3 r6.y, r4.xyzx, r6.yzwy
-    ge r6.z, l(0.000000), r6.y
-    or r6.z, r0.z, r6.z
-    lt r6.w, r6.y, r2.w
-    mul r6.y, r6.y, l(63.499989)
-    div r6.y, r6.y, r2.w
-    ftou r6.y, r6.y
-    movc r6.y, r6.w, icb[r6.y + 14].y, l(15)
-    movc r6.y, r6.z, l(0), r6.y
-    iadd r6.z, l(64), -icb[r6.y + 14].z
-    imul null, r7.xyz, r3.yzwy, icb[r6.y + 14].zzzz
-    imad r6.yzw, r2.xxyz, r6.zzzz, r7.xxyz
-    iadd r6.yzw, r6.yyzw, l(0, 32, 32, 32)
-    ishr r6.yzw, r6.yyzw, l(6)
-    imul null, r7.xyz, r6.yzwy, l(31, 31, 31, 0)
-    ishr r8.xyz, r7.xyzx, l(6)
-    ilt r9.xyz, r6.yzwy, l(0, 0, 0, 0)
-    imul null, r6.yzw, r6.yyzw, l(0, -31, -31, -31)
-    ishr r6.yzw, r6.yyzw, l(5)
-    ineg r6.yzw, r6.yyzw
-    ishr r7.xyz, r7.xyzx, l(5)
-    movc r6.yzw, r9.xxyz, r6.yyzw, r7.xxyz
-    ilt r7.xyz, r6.yzwy, l(0, 0, 0, 0)
-    ineg r9.xyz, r6.yzwy
-    or r9.xyz, r9.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-    movc r6.yzw, r7.xxyz, r9.xxyz, r6.yyzw
-    movc r6.yzw, r6.xxxx, r8.xxyz, r6.yyzw
-    and r7.xyzw, r6.yyzz, l(1023, 0x00007c00, 1023, 0x00007c00)
-    if_nz r7.y
-      ushr r7.y, r6.y, l(10)
-      and r7.y, r7.y, l(31)
-    else 
-      if_nz r7.x
-        ishl r8.x, r7.x, l(1)
-        mov r8.y, r8.x
-        mov r7.y, l(0)
-        loop 
-          and r8.z, r8.y, l(1024)
-          breakc_nz r8.z
-          iadd r7.y, r7.y, l(-1)
-          ishl r8.y, r8.y, l(1)
-        endloop 
-        and r7.x, r8.y, l(1022)
-      else 
-        mov r7.xy, l(0,-112,0,0)
-      endif 
-    endif 
-    ishl r8.xzw, r6.yyzw, l(16)
-    and r8.xzw, r8.xxzw, l(0x80000000, 0, 0x80000000, 0x80000000)
-    ishl r6.y, r7.y, l(23)
-    iadd r6.y, r6.y, l(0x38000000)
-    or r6.y, r6.y, r8.x
-    ishl r7.x, r7.x, l(13)
-    iadd r9.x, r6.y, r7.x
-    if_nz r7.w
-      ushr r6.y, r6.z, l(10)
-      and r6.y, r6.y, l(31)
-    else 
-      if_nz r7.z
-        ishl r6.z, r7.z, l(1)
-        mov r7.x, r6.z
-        mov r6.y, l(0)
-        loop 
-          and r7.w, r7.x, l(1024)
-          breakc_nz r7.w
-          iadd r6.y, r6.y, l(-1)
-          ishl r7.x, r7.x, l(1)
-        endloop 
-        and r7.z, r7.x, l(1022)
-      else 
-        mov r7.z, l(0)
-        mov r6.y, l(-112)
-      endif 
-    endif 
-    ishl r6.z, r6.y, l(23)
-    iadd r6.z, r6.z, l(0x38000000)
-    or r6.z, r6.z, r8.z
-    ishl r7.z, r7.z, l(13)
-    iadd r9.y, r6.z, r7.z
-    and r7.zw, r6.wwww, l(0, 0, 1023, 0x00007c00)
-    if_nz r7.w
-      ushr r6.z, r6.w, l(10)
-      and r6.z, r6.z, l(31)
-    else 
-      if_nz r7.z
-        ishl r6.w, r7.z, l(1)
-        mov r7.w, r6.w
-        mov r6.z, l(0)
-        loop 
-          and r8.x, r7.w, l(1024)
-          breakc_nz r8.x
-          iadd r6.z, r6.z, l(-1)
-          ishl r7.w, r7.w, l(1)
-        endloop 
-        and r7.z, r7.w, l(1022)
-      else 
-        mov r7.z, l(0)
-        mov r6.z, l(-112)
-      endif 
-    endif 
-    ishl r6.w, r6.z, l(23)
-    iadd r6.w, r6.w, l(0x38000000)
-    or r6.w, r6.w, r8.w
-    ishl r7.z, r7.z, l(13)
-    iadd r9.z, r6.w, r7.z
-    ld_structured r10.xyz, r5.w, l(24), g0.xyzx
-    add r8.xzw, r9.xxyz, -r10.xxyz
-    dp3 r5.w, r8.xzwx, r8.xzwx
-    add r4.w, r4.w, r5.w
-    iadd r5.y, r5.y, l(1)
-  endloop 
-  movc r5.x, r3.x, l(100000002004087734272.000000), r4.w
-  store_structured g0.xy, vThreadIDInGroupFlattened.x, l(40), r5.xzxx
-endif 
-sync_g_t
-if_nz r1.w
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(40), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r2.yz, r0.y, l(40), g0.xxyx
-  lt r0.z, r2.y, r1.x
-  if_nz r0.z
-    ld_structured r2.x, r0.y, l(40), g0.xxxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(40), r2.xzxx
-  endif 
-endif 
-sync_g_t
-if_nz r0.w
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(40), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r2.yz, r0.y, l(40), g0.xxyx
-  lt r0.z, r2.y, r1.x
-  if_nz r0.z
-    ld_structured r2.x, r0.y, l(40), g0.xxxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(40), r2.xzxx
-  endif 
-  ld_structured r1.xy, vThreadIDInGroupFlattened.x, l(40), g0.xyxx
-  mov r1.zw, l(0,0,0,0)
-  store_structured u0.xyzw, r0.x, l(0), r1.xyzw
-endif 
-ret 
-// Approximately 0 instruction slots used
-#endif
-
-const BYTE BC6HEncode_TryModeG10CS[] =
-{
-     68,  88,  66,  67, 117, 150, 
-     86, 154,  76,  44,  62, 174, 
-    101,  82,  50,  59,  75, 244, 
-     89,  47,   1,   0,   0,   0, 
-     84,  63,   0,   0,   3,   0, 
-      0,   0,  44,   0,   0,   0, 
-     60,   0,   0,   0,  76,   0, 
-      0,   0,  73,  83,  71,  78, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     79,  83,  71,  78,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  83,  72, 
-     69,  88,   0,  63,   0,   0, 
-     64,   0,   5,   0, 192,  15, 
-      0,   0, 106,   8,   0,   1, 
-     53,  24,   0,   0,  58,   1, 
-      0,   0,  10,   0,   0,   0, 
-      5,   0,   0,   0,   5,   0, 
-      0,   0,   5,   0,   0,   0, 
-      7,   0,   0,   0,   6,   0, 
-      0,   0,   6,   0,   0,   0, 
-      6,   0,   0,   0,  11,   0, 
-      0,   0,   5,   0,   0,   0, 
-      4,   0,   0,   0,   4,   0, 
-      0,   0,  11,   0,   0,   0, 
-      4,   0,   0,   0,   5,   0, 
-      0,   0,   4,   0,   0,   0, 
-     11,   0,   0,   0,   4,   0, 
-      0,   0,   4,   0,   0,   0, 
-      5,   0,   0,   0,   9,   0, 
-      0,   0,   5,   0,   0,   0, 
-      5,   0,   0,   0,   5,   0, 
-      0,   0,   8,   0,   0,   0, 
-      6,   0,   0,   0,   5,   0, 
-      0,   0,   5,   0,   0,   0, 
-      8,   0,   0,   0,   5,   0, 
-      0,   0,   6,   0,   0,   0, 
-      5,   0,   0,   0,   8,   0, 
-      0,   0,   5,   0,   0,   0, 
-      5,   0,   0,   0,   6,   0, 
-      0,   0,   6,   0,   0,   0, 
-      6,   0,   0,   0,   6,   0, 
-      0,   0,   6,   0,   0,   0, 
-     10,   0,   0,   0,  10,   0, 
-      0,   0,  10,   0,   0,   0, 
-     10,   0,   0,   0,  11,   0, 
-      0,   0,   9,   0,   0,   0, 
-      9,   0,   0,   0,   9,   0, 
-      0,   0,  12,   0,   0,   0, 
-      8,   0,   0,   0,   8,   0, 
-      0,   0,   8,   0,   0,   0, 
-     16,   0,   0,   0,   4,   0, 
-      0,   0,   4,   0,   0,   0, 
-      4,   0,   0,   0, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255,   1,   0,   0,   0, 
-     13,   0,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-      1,   0,   0,   0,  17,   0, 
-      0,   0,   0,   0,   0,   0, 
-    255, 255, 255, 255,   1,   0, 
-      0,   0,  21,   0,   0,   0, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255,   1,   0,   0,   0, 
-     26,   0,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-      2,   0,   0,   0,  30,   0, 
-      0,   0,   0,   0,   0,   0, 
-    255, 255, 255, 255,   2,   0, 
-      0,   0,  34,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     38,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  43,   0, 
-      0,   0,   0,   0,   0,   0, 
-    255, 255, 255, 255,   2,   0, 
-      0,   0,  47,   0,   0,   0, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255,   3,   0,   0,   0, 
-     51,   0,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-      3,   0,   0,   0,  55,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  60,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     64,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      9,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   9,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      9,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     11,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  11,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  11,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     11,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  12,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     12,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  13,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  13,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  13,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  14,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  14,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  89,   0,   0,   4, 
-     70, 142,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     88,  24,   0,   4,   0, 112, 
-     16,   0,   0,   0,   0,   0, 
-     85,  85,   0,   0, 158,   0, 
-      0,   4,   0, 224,  17,   0, 
-      0,   0,   0,   0,  16,   0, 
-      0,   0,  95,   0,   0,   2, 
-      0,  64,   2,   0,  95,   0, 
-      0,   2,  18,  16,   2,   0, 
-    104,   0,   0,   2,  19,   0, 
-      0,   0, 160,   0,   0,   5, 
-      0, 240,  17,   0,   0,   0, 
-      0,   0,  84,   0,   0,   0, 
-     64,   0,   0,   0, 155,   0, 
-      0,   4,  64,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   6, 
-     18,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  16,   2,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  30,   0,   0,   8, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10, 128, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  48,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16, 128, 
-     65,   0,   0,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-     79,   0,   0,  10, 242,   0, 
-     16,   0,   1,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-     16,   0,   0,   0,   8,   0, 
-      0,   0,   4,   0,   0,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      1,   0,   0,   0,  78,   0, 
-      0,   9, 130,   0,  16,   0, 
-      0,   0,   0,   0,   0, 208, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,  26, 128, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  35,   0, 
-      0,  11,  18,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16, 128,  65,   0,   0,   0, 
-      0,   0,   0,   0,  26, 128, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     54,   0,   0,   8, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  45,   0,   0,   7, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  70, 126, 
-     16,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   4,   0, 
-      0,   0,   6,   5,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 127, 
-    255, 255, 127,   0, 255, 255, 
-    255, 127, 255, 255, 127,   0, 
-     79,   0,   0,  10,  50,   0, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0, 255, 239, 
-    255,  71, 255, 239, 255,  71, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 134,   0,  16,   0, 
-      4,   0,   0,   0,  79,   0, 
-      0,  10,  50,   0,  16,   0, 
-      5,   0,   0,   0, 134,   0, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-    128,  56,   0,   0, 128,  56, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    194,   0,  16,   0,   5,   0, 
-      0,   0,   6,   8,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     30,   0,   0,  11, 194,   0, 
-     16,   0,   5,   0,   0,   0, 
-    166,  14,  16, 128,  65,   0, 
-      0,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    113,   0,   0,   0, 113,   0, 
-      0,   0,  30,   0,   0,  10, 
-    162,   0,  16,   0,   4,   0, 
-      0,   0,  86,  13,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 128,   0,   0,   0, 
-      0,   0,   0,   0, 128,   0, 
-     85,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  85,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,  10, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0, 134,   0,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0, 200, 
-      0,   0,   0, 200,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,   9,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   0,  16,   0,   5,   0, 
-      0,   0,  70,   0,  16,   0, 
-      6,   0,   0,   0,  70,   0, 
-     16,   0,   4,   0,   0,   0, 
-     30,   0,   0,  10, 194,   0, 
-     16,   0,   4,   0,   0,   0, 
-      6,   4,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 255,  15,   0,   0, 
-    255,  15,   0,   0,  85,   0, 
-      0,   7,  50,   0,  16,   0, 
-      4,   0,   0,   0,  70,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,   1,   0,   0,  10, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  70,   0,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   0,  16,   0,   4,   0, 
-      0,   0, 230,  10,  16,   0, 
-      4,   0,   0,   0,  85,   0, 
-      0,   7,  50,   0,  16,   0, 
-      4,   0,   0,   0,  70,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,   1,   0,   0,  10, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  70,   0,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  12,  50,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,   0,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  70,   0, 
-     16,   0,   4,   0,   0,   0, 
-     30,   0,   0,   7,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   0,  16,   0,   3,   0, 
-      0,   0,  70,   0,  16,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,  10,  50,   0,  16,   0, 
-      2,   0,   0,   0, 166,  10, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 127, 255, 255, 127,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  79,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 239, 255,  71,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     79,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0, 128,  56,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  30,   0,   0,   8, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16, 128, 
-     65,   0,   0,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-    113,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-    128,   0,  85,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0, 200,  55,   0, 
-      0,   9,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0, 255,  15, 
-      0,   0,  85,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 127,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 255, 127, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,   6,   5,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0, 255,   3,   0,   0, 
-      0, 124,   0,   0, 255,   3, 
-      0,   0,   0, 124,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  18,   0,   0,   1, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  48,   0,   0,   1, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   4,   0,   0,   3,   0, 
-      4,   3,  10,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  41,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     22,   0,   0,   1,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0, 254,   3, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    144, 255, 255, 255,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,  56,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-     18,   0,   0,   1,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   4, 
-      0,   0,   3,   0,   4,   3, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0, 255, 255, 255, 255, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,   1,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0, 254,   3,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 144, 255, 
-    255, 255,  21,   0,   0,   1, 
-     21,   0,   0,   1,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,  56, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,   0,   0,  10,  50,   0, 
-     16,   0,   2,   0,   0,   0, 
-    166,  10,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255,   3,   0,   0,   0, 124, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-     18,   0,   0,   1,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   5, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   4, 
-      0,   0,   3,   0,   4,   3, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0, 255, 255, 255, 255, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,   1,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0, 254,   3,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 144, 255, 
-    255, 255,  21,   0,   0,   1, 
-     21,   0,   0,   1,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,  56, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  16,   0,   0,  10, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0, 208, 179,  89,  62, 
-     89,  23,  55,  63, 152, 221, 
-    147,  61,   0,   0,   0,   0, 
-     32,   0,   0,   8, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  95,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     78,   0,   0,  11, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-      0, 208,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-     31,   0,   0,   0,   0,   0, 
-      0,   0,  79,   0,   0,  10, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 123,   0,   0, 255, 123, 
-      0,   0, 255, 123,   0,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  78,   0,   0,  11, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,   0, 208,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,   0,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0, 224, 255, 
-     15,   0, 224, 255,  15,   0, 
-    224, 255,  15,   0,   0,   0, 
-      0,   0,  78,   0,   0,  11, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,   0, 208,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,   0,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-      0,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1, 128, 255, 255,   1, 128, 
-    255, 255,   1, 128, 255, 255, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0, 150,  15, 
-     16,   0,   2,   0,   0,   0, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  76,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  76,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  49,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 168,   0,   0,   8, 
-    114, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     80,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     80,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  76,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  76,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  49,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 168,   0,   0,   8, 
-    114, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     80,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     80,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  76,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  76,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  49,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 168,   0,   0,   8, 
-    114, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     80,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     80,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  79,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  76,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  76,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  49,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  80,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  49,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   0,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16, 128, 
-     65,   0,   0,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  43,   0, 
-      0,   5, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     16,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   8, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     43,   0,   0,   5, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  16,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     49,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  29,   0, 
-      0,   7,  18,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-     56,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  14,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  28,   0,   0,   5, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  79,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      3,   0,   0,   0, 168,   0, 
-      0,   8,  50, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0, 150,   5, 
-     16,   0,   2,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,   1,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     43,   0,   0,   5, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,  16,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     30,   0,   0,  10,  98,   0, 
-     16,   0,   5,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,  11,   0,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  11,  50,   0,  16,   0, 
-      6,   0,   0,   0, 166, 138, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,  95,   0,   0,   0, 
-     96,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     33,   0,   0,   8,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10, 144, 144,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-      8,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  32,   0,   0,  10, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   8,  66,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     10, 144, 144,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  41,   0, 
-      0,   8, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-     10, 144, 144,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     41,   0,   0,   8, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  10, 144, 144,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  18,   0, 
-      0,   1,  33,   0,   0,   8, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10, 144, 144,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  55,   0,   0,  15, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,  15, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0, 166,  10,  16,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  33,   0, 
-      0,  10, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  10, 144, 
-    144,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0, 255, 255, 255, 255, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     16,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-    246,  15,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-    246,  15,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16,   0,   1,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     17,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16, 128, 
-     65,   0,   0,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     18,   0,   0,   0,  70,   2, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  18,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0, 246,  15,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,  18,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0, 246,  15,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  16,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     21,   0,   0,   1,  30,   0, 
-      0,   8, 114,   0,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     55,   0,   0,  11, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6, 144, 208,   0,  14,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,  11, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255,  70, 158, 144,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     33,   0,   0,   7, 226,   0, 
-     16,   0,   8,   0,   0,   0, 
-      6,   9,  16,   0,   2,   0, 
-      0,   0,  86,  14,  16,   0, 
-      9,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-     34,   0,   0,   7, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-    150,   7,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-    150,   7,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  11,   0,   0,   0, 
-     10,   0,  16,   0,  11,   0, 
-      0,   0,  60,   0,   0,   7, 
-     18,   0,  16,   0,  11,   0, 
-      0,   0,  42,   0,  16,   0, 
-     11,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   8,  18,   0, 
-     16,   0,  12,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  10, 144, 144,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  41,   0,   0,   8, 
-     34,   0,  16,   0,  12,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  26, 144, 
-    144,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   8,  66,   0,  16,   0, 
-     12,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42, 144, 144,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     41,   0,   0,   8, 130,   0, 
-     16,   0,  12,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  58, 144, 144,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,  10, 
-    242,   0,  16,   0,  12,   0, 
-      0,   0,  70,  14,  16,   0, 
-     12,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-      1,   0,   0,   7, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,   6,   0,  16,   0, 
-     12,   0,   0,   0,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-     13,   0,   0,   0, 150,   3, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255,  55,   0,   0,   9, 
-    226,   0,  16,   0,   8,   0, 
-      0,   0,  86,  14,  16,   0, 
-      8,   0,   0,   0,   6,   9, 
-     16,   0,  13,   0,   0,   0, 
-      6,   9,  16,   0,   2,   0, 
-      0,   0,   1,   0,   0,   7, 
-    226,   0,  16,   0,  12,   0, 
-      0,   0,   6,   9,  16,   0, 
-      2,   0,   0,   0,  86,  14, 
-     16,   0,  12,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,  10,   0, 
-      0,   0, 150,   7,  16,   0, 
-      9,   0,   0,   0, 150,   7, 
-     16,   0,  12,   0,   0,   0, 
-     55,   0,   0,   9, 226,   0, 
-     16,   0,  11,   0,   0,   0, 
-      6,   9,  16,   0,   3,   0, 
-      0,   0,  86,  14,  16,   0, 
-      8,   0,   0,   0,   6,   9, 
-     16,   0,  10,   0,   0,   0, 
-      1,   0,   0,   7, 226,   0, 
-     16,   0,   3,   0,   0,   0, 
-      6,   9,  16,   0,   2,   0, 
-      0,   0,   6,   0,  16,   0, 
-     12,   0,   0,   0,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  11, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-      6, 144, 208,   0,  14,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,  11,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,   1,   0,   0,   7, 
-    114,   0,  16,   0,   2,   0, 
-      0,   0,   6,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      1,   0,   0,   7, 226,   0, 
-     16,   0,   8,   0,   0,   0, 
-      6,   9,  16,   0,   7,   0, 
-      0,   0, 246,  15,  16,   0, 
-     13,   0,   0,   0,  30,   0, 
-      0,   8, 226,   0,  16,   0, 
-      8,   0,   0,   0,   6,   0, 
-     16, 128,  65,   0,   0,   0, 
-      9,   0,   0,   0,  86,  14, 
-     16,   0,   8,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0, 150,   7,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-     86,   5,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     60,   0,   0,   9,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  10, 144, 208,   0, 
-     14,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,   0,   0,   7, 226,   0, 
-     16,   0,   6,   0,   0,   0, 
-     86,  14,  16,   0,   9,   0, 
-      0,   0,  86,  14,  16,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,   7, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-    150,   7,  16,   0,   3,   0, 
-      0,   0,  30,   0,   0,   8, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0, 150,   7,  16, 128, 
-     65,   0,   0,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      6,   0,   0,   0,  86,  14, 
-     16,   0,   6,   0,   0,   0, 
-      6,   9,  16,   0,   7,   0, 
-      0,   0,  86,  14,  16,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      3,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-     86,  14,  16,   0,   6,   0, 
-      0,   0,  86,  14,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7, 226,   0,  16,   0, 
-      6,   0,   0,   0,   6,   9, 
-     16,   0,   2,   0,   0,   0, 
-     86,  14,  16,   0,   3,   0, 
-      0,   0,  55,   0,   0,  11, 
-    226,   0,  16,   0,   3,   0, 
-      0,   0,   6, 144, 208,   0, 
-     14,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     86,  14,  16,   0,   6,   0, 
-      0,   0,  86,  14,  16,   0, 
-      3,   0,   0,   0,  79,   0, 
-      0,  11,  98,   0,  16,   0, 
-      6,   0,   0,   0,   6, 144, 
-    144,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,  16,   0, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,   7, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-      6,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,  32,   0, 
-      0,   7, 226,   0,  16,   0, 
-      8,   0,   0,   0,   6,   0, 
-     16,   0,  12,   0,   0,   0, 
-     86,  14,  16,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-    150,   7,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  30,   0, 
-      0,  10, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,  10, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   8, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  10, 144, 144,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  85,   0,   0,   8, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  10, 144, 
-    144,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  55,   0, 
-      0,  12, 226,   0,  16,   0, 
-      8,   0,   0,   0,  86,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0,   6,   9,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  12, 226,   0,  16,   0, 
-      8,   0,   0,   0,  86,  14, 
-     16,   0,   3,   0,   0,   0, 
-     86,  14,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      7,   0,   0,   0,  86,   5, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      8,   0,   0,   0,  86,   5, 
-     16,   0,   6,   0,   0,   0, 
-     86,  14,  16,   0,   8,   0, 
-      0,   0,  86,  14,  16,   0, 
-      3,   0,   0,   0,  33,   0, 
-      0,  10, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0, 150,   7,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     36,   0,   0,   8, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16, 128,  65,   0, 
-      0,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  36,   0,   0,   8, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0, 150,   7,  16, 128, 
-     65,   0,   0,   0,   3,   0, 
-      0,   0, 150,   7,  16,   0, 
-      3,   0,   0,   0,  33,   0, 
-      0,   7, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-    246,  15,  16,   0,  13,   0, 
-      0,   0,  33,   0,   0,   7, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0, 246,  15, 
-     16,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     16,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  30,   0,   0,  10, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,  64,   0,   0,   0,  64, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,  10, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,  16,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      2,   0,   0,   0, 166,  10, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      3,   0,   0,   0, 166,  10, 
-     16,   0,   6,   0,   0,   0, 
-      6,   9,  16,   0,  10,   0, 
-      0,   0,  86,  14,  16,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      2,   0,   0,   0,   6,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      3,   0,   0,   0,   6,   0, 
-     16,   0,   6,   0,   0,   0, 
-     86,  14,  16,   0,   8,   0, 
-      0,   0,  86,  14,  16,   0, 
-      3,   0,   0,   0,  29,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,  80,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   3,   0,   4,   3, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 226,   0, 
-     16,   0,   6,   0,   0,   0, 
-      6,   9,  16,   0,   1,   0, 
-      0,   0,   6,   9,  16,   0, 
-      7,   0,   0,   0,  43,   0, 
-      0,   5, 226,   0,  16,   0, 
-      6,   0,   0,   0,  86,  14, 
-     16,   0,   6,   0,   0,   0, 
-     16,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0, 150,   7,  16,   0, 
-      6,   0,   0,   0,  29,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-     49,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  56,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0, 253, 255, 
-    125,  66,  14,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     28,   0,   0,   5,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  55,   0,   0,  11, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  26, 144, 
-    208,   0,  14,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,  10,  66,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  64,   0,   0,   0, 
-     42, 144, 208, 128,  65,   0, 
-      0,   0,  14,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  38,   0,   0,  10, 
-      0, 208,   0,   0, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-    150,   7,  16,   0,   3,   0, 
-      0,   0, 166, 154, 208,   0, 
-     14,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     35,   0,   0,   9, 226,   0, 
-     16,   0,   6,   0,   0,   0, 
-      6,   9,  16,   0,   2,   0, 
-      0,   0, 166,  10,  16,   0, 
-      6,   0,   0,   0,   6,   9, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,  10, 226,   0, 
-     16,   0,   6,   0,   0,   0, 
-     86,  14,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,   0,  32,   0,   0,   0, 
-     32,   0,   0,   0,  42,   0, 
-      0,   7, 226,   0,  16,   0, 
-      6,   0,   0,   0,  86,  14, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  38,   0,   0,  11, 
-      0, 208,   0,   0, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-    150,   7,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,   0,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  34,   0,   0,  10, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0, 150,   7,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     38,   0,   0,  11,   0, 208, 
-      0,   0, 226,   0,  16,   0, 
-      6,   0,   0,   0,  86,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0, 225, 255, 255, 255, 
-    225, 255, 255, 255, 225, 255, 
-    255, 255,  42,   0,   0,   7, 
-    226,   0,  16,   0,   6,   0, 
-      0,   0,  86,  14,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     40,   0,   0,   5, 226,   0, 
-     16,   0,   6,   0,   0,   0, 
-     86,  14,  16,   0,   6,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 226,   0, 
-     16,   0,   6,   0,   0,   0, 
-      6,   9,  16,   0,   9,   0, 
-      0,   0,  86,  14,  16,   0, 
-      6,   0,   0,   0,   6,   9, 
-     16,   0,   7,   0,   0,   0, 
-     34,   0,   0,  10, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-    150,   7,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-      9,   0,   0,   0, 150,   7, 
-     16,   0,   6,   0,   0,   0, 
-     60,   0,   0,  10, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      6,   0,   0,   0,   6,   9, 
-     16,   0,   7,   0,   0,   0, 
-      6,   9,  16,   0,   9,   0, 
-      0,   0,  86,  14,  16,   0, 
-      6,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      6,   0,   0,   0,   6,   0, 
-     16,   0,   6,   0,   0,   0, 
-      6,   9,  16,   0,   8,   0, 
-      0,   0,  86,  14,  16,   0, 
-      6,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      7,   0,   0,   0,  86,  10, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0, 255,   3, 
-      0,   0,   0, 124,   0,   0, 
-    255,   3,   0,   0,   0, 124, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,  85,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,  18,   0, 
-      0,   1,  31,   0,   4,   3, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  54,   0,   0,   5, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  48,   0, 
-      0,   1,   1,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,   0,   4,   0,   0, 
-      3,   0,   4,   3,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-    254,   3,   0,   0,  18,   0, 
-      0,   1,  54,   0,   0,   8, 
-     50,   0,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0, 144, 255, 
-    255, 255,   0,   0,   0,   0, 
-      0,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     41,   0,   0,   7, 210,   0, 
-     16,   0,   8,   0,   0,   0, 
-     86,  14,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 210,   0,  16,   0, 
-      8,   0,   0,   0,   6,  14, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,  56,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      7,   0,   0,   0,  85,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-     18,   0,   0,   1,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   0,   4, 
-      0,   0,   3,   0,   4,   3, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0, 255, 255, 255, 255, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,   1,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0, 254,   3,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0, 144, 255, 
-    255, 255,  21,   0,   0,   1, 
-     21,   0,   0,   1,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,  56, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   7,   0,   0,   0, 
-    246,  15,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 255,   3,   0,   0, 
-      0, 124,   0,   0,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      7,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-     18,   0,   0,   1,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   0,   4, 
-      0,   0,   3,   0,   4,   3, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0, 255, 255, 255, 255, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,   1,   0,   0,   7, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0, 254,   3,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0, 144, 255, 
-    255, 255,  21,   0,   0,   1, 
-     21,   0,   0,   1,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,  56, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-      0,   0,   0,   8, 210,   0, 
-     16,   0,   8,   0,   0,   0, 
-      6,   9,  16,   0,   9,   0, 
-      0,   0,   6,   9,  16, 128, 
-     65,   0,   0,   0,  10,   0, 
-      0,   0,  16,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0, 134,   3,  16,   0, 
-      8,   0,   0,   0, 134,   3, 
-     16,   0,   8,   0,   0,   0, 
-      0,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-     55,   0,   0,   9,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-    236, 120, 173,  96,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-    134,   0,  16,   0,   5,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  98,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0,   6, 241, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  50, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0, 134,   0, 
-     16,   0,   2,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     98,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-      6, 241,  17,   0,   0,   0, 
-      0,   0,  49,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-    134,   0,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-    167,   0,   0,   8,  50,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  54,   0,   0,   8, 
-    194,   0,  16,   0,   1,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   9, 242, 224,  17,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70,  14,  16,   0, 
-      1,   0,   0,   0,  21,   0, 
-      0,   1,  62,   0,   0,   1
-};
diff --git a/thirdparty/directxtex/Shaders/Compiled/BC6HEncode_TryModeLE10CS.inc b/thirdparty/directxtex/Shaders/Compiled/BC6HEncode_TryModeLE10CS.inc
deleted file mode 100644
index 20f5695..0000000
--- a/thirdparty/directxtex/Shaders/Compiled/BC6HEncode_TryModeLE10CS.inc
+++ /dev/null
@@ -1,5061 +0,0 @@
-#if 0
-//
-// Generated by Microsoft (R) D3D Shader Disassembler
-//
-//
-// Input signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Input
-//
-// Output signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Output
-cs_4_0
-dcl_globalFlags refactoringAllowed
-dcl_immediateConstantBuffer { { 0x0000cccc, 15, -1, 0},
-                              { 0x00008888, 15, -1, 9},
-                              { 0x0000eeee, 15, -1, 18},
-                              { 0x0000ecc8, 15, -1, 27},
-                              { 0x0000c880, 15, -1, 37},
-                              { 0x0000feec, 15, -1, 46},
-                              { 0x0000fec8, 15, -1, 55},
-                              { 0x0000ec80, 15, -1, 64},
-                              { 0x0000c800, 15, -1, 0},
-                              { 0x0000ffec, 15, 0, 0},
-                              { 0x0000fe80, 15, 0, 0},
-                              { 0x0000e800, 15, -1, 0},
-                              { 0x0000ffe8, 15, -1, 0},
-                              { 0x0000ff00, 15, -1, 0},
-                              { 0x0000fff0, 15, 0, 0},
-                              { 0x0000f000, 15, 0, 0},
-                              { 0x0000f710, 15, 0, 0},
-                              { 142, 2, 0, 0},
-                              { 0x00007100, 8, 0, 0},
-                              { 2254, 2, 0, 0},
-                              { 140, 2, 0, 0},
-                              { 0x00007310, 8, 0, 0},
-                              { 0x00003100, 8, 0, 0},
-                              { 0x00008cce, 15, 0, 0},
-                              { 2188, 2, 0, 0},
-                              { 0x00003110, 8, 0, 0},
-                              { 0x00006666, 2, 0, 0},
-                              { 0x0000366c, 2, 0, 0},
-                              { 6120, 8, 0, 0},
-                              { 4080, 8, 0, 0},
-                              { 0x0000718e, 2, 0, 0},
-                              { 0x0000399c, 2, 0, 0},
-                              { 10, 5, 5, 5},
-                              { 7, 6, 6, 6},
-                              { 11, 5, 4, 4},
-                              { 11, 4, 5, 4},
-                              { 11, 4, 4, 5},
-                              { 9, 5, 5, 5},
-                              { 8, 6, 5, 5},
-                              { 8, 5, 6, 5},
-                              { 8, 5, 5, 6},
-                              { 6, 6, 6, 6},
-                              { 10, 10, 10, 10},
-                              { 11, 9, 9, 9},
-                              { 12, 8, 8, 8},
-                              { 16, 4, 4, 4},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 7, 0, 0, 0} }
-dcl_constantbuffer CB0[2], immediateIndexed
-dcl_resource_texture2d (float,float,float,float) t0
-dcl_resource_structured t1, 16
-dcl_uav_structured u0, 16
-dcl_input vThreadIDInGroupFlattened
-dcl_input vThreadGroupID.x
-dcl_temps 24
-dcl_indexableTemp x0[6], 4
-dcl_indexableTemp x1[2], 4
-dcl_tgsm_structured g0, 84, 64
-dcl_thread_group 64, 1, 1
-ushr r0.x, vThreadIDInGroupFlattened.x, l(5)
-ishl r0.y, vThreadGroupID.x, l(1)
-iadd r0.y, r0.y, cb0[1].x
-iadd r0.x, r0.x, r0.y
-and r0.y, vThreadIDInGroupFlattened.x, l(32)
-iadd r1.z, -r0.y, vThreadIDInGroupFlattened.x
-ult r2.xyzw, r1.zzzz, l(16, 32, 8, 4)
-if_nz r2.x
-  udiv r0.z, null, r0.x, cb0[0].y
-  imad r0.w, -r0.z, cb0[0].y, r0.x
-  ishl r0.w, r0.w, l(2)
-  ishl r0.z, r0.z, l(2)
-  and r1.w, r1.z, l(3)
-  iadd r3.x, r0.w, r1.w
-  ushr r0.w, r1.z, l(2)
-  iadd r3.y, r0.w, r0.z
-  mov r3.zw, l(0,0,0,0)
-  ld r3.xyzw, r3.xyzw, t0.xyzw
-  ushr r4.xyz, r3.xyzx, l(16)
-  and r4.xyz, r4.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  and r5.xyzw, r3.xxyy, l(0x7fffffff, 0x007fffff, 0x7fffffff, 0x007fffff)
-  ult r0.zw, l(0, 0, 0x47ffefff, 0x47ffefff), r5.xxxz
-  ult r3.xy, r5.xzxx, l(0x38800000, 0x38800000, 0, 0)
-  ushr r6.xy, r5.xzxx, l(23)
-  iadd r6.xy, -r6.xyxx, l(113, 113, 0, 0)
-  iadd r5.yw, r5.yyyw, l(0, 0x00800000, 0, 0x00800000)
-  ushr r7.x, r5.y, r6.x
-  ushr r7.y, r5.w, r6.y
-  iadd r5.xy, r5.xzxx, l(0xc8000000, 0xc8000000, 0, 0)
-  movc r3.xy, r3.xyxx, r7.xyxx, r5.xyxx
-  iadd r5.xy, r3.xyxx, l(4095, 4095, 0, 0)
-  ushr r3.xy, r3.xyxx, l(13)
-  and r3.xy, r3.xyxx, l(1, 1, 0, 0)
-  iadd r3.xy, r3.xyxx, r5.xyxx
-  ushr r3.xy, r3.xyxx, l(13)
-  and r3.xy, r3.xyxx, l(0x00007fff, 0x00007fff, 0, 0)
-  movc r0.zw, r0.zzzw, l(0,0,0x00007fff,0x00007fff), r3.xxxy
-  iadd r5.xy, r4.xyxx, r0.zwzz
-  and r0.zw, r3.zzzz, l(0, 0, 0x7fffffff, 0x007fffff)
-  ult r1.w, l(0x47ffefff), r0.z
-  ult r3.x, r0.z, l(0x38800000)
-  ushr r3.y, r0.z, l(23)
-  iadd r3.y, -r3.y, l(113)
-  iadd r0.w, r0.w, l(0x00800000)
-  ushr r0.w, r0.w, r3.y
-  iadd r0.z, r0.z, l(0xc8000000)
-  movc r0.z, r3.x, r0.w, r0.z
-  iadd r0.w, r0.z, l(4095)
-  ushr r0.z, r0.z, l(13)
-  and r0.z, r0.z, l(1)
-  iadd r0.z, r0.z, r0.w
-  ushr r0.z, r0.z, l(13)
-  and r0.z, r0.z, l(0x00007fff)
-  movc r0.z, r1.w, l(0x00007fff), r0.z
-  iadd r5.z, r4.z, r0.z
-  and r3.xyzw, r5.xxyy, l(1023, 0x00007c00, 1023, 0x00007c00)
-  if_nz r3.y
-    ushr r0.z, r5.x, l(10)
-    and r0.z, r0.z, l(31)
-  else 
-    if_nz r3.x
-      ishl r0.w, r3.x, l(1)
-      mov r1.w, r0.w
-      mov r0.z, l(0)
-      loop 
-        and r3.y, r1.w, l(1024)
-        breakc_nz r3.y
-        iadd r0.z, r0.z, l(-1)
-        ishl r1.w, r1.w, l(1)
-      endloop 
-      and r3.x, r1.w, l(1022)
-    else 
-      mov r3.x, l(0)
-      mov r0.z, l(-112)
-    endif 
-  endif 
-  ishl r4.xyz, r5.xyzx, l(16)
-  and r4.xyz, r4.xyzx, l(0x80000000, 0x80000000, 0x80000000, 0)
-  ishl r0.z, r0.z, l(23)
-  iadd r0.z, r0.z, l(0x38000000)
-  or r0.z, r0.z, r4.x
-  ishl r0.w, r3.x, l(13)
-  iadd r6.x, r0.w, r0.z
-  if_nz r3.w
-    ushr r0.z, r5.y, l(10)
-    and r0.z, r0.z, l(31)
-  else 
-    if_nz r3.z
-      ishl r0.w, r3.z, l(1)
-      mov r1.w, r0.w
-      mov r0.z, l(0)
-      loop 
-        and r3.x, r1.w, l(1024)
-        breakc_nz r3.x
-        iadd r0.z, r0.z, l(-1)
-        ishl r1.w, r1.w, l(1)
-      endloop 
-      and r3.z, r1.w, l(1022)
-    else 
-      mov r3.z, l(0)
-      mov r0.z, l(-112)
-    endif 
-  endif 
-  ishl r0.z, r0.z, l(23)
-  iadd r0.z, r0.z, l(0x38000000)
-  or r0.z, r0.z, r4.y
-  ishl r0.w, r3.z, l(13)
-  iadd r6.y, r0.w, r0.z
-  and r0.zw, r5.zzzz, l(0, 0, 1023, 0x00007c00)
-  if_nz r0.w
-    ushr r0.w, r5.z, l(10)
-    and r0.w, r0.w, l(31)
-  else 
-    if_nz r0.z
-      ishl r1.w, r0.z, l(1)
-      mov r3.x, r1.w
-      mov r0.w, l(0)
-      loop 
-        and r3.y, r3.x, l(1024)
-        breakc_nz r3.y
-        iadd r0.w, r0.w, l(-1)
-        ishl r3.x, r3.x, l(1)
-      endloop 
-      and r0.z, r3.x, l(1022)
-    else 
-      mov r0.zw, l(0,0,0,-112)
-    endif 
-  endif 
-  ishl r0.w, r0.w, l(23)
-  iadd r0.w, r0.w, l(0x38000000)
-  or r0.w, r0.w, r4.z
-  ishl r0.z, r0.z, l(13)
-  iadd r6.z, r0.z, r0.w
-  dp3 r6.w, r6.xyzx, l(0.212600, 0.715200, 0.072200, 0.000000)
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(24), r6.xyzw
-  ieq r0.z, cb0[0].z, l(95)
-  ishl r3.xyz, r5.xyzx, l(6)
-  udiv r3.xyz, null, r3.xyzx, l(31, 31, 31, 0)
-  ult r4.xyz, r5.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  ieq r6.xyz, r5.xyzx, l(0x00007bff, 0x00007bff, 0x00007bff, 0)
-  ishl r5.xyz, r5.xyzx, l(5)
-  udiv r7.xyz, null, r5.xyzx, l(31, 31, 31, 0)
-  movc r7.xyz, r6.xyzx, l(0x00007fff,0x00007fff,0x00007fff,0), r7.xyzx
-  and r5.xyz, r5.xyzx, l(0x000fffe0, 0x000fffe0, 0x000fffe0, 0)
-  udiv r5.xyz, null, r5.xyzx, l(31, 31, 31, 0)
-  ineg r5.xyz, r5.xyzx
-  movc r5.xyz, r6.xyzx, l(0xffff8001,0xffff8001,0xffff8001,0), r5.xyzx
-  movc r4.xyz, r4.xyzx, r7.xyzx, r5.xyzx
-  movc r3.xyz, r0.zzzz, r3.xyzx, r4.xyzx
-  store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(12), r3.xyzx
-endif 
-sync_g_t
-if_nz r2.y
-  mov x0[0].x, l(0x7fffffff)
-  mov x0[1].x, l(0x7fffffff)
-  mov x0[2].x, l(0x7fffffff)
-  mov x0[0].y, l(-0.000000)
-  mov x0[1].y, l(-0.000000)
-  mov x0[2].y, l(-0.000000)
-  mov x0[3].x, l(0x7fffffff)
-  mov x0[4].x, l(0x7fffffff)
-  mov x0[5].x, l(0x7fffffff)
-  mov x0[3].y, l(-0.000000)
-  mov x0[4].y, l(-0.000000)
-  mov x0[5].y, l(-0.000000)
-  mov x1[0].x, l(340282346638528859811704183484516925440.000000)
-  mov x1[0].y, l(-340282346638528859811704183484516925440.000000)
-  mov x1[1].x, l(340282346638528859811704183484516925440.000000)
-  mov x1[1].y, l(-340282346638528859811704183484516925440.000000)
-  mov r0.z, l(0)
-  loop 
-    uge r0.w, r0.z, l(16)
-    breakc_nz r0.w
-    iadd r0.w, r0.z, r0.y
-    ld_structured r3.xyz, r0.w, l(12), g0.xyzx
-    ld_structured r4.x, r0.w, l(36), g0.xxxx
-    ushr r0.w, icb[r1.z + 0].x, r0.z
-    and r0.w, r0.w, l(1)
-    if_nz r0.w
-      mov r0.w, x1[1].x
-      lt r1.w, r4.x, r0.w
-      mov r2.y, x0[3].x
-      movc r2.y, r1.w, r3.x, r2.y
-      mov x0[3].x, r2.y
-      mov r2.y, x0[4].x
-      movc r2.y, r1.w, r3.y, r2.y
-      mov x0[4].x, r2.y
-      mov r2.y, x0[5].x
-      movc r2.y, r1.w, r3.z, r2.y
-      mov x0[5].x, r2.y
-      movc r0.w, r1.w, r4.x, r0.w
-      mov x1[1].x, r0.w
-      mov r0.w, x1[1].y
-      lt r1.w, r0.w, r4.x
-      mov r2.y, x0[3].y
-      movc r2.y, r1.w, r3.x, r2.y
-      mov x0[3].y, r2.y
-      mov r2.y, x0[4].y
-      movc r2.y, r1.w, r3.y, r2.y
-      mov x0[4].y, r2.y
-      mov r2.y, x0[5].y
-      movc r2.y, r1.w, r3.z, r2.y
-      mov x0[5].y, r2.y
-      movc r0.w, r1.w, r4.x, r0.w
-      mov x1[1].y, r0.w
-    else 
-      mov r0.w, x1[0].x
-      lt r1.w, r4.x, r0.w
-      mov r2.y, x0[0].x
-      movc r2.y, r1.w, r3.x, r2.y
-      mov x0[0].x, r2.y
-      mov r2.y, x0[1].x
-      movc r2.y, r1.w, r3.y, r2.y
-      mov x0[1].x, r2.y
-      mov r2.y, x0[2].x
-      movc r2.y, r1.w, r3.z, r2.y
-      mov x0[2].x, r2.y
-      movc r0.w, r1.w, r4.x, r0.w
-      mov x1[0].x, r0.w
-      mov r0.w, x1[0].y
-      lt r1.w, r0.w, r4.x
-      mov r2.y, x0[0].y
-      movc r2.y, r1.w, r3.x, r2.y
-      mov x0[0].y, r2.y
-      mov r2.y, x0[1].y
-      movc r2.y, r1.w, r3.y, r2.y
-      mov x0[1].y, r2.y
-      mov r2.y, x0[2].y
-      movc r2.y, r1.w, r3.z, r2.y
-      mov x0[2].y, r2.y
-      movc r0.w, r1.w, r4.x, r0.w
-      mov x1[0].y, r0.w
-    endif 
-    iadd r0.z, r0.z, l(1)
-  endloop 
-  mov r3.x, x0[0].y
-  mov r3.y, x0[1].y
-  mov r3.z, x0[2].y
-  mov r0.z, x0[0].x
-  mov r0.w, x0[1].x
-  mov r1.w, x0[2].x
-  ineg r4.xy, r0.zwzz
-  ineg r4.z, r1.w
-  iadd r5.xyz, r3.xyzx, r4.xyzx
-  itof r5.xyz, r5.xyzx
-  dp3 r2.y, r5.xyzx, r5.xyzx
-  ld_structured r6.xyz, r0.y, l(12), g0.xyzx
-  iadd r4.xyz, r4.xyzx, r6.xyzx
-  itof r4.xyz, r4.xyzx
-  dp3 r3.w, r5.xyzx, r4.xyzx
-  lt r4.x, l(0.000000), r2.y
-  ge r4.y, r3.w, l(0.000000)
-  and r4.x, r4.y, r4.x
-  mul r3.w, r3.w, l(63.499989)
-  div r3.w, r3.w, r2.y
-  ftou r3.w, r3.w
-  ult r3.w, l(32), r3.w
-  and r3.w, r3.w, r4.x
-  movc r4.xyz, r3.wwww, -r5.xyzx, r5.xyzx
-  movc r5.xy, r3.wwww, r3.xyxx, r0.zwzz
-  movc r5.z, r3.w, r3.z, r1.w
-  movc r6.xy, r3.wwww, r0.zwzz, r3.xyxx
-  movc r6.z, r3.w, r1.w, r3.z
-  mov r3.x, x0[3].y
-  mov r3.y, x0[4].y
-  mov r3.z, x0[5].y
-  mov r0.z, x0[3].x
-  mov r0.w, x0[4].x
-  mov r1.w, x0[5].x
-  ineg r7.xy, r0.zwzz
-  ineg r7.z, r1.w
-  iadd r8.xyz, r3.xyzx, r7.xyzx
-  itof r8.xyz, r8.xyzx
-  dp3 r3.w, r8.xyzx, r8.xyzx
-  iadd r4.w, r0.y, icb[r1.z + 0].y
-  ld_structured r9.xyz, r4.w, l(12), g0.xyzx
-  iadd r7.xyz, r7.xyzx, r9.xyzx
-  itof r7.xyz, r7.xyzx
-  dp3 r4.w, r8.xyzx, r7.xyzx
-  lt r5.w, l(0.000000), r3.w
-  ge r6.w, r4.w, l(0.000000)
-  and r5.w, r5.w, r6.w
-  mul r4.w, r4.w, l(63.499989)
-  div r4.w, r4.w, r3.w
-  ftou r4.w, r4.w
-  ult r4.w, l(32), r4.w
-  and r4.w, r4.w, r5.w
-  movc r7.xyz, r4.wwww, -r8.xyzx, r8.xyzx
-  movc r8.xy, r4.wwww, r3.xyxx, r0.zwzz
-  movc r8.z, r4.w, r3.z, r1.w
-  movc r9.xy, r4.wwww, r0.zwzz, r3.xyxx
-  movc r9.z, r4.w, r1.w, r3.z
-  ieq r0.zw, cb0[0].zzzz, l(0, 0, 95, 96)
-  if_nz r0.z
-    mov r1.w, cb0[0].w
-    ige r3.x, icb[r1.w + 32].x, l(15)
-    and r3.x, r3.x, l(1)
-    movc r10.xyz, r5.xyzx, l(0,0,0,0), l(1,1,1,0)
-    movc r11.xyz, r6.xyzx, l(0,0,0,0), l(1,1,1,0)
-    or r10.xyz, r3.xxxx, r10.xyzx
-    or r11.xyz, r3.xxxx, r11.xyzx
-    ieq r12.xyz, r5.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-    ieq r13.xyz, r6.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-    ishl r3.y, l(1), icb[r1.w + 32].x
-    iadd r3.y, r3.y, l(-1)
-    ishl r14.xyz, r5.xyzx, icb[r1.w + 32].x
-    ishl r15.xyz, r6.xyzx, icb[r1.w + 32].x
-    ishr r14.xyz, r14.xyzx, l(16)
-    ishr r15.xyz, r15.xyzx, l(16)
-    movc r12.xyz, r12.xyzx, r3.yyyy, r14.xyzx
-    movc r13.xyz, r13.xyzx, r3.yyyy, r15.xyzx
-    movc r10.xyz, r10.xyzx, r5.xyzx, r12.xyzx
-    movc r11.xyz, r11.xyzx, r6.xyzx, r13.xyzx
-    movc r12.xyz, r8.xyzx, l(0,0,0,0), l(1,1,1,0)
-    movc r13.xyz, r9.xyzx, l(0,0,0,0), l(1,1,1,0)
-    or r12.xyz, r3.xxxx, r12.xyzx
-    or r13.xyz, r3.xxxx, r13.xyzx
-    ieq r14.xyz, r8.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-    ieq r15.xyz, r9.xyzx, l(0x0000ffff, 0x0000ffff, 0x0000ffff, 0)
-    mov r1.w, cb0[0].w
-    ishl r16.xyz, r8.xyzx, icb[r1.w + 32].x
-    ishl r17.xyz, r9.xyzx, icb[r1.w + 32].x
-    ishr r16.xyz, r16.xyzx, l(16)
-    ishr r17.xyz, r17.xyzx, l(16)
-    movc r14.xyz, r14.xyzx, r3.yyyy, r16.xyzx
-    movc r3.xyz, r15.xyzx, r3.yyyy, r17.xyzx
-    movc r12.xyz, r12.xyzx, r8.xyzx, r14.xyzx
-    movc r3.xyz, r13.xyzx, r9.xyzx, r3.xyzx
-  else 
-    mov r1.w, cb0[0].w
-    ige r4.w, icb[r1.w + 32].x, l(16)
-    and r4.w, r4.w, l(1)
-    movc r13.xyz, r5.xyzx, l(0,0,0,0), l(1,1,1,0)
-    movc r14.xyz, r6.xyzx, l(0,0,0,0), l(1,1,1,0)
-    or r13.xyz, r4.wwww, r13.xyzx
-    or r14.xyz, r4.wwww, r14.xyzx
-    ige r15.xyz, r5.xyzx, l(0, 0, 0, 0)
-    ige r16.xyz, r6.xyzx, l(0, 0, 0, 0)
-    ieq r17.xyz, r5.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ieq r18.xyz, r6.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    iadd r1.w, l(-1), icb[r1.w + 32].x
-    ishl r5.w, l(1), r1.w
-    iadd r6.w, r5.w, l(-1)
-    ishl r19.xyz, r5.xyzx, r1.w
-    ishl r20.xyz, r6.xyzx, r1.w
-    ishr r19.xyz, r19.xyzx, l(15)
-    ishr r20.xyz, r20.xyzx, l(15)
-    movc r17.xyz, r17.xyzx, r6.wwww, r19.xyzx
-    movc r18.xyz, r18.xyzx, r6.wwww, r20.xyzx
-    ineg r19.xyz, r5.xyzx
-    ineg r20.xyz, r6.xyzx
-    ieq r21.xyz, r19.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ieq r22.xyz, r20.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    iadd r5.w, -r5.w, l(1)
-    ishl r19.xyz, r19.xyzx, r1.w
-    ishl r20.xyz, r20.xyzx, r1.w
-    ishr r19.xyz, r19.xyzx, l(15)
-    ishr r20.xyz, r20.xyzx, l(15)
-    ineg r19.xyz, r19.xyzx
-    ineg r20.xyz, r20.xyzx
-    movc r19.xyz, r21.xyzx, r5.wwww, r19.xyzx
-    movc r20.xyz, r22.xyzx, r5.wwww, r20.xyzx
-    movc r15.xyz, r15.xyzx, r17.xyzx, r19.xyzx
-    movc r16.xyz, r16.xyzx, r18.xyzx, r20.xyzx
-    movc r10.xyz, r13.xyzx, r5.xyzx, r15.xyzx
-    movc r11.xyz, r14.xyzx, r6.xyzx, r16.xyzx
-    movc r6.xyz, r8.xyzx, l(0,0,0,0), l(1,1,1,0)
-    movc r13.xyz, r9.xyzx, l(0,0,0,0), l(1,1,1,0)
-    or r6.xyz, r4.wwww, r6.xyzx
-    or r13.xyz, r4.wwww, r13.xyzx
-    ige r14.xyz, r8.xyzx, l(0, 0, 0, 0)
-    ige r15.xyz, r9.xyzx, l(0, 0, 0, 0)
-    ieq r16.xyz, r8.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ieq r17.xyz, r9.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ishl r18.xyz, r8.xyzx, r1.w
-    ishl r19.xyz, r9.xyzx, r1.w
-    ishr r18.xyz, r18.xyzx, l(15)
-    ishr r19.xyz, r19.xyzx, l(15)
-    movc r16.xyz, r16.xyzx, r6.wwww, r18.xyzx
-    movc r17.xyz, r17.xyzx, r6.wwww, r19.xyzx
-    ineg r18.xyz, r8.xyzx
-    ineg r19.xyz, r9.xyzx
-    ieq r20.xyz, r18.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ieq r21.xyz, r19.xyzx, l(0x00007fff, 0x00007fff, 0x00007fff, 0)
-    ishl r18.xyz, r18.xyzx, r1.w
-    ishl r19.xyz, r19.xyzx, r1.w
-    ishr r18.xyz, r18.xyzx, l(15)
-    ishr r19.xyz, r19.xyzx, l(15)
-    ineg r18.xyz, r18.xyzx
-    ineg r19.xyz, r19.xyzx
-    movc r18.xyz, r20.xyzx, r5.wwww, r18.xyzx
-    movc r19.xyz, r21.xyzx, r5.wwww, r19.xyzx
-    movc r14.xyz, r14.xyzx, r16.xyzx, r18.xyzx
-    movc r15.xyz, r15.xyzx, r17.xyzx, r19.xyzx
-    movc r12.xyz, r6.xyzx, r8.xyzx, r14.xyzx
-    movc r3.xyz, r13.xyzx, r9.xyzx, r15.xyzx
-  endif 
-  iadd r6.xyz, -r10.xyzx, r11.xyzx
-  mov r1.w, cb0[0].w
-  movc r6.xyz, icb[r1.w + 0].zzzz, r6.xyzx, r11.xyzx
-  iadd r9.xyz, -r10.xyzx, r12.xyzx
-  movc r9.xyz, icb[r1.w + 0].zzzz, r9.xyzx, r12.xyzx
-  iadd r11.xyz, -r10.xyzx, r3.xyzx
-  movc r3.xyz, icb[r1.w + 0].zzzz, r11.xyzx, r3.xyzx
-  if_nz icb[r1.w + 0].z
-    ige r11.xyz, r6.xyzx, l(0, 0, 0, 0)
-    iadd r12.xyz, l(-1, -1, -1, 0), icb[r1.w + 32].yzwy
-    ishl r13.x, l(1), r12.x
-    ishl r13.y, l(1), r12.y
-    ishl r13.z, l(1), r12.z
-    ige r12.xyz, r6.xyzx, r13.xyzx
-    ineg r14.xyz, r6.xyzx
-    ilt r14.xyz, r13.xyzx, r14.xyzx
-    movc r15.xyz, r11.xyzx, r12.xyzx, r14.xyzx
-    or r4.w, r15.y, r15.x
-    or r4.w, r15.z, r4.w
-    ishl r15.x, l(1), icb[r1.w + 32].x
-    ishl r15.y, l(1), icb[r1.w + 32].y
-    ishl r15.z, l(1), icb[r1.w + 32].z
-    ishl r15.w, l(1), icb[r1.w + 32].w
-    iadd r15.xyzw, r15.xyzw, l(-1, -1, -1, -1)
-    and r16.xyz, r10.xyzx, r15.xxxx
-    iadd r17.xyz, r13.xyzx, l(-1, -1, -1, 0)
-    movc r12.xyz, r12.xyzx, r17.xyzx, r6.xyzx
-    and r18.xyz, r6.xyzx, r15.yzwy
-    movc r14.xyz, r14.xyzx, r13.xyzx, r18.xyzx
-    movc r11.xyz, r11.xyzx, r12.xyzx, r14.xyzx
-    ige r12.xyz, r9.xyzx, l(0, 0, 0, 0)
-    ige r14.xyz, r9.xyzx, r13.xyzx
-    ineg r18.xyz, r9.xyzx
-    ilt r18.xyz, r13.xyzx, r18.xyzx
-    movc r19.xyz, r12.xyzx, r14.xyzx, r18.xyzx
-    ige r20.xyz, r3.xyzx, l(0, 0, 0, 0)
-    ige r21.xyz, r3.xyzx, r13.xyzx
-    ineg r22.xyz, r3.xyzx
-    ilt r22.xyz, r13.xyzx, r22.xyzx
-    movc r23.xyz, r20.xyzx, r21.xyzx, r22.xyzx
-    or r19.xyz, r19.xyzx, r23.xyzx
-    or r5.w, r19.y, r19.x
-    or r5.w, r19.z, r5.w
-    or r4.w, r4.w, r5.w
-    and r4.w, r4.w, l(1)
-    movc r14.xyz, r14.xyzx, r17.xyzx, r9.xyzx
-    and r19.xyz, r9.xyzx, r15.yzwy
-    movc r18.xyz, r18.xyzx, r13.xyzx, r19.xyzx
-    movc r12.xyz, r12.xyzx, r14.xyzx, r18.xyzx
-    movc r14.xyz, r21.xyzx, r17.xyzx, r3.xyzx
-    and r15.xyz, r3.xyzx, r15.yzwy
-    movc r13.xyz, r22.xyzx, r13.xyzx, r15.xyzx
-    movc r13.xyz, r20.xyzx, r14.xyzx, r13.xyzx
-  else 
-    ishl r5.w, l(1), icb[r1.w + 32].x
-    iadd r5.w, r5.w, l(-1)
-    and r16.xyz, r5.wwww, r10.xyzx
-    and r11.xyz, r5.wwww, r6.xyzx
-    and r12.xyz, r5.wwww, r9.xyzx
-    and r13.xyz, r3.xyzx, r5.wwww
-    mov r4.w, l(0)
-  endif 
-  iadd r6.xyzw, l(-1, -1, -1, -1), icb[r1.w + 32].xyzw
-  ishl r9.x, l(1), r6.x
-  ishl r9.y, l(1), r6.y
-  ishl r9.z, l(1), r6.z
-  ishl r9.w, l(1), r6.w
-  and r3.xyz, r9.xxxx, r16.xyzx
-  iadd r10.xyzw, r9.xyzw, l(-1, -1, -1, -1)
-  and r6.yzw, r10.xxxx, r16.xxyz
-  iadd r6.yzw, -r9.xxxx, r6.yyzw
-  movc r3.xyz, r3.xyzx, r6.yzwy, r16.xyzx
-  movc r3.xyz, r0.wwww, r3.xyzx, r16.xyzx
-  or r0.w, r0.w, icb[r1.w + 0].z
-  and r6.yzw, r9.yyzw, r11.xxyz
-  and r14.xyz, r10.yzwy, r11.xyzx
-  iadd r14.xyz, -r9.yzwy, r14.xyzx
-  movc r6.yzw, r6.yyzw, r14.xxyz, r11.xxyz
-  movc r6.yzw, r0.wwww, r6.yyzw, r11.xxyz
-  and r11.xyz, r9.yzwy, r12.xyzx
-  and r14.xyz, r10.yzwy, r12.xyzx
-  iadd r14.xyz, -r9.yzwy, r14.xyzx
-  movc r11.xyz, r11.xyzx, r14.xyzx, r12.xyzx
-  movc r11.xyz, r0.wwww, r11.xyzx, r12.xyzx
-  and r12.xyz, r9.yzwy, r13.xyzx
-  and r10.yzw, r10.yyzw, r13.xxyz
-  iadd r9.xyz, -r9.yzwy, r10.yzwy
-  movc r9.xyz, r12.xyzx, r9.xyzx, r13.xyzx
-  movc r9.xyz, r0.wwww, r9.xyzx, r13.xyzx
-  iadd r10.yzw, r3.xxyz, r6.yyzw
-  movc r6.yzw, icb[r1.w + 0].zzzz, r10.yyzw, r6.yyzw
-  iadd r10.yzw, r3.xxyz, r11.xxyz
-  movc r10.yzw, icb[r1.w + 0].zzzz, r10.yyzw, r11.xxyz
-  iadd r11.xyz, r3.xyzx, r9.xyzx
-  movc r9.xyz, icb[r1.w + 0].zzzz, r11.xyzx, r9.xyzx
-  ult r11.xy, icb[r1.w + 32].xxxx, l(15, 16, 0, 0)
-  ishl r0.w, l(1), icb[r1.w + 32].x
-  iadd r0.w, r0.w, l(-1)
-  ieq r12.xyz, r0.wwww, r3.xyzx
-  ieq r13.xyz, r0.wwww, r6.yzwy
-  ishl r14.xyz, r3.xyzx, l(16)
-  ishl r15.xyz, r6.yzwy, l(16)
-  iadd r14.xyz, r14.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  iadd r15.xyz, r15.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  ushr r14.xyz, r14.xyzx, icb[r1.w + 32].x
-  ushr r15.xyz, r15.xyzx, icb[r1.w + 32].x
-  movc r12.xyz, r12.xyzx, l(0x0000ffff,0x0000ffff,0x0000ffff,0), r14.xyzx
-  movc r13.xyz, r13.xyzx, l(0x0000ffff,0x0000ffff,0x0000ffff,0), r15.xyzx
-  movc r12.xyz, r3.xyzx, r12.xyzx, l(0,0,0,0)
-  movc r13.xyz, r6.yzwy, r13.xyzx, l(0,0,0,0)
-  movc r12.xyz, r11.xxxx, r12.xyzx, r3.xyzx
-  movc r13.xyz, r11.xxxx, r13.xyzx, r6.yzwy
-  ige r14.xyz, r3.xyzx, l(0, 0, 0, 0)
-  ige r15.xyz, r6.yzwy, l(0, 0, 0, 0)
-  imax r16.xyz, -r3.xyzx, r3.xyzx
-  imax r17.xyz, -r6.yzwy, r6.yzwy
-  ige r18.xyz, r16.xyzx, r10.xxxx
-  ige r19.xyz, r17.xyzx, r10.xxxx
-  ishl r20.xyz, r16.xyzx, l(15)
-  ishl r21.xyz, r17.xyzx, l(15)
-  iadd r20.xyz, r20.xyzx, l(0x00004000, 0x00004000, 0x00004000, 0)
-  iadd r21.xyz, r21.xyzx, l(0x00004000, 0x00004000, 0x00004000, 0)
-  ushr r20.xyz, r20.xyzx, r6.x
-  ushr r21.xyz, r21.xyzx, r6.x
-  movc r18.xyz, r18.xyzx, l(0x00007fff,0x00007fff,0x00007fff,0), r20.xyzx
-  movc r19.xyz, r19.xyzx, l(0x00007fff,0x00007fff,0x00007fff,0), r21.xyzx
-  movc r16.xyz, r16.xyzx, r18.xyzx, l(0,0,0,0)
-  movc r17.xyz, r17.xyzx, r19.xyzx, l(0,0,0,0)
-  ineg r18.xyz, r16.xyzx
-  ineg r19.xyz, r17.xyzx
-  movc r14.xyz, r14.xyzx, r16.xyzx, r18.xyzx
-  movc r15.xyz, r15.xyzx, r17.xyzx, r19.xyzx
-  movc r3.xyz, r11.yyyy, r14.xyzx, r3.xyzx
-  movc r6.yzw, r11.yyyy, r15.xxyz, r6.yyzw
-  movc r3.xyz, r0.zzzz, r12.xyzx, r3.xyzx
-  movc r6.yzw, r0.zzzz, r13.xxyz, r6.yyzw
-  ieq r12.xyz, r0.wwww, r10.yzwy
-  ieq r13.xyz, r0.wwww, r9.xyzx
-  ishl r14.xyz, r10.yzwy, l(16)
-  ishl r15.xyz, r9.xyzx, l(16)
-  iadd r14.xyz, r14.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  iadd r15.xyz, r15.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-  ushr r14.xyz, r14.xyzx, icb[r1.w + 32].x
-  ushr r15.xyz, r15.xyzx, icb[r1.w + 32].x
-  movc r12.xyz, r12.xyzx, l(0x0000ffff,0x0000ffff,0x0000ffff,0), r14.xyzx
-  movc r13.xyz, r13.xyzx, l(0x0000ffff,0x0000ffff,0x0000ffff,0), r15.xyzx
-  movc r12.xyz, r10.yzwy, r12.xyzx, l(0,0,0,0)
-  movc r13.xyz, r9.xyzx, r13.xyzx, l(0,0,0,0)
-  movc r12.xyz, r11.xxxx, r12.xyzx, r10.yzwy
-  movc r11.xzw, r11.xxxx, r13.xxyz, r9.xxyz
-  ige r13.xyz, r10.yzwy, l(0, 0, 0, 0)
-  ige r14.xyz, r9.xyzx, l(0, 0, 0, 0)
-  imax r15.xyz, -r10.yzwy, r10.yzwy
-  imax r16.xyz, -r9.xyzx, r9.xyzx
-  ige r17.xyz, r15.xyzx, r10.xxxx
-  ige r18.xyz, r16.xyzx, r10.xxxx
-  ishl r19.xyz, r15.xyzx, l(15)
-  ishl r20.xyz, r16.xyzx, l(15)
-  iadd r19.xyz, r19.xyzx, l(0x00004000, 0x00004000, 0x00004000, 0)
-  iadd r20.xyz, r20.xyzx, l(0x00004000, 0x00004000, 0x00004000, 0)
-  ushr r19.xyz, r19.xyzx, r6.x
-  ushr r20.xyz, r20.xyzx, r6.x
-  movc r17.xyz, r17.xyzx, l(0x00007fff,0x00007fff,0x00007fff,0), r19.xyzx
-  movc r18.xyz, r18.xyzx, l(0x00007fff,0x00007fff,0x00007fff,0), r20.xyzx
-  movc r15.xyz, r15.xyzx, r17.xyzx, l(0,0,0,0)
-  movc r16.xyz, r16.xyzx, r18.xyzx, l(0,0,0,0)
-  ineg r17.xyz, r15.xyzx
-  ineg r18.xyz, r16.xyzx
-  movc r13.xyz, r13.xyzx, r15.xyzx, r17.xyzx
-  movc r14.xyz, r14.xyzx, r16.xyzx, r18.xyzx
-  movc r10.xyz, r11.yyyy, r13.xyzx, r10.yzwy
-  movc r9.xyz, r11.yyyy, r14.xyzx, r9.xyzx
-  movc r10.xyz, r0.zzzz, r12.xyzx, r10.xyzx
-  movc r9.xyz, r0.zzzz, r11.xzwx, r9.xyzx
-  ge r0.w, l(0.000000), r3.w
-  ge r1.w, l(0.000000), r2.y
-  mov r5.w, l(0)
-  mov r6.x, l(0)
-  loop 
-    uge r7.w, r6.x, l(16)
-    breakc_nz r7.w
-    ushr r7.w, icb[r1.z + 0].x, r6.x
-    and r7.w, r7.w, l(1)
-    if_nz r7.w
-      iadd r7.w, r0.y, r6.x
-      ld_structured r11.xyz, r7.w, l(12), g0.xyzx
-      iadd r11.xyz, -r8.xyzx, r11.xyzx
-      itof r11.xyz, r11.xyzx
-      dp3 r7.w, r7.xyzx, r11.xyzx
-      ge r8.w, l(0.000000), r7.w
-      or r8.w, r0.w, r8.w
-      lt r9.w, r7.w, r3.w
-      mul r7.w, r7.w, l(63.499989)
-      div r7.w, r7.w, r3.w
-      ftou r7.w, r7.w
-      movc r7.w, r9.w, icb[r7.w + 46].x, l(7)
-      movc r7.w, r8.w, l(0), r7.w
-      iadd r8.w, l(64), -icb[r7.w + 0].w
-      imul null, r11.xyz, r9.xyzx, icb[r7.w + 0].wwww
-      imad r11.xyz, r10.xyzx, r8.wwww, r11.xyzx
-      iadd r11.xyz, r11.xyzx, l(32, 32, 32, 0)
-      ishr r11.xyz, r11.xyzx, l(6)
-      imul null, r12.xyz, r11.xyzx, l(31, 31, 31, 0)
-      ishr r13.xyz, r12.xyzx, l(6)
-      ilt r14.xyz, r11.xyzx, l(0, 0, 0, 0)
-      imul null, r11.xyz, r11.xyzx, l(-31, -31, -31, 0)
-      ishr r11.xyz, r11.xyzx, l(5)
-      ineg r11.xyz, r11.xyzx
-      ishr r12.xyz, r12.xyzx, l(5)
-      movc r11.xyz, r14.xyzx, r11.xyzx, r12.xyzx
-      ilt r12.xyz, r11.xyzx, l(0, 0, 0, 0)
-      ineg r14.xyz, r11.xyzx
-      or r14.xyz, r14.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-      movc r11.xyz, r12.xyzx, r14.xyzx, r11.xyzx
-      movc r11.xyz, r0.zzzz, r13.xyzx, r11.xyzx
-    else 
-      iadd r7.w, r0.y, r6.x
-      ld_structured r12.xyz, r7.w, l(12), g0.xyzx
-      iadd r12.xyz, -r5.xyzx, r12.xyzx
-      itof r12.xyz, r12.xyzx
-      dp3 r7.w, r4.xyzx, r12.xyzx
-      ge r8.w, l(0.000000), r7.w
-      or r8.w, r1.w, r8.w
-      lt r9.w, r7.w, r2.y
-      mul r7.w, r7.w, l(63.499989)
-      div r7.w, r7.w, r2.y
-      ftou r7.w, r7.w
-      movc r7.w, r9.w, icb[r7.w + 46].x, l(7)
-      movc r7.w, r8.w, l(0), r7.w
-      iadd r8.w, l(64), -icb[r7.w + 0].w
-      imul null, r12.xyz, r6.yzwy, icb[r7.w + 0].wwww
-      imad r12.xyz, r3.xyzx, r8.wwww, r12.xyzx
-      iadd r12.xyz, r12.xyzx, l(32, 32, 32, 0)
-      ishr r12.xyz, r12.xyzx, l(6)
-      imul null, r13.xyz, r12.xyzx, l(31, 31, 31, 0)
-      ishr r14.xyz, r13.xyzx, l(6)
-      ilt r15.xyz, r12.xyzx, l(0, 0, 0, 0)
-      imul null, r12.xyz, r12.xyzx, l(-31, -31, -31, 0)
-      ishr r12.xyz, r12.xyzx, l(5)
-      ineg r12.xyz, r12.xyzx
-      ishr r13.xyz, r13.xyzx, l(5)
-      movc r12.xyz, r15.xyzx, r12.xyzx, r13.xyzx
-      ilt r13.xyz, r12.xyzx, l(0, 0, 0, 0)
-      ineg r15.xyz, r12.xyzx
-      or r15.xyz, r15.xyzx, l(0x00008000, 0x00008000, 0x00008000, 0)
-      movc r12.xyz, r13.xyzx, r15.xyzx, r12.xyzx
-      movc r11.xyz, r0.zzzz, r14.xyzx, r12.xyzx
-    endif 
-    and r12.xy, r11.xxxx, l(1023, 0x00007c00, 0, 0)
-    if_nz r12.y
-      ushr r7.w, r11.x, l(10)
-      and r7.w, r7.w, l(31)
-    else 
-      if_nz r12.x
-        ishl r8.w, r12.x, l(1)
-        mov r9.w, r8.w
-        mov r7.w, l(0)
-        loop 
-          and r10.w, r9.w, l(1024)
-          breakc_nz r10.w
-          iadd r7.w, r7.w, l(-1)
-          ishl r9.w, r9.w, l(1)
-        endloop 
-        and r12.x, r9.w, l(1022)
-      else 
-        mov r12.x, l(0)
-        mov r7.w, l(-112)
-      endif 
-    endif 
-    ishl r8.w, r11.x, l(16)
-    and r8.w, r8.w, l(0x80000000)
-    ishl r10.w, r7.w, l(23)
-    iadd r10.w, r10.w, l(0x38000000)
-    or r8.w, r8.w, r10.w
-    ishl r10.w, r12.x, l(13)
-    iadd r12.x, r8.w, r10.w
-    and r11.xw, r11.yyyy, l(1023, 0, 0, 0x00007c00)
-    if_nz r11.w
-      ushr r8.w, r11.y, l(10)
-      and r8.w, r8.w, l(31)
-    else 
-      if_nz r11.x
-        ishl r10.w, r11.x, l(1)
-        mov r11.w, r10.w
-        mov r8.w, l(0)
-        loop 
-          and r12.w, r11.w, l(1024)
-          breakc_nz r12.w
-          iadd r8.w, r8.w, l(-1)
-          ishl r11.w, r11.w, l(1)
-        endloop 
-        and r11.x, r11.w, l(1022)
-      else 
-        mov r11.x, l(0)
-        mov r8.w, l(-112)
-      endif 
-    endif 
-    ishl r10.w, r11.y, l(16)
-    and r10.w, r10.w, l(0x80000000)
-    ishl r11.y, r8.w, l(23)
-    iadd r11.y, r11.y, l(0x38000000)
-    or r10.w, r10.w, r11.y
-    ishl r11.x, r11.x, l(13)
-    iadd r12.y, r10.w, r11.x
-    and r11.xy, r11.zzzz, l(1023, 0x00007c00, 0, 0)
-    if_nz r11.y
-      ushr r10.w, r11.z, l(10)
-      and r10.w, r10.w, l(31)
-    else 
-      if_nz r11.x
-        ishl r11.y, r11.x, l(1)
-        mov r12.w, r11.y
-        mov r10.w, l(0)
-        loop 
-          and r13.x, r12.w, l(1024)
-          breakc_nz r13.x
-          iadd r10.w, r10.w, l(-1)
-          ishl r12.w, r12.w, l(1)
-        endloop 
-        and r11.x, r12.w, l(1022)
-      else 
-        mov r11.x, l(0)
-        mov r10.w, l(-112)
-      endif 
-    endif 
-    ishl r11.y, r11.z, l(16)
-    and r11.y, r11.y, l(0x80000000)
-    ishl r11.z, r10.w, l(23)
-    iadd r11.z, r11.z, l(0x38000000)
-    or r11.y, r11.z, r11.y
-    ishl r11.x, r11.x, l(13)
-    iadd r12.z, r11.x, r11.y
-    iadd r11.x, r0.y, r6.x
-    ld_structured r13.xyz, r11.x, l(24), g0.xyzx
-    add r11.xyz, r12.xyzx, -r13.xyzx
-    dp3 r11.x, r11.xyzx, r11.xyzx
-    add r5.w, r5.w, r11.x
-    iadd r6.x, r6.x, l(1)
-  endloop 
-  movc r1.x, r4.w, l(100000002004087734272.000000), r5.w
-  iadd r1.y, cb0[0].w, l(1)
-  store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(40), r1.xyzx
-endif 
-sync_g_t
-if_nz r2.x
-  ld_structured r3.x, vThreadIDInGroupFlattened.x, l(40), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(16)
-  ld_structured r4.yzw, r0.y, l(40), g0.xxyz
-  lt r0.z, r4.y, r3.x
-  if_nz r0.z
-    ld_structured r4.x, r0.y, l(40), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(40), r4.xzwx
-  endif 
-endif 
-sync_g_t
-if_nz r2.z
-  ld_structured r3.x, vThreadIDInGroupFlattened.x, l(40), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r4.yzw, r0.y, l(40), g0.xxyz
-  lt r0.z, r4.y, r3.x
-  if_nz r0.z
-    ld_structured r4.x, r0.y, l(40), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(40), r4.xzwx
-  endif 
-endif 
-sync_g_t
-if_nz r2.w
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(40), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r3.yzw, r0.y, l(40), g0.xxyz
-  lt r0.z, r3.y, r2.x
-  if_nz r0.z
-    ld_structured r3.x, r0.y, l(40), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(40), r3.xzwx
-  endif 
-endif 
-sync_g_t
-ult r0.yz, r1.zzzz, l(0, 2, 1, 0)
-if_nz r0.y
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(40), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r2.yzw, r0.y, l(40), g0.xxyz
-  lt r0.w, r2.y, r1.x
-  if_nz r0.w
-    ld_structured r2.x, r0.y, l(40), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(40), r2.xzwx
-  endif 
-endif 
-sync_g_t
-if_nz r0.z
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(40), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r2.yzw, r0.y, l(40), g0.xxyz
-  lt r0.z, r2.y, r1.x
-  if_nz r0.z
-    ld_structured r2.x, r0.y, l(40), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(40), r2.xzwx
-  endif 
-  ld_structured r1.x, r0.x, l(0), t1.xxxx
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(40), g0.xxxx
-  lt r0.y, r2.x, r1.x
-  if_nz r0.y
-    ld_structured r1.xyz, vThreadIDInGroupFlattened.x, l(40), g0.xyzx
-    mov r1.w, l(0)
-  else 
-    ld_structured r1.xyzw, r0.x, l(0), t1.xyzw
-  endif 
-  store_structured u0.xyzw, r0.x, l(0), r1.xyzw
-endif 
-ret 
-// Approximately 0 instruction slots used
-#endif
-
-const BYTE BC6HEncode_TryModeLE10CS[] =
-{
-     68,  88,  66,  67, 161,   2, 
-    137, 126,  42,  47, 246, 175, 
-    125,  91,  68,  30, 201,  32, 
-    221, 116,   1,   0,   0,   0, 
-     76,  96,   0,   0,   3,   0, 
-      0,   0,  44,   0,   0,   0, 
-     60,   0,   0,   0,  76,   0, 
-      0,   0,  73,  83,  71,  78, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     79,  83,  71,  78,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  83,  72, 
-     69,  88, 248,  95,   0,   0, 
-     64,   0,   5,   0, 254,  23, 
-      0,   0, 106,   8,   0,   1, 
-     53,  24,   0,   0, 186,   1, 
-      0,   0, 204, 204,   0,   0, 
-     15,   0,   0,   0, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-    136, 136,   0,   0,  15,   0, 
-      0,   0, 255, 255, 255, 255, 
-      9,   0,   0,   0, 238, 238, 
-      0,   0,  15,   0,   0,   0, 
-    255, 255, 255, 255,  18,   0, 
-      0,   0, 200, 236,   0,   0, 
-     15,   0,   0,   0, 255, 255, 
-    255, 255,  27,   0,   0,   0, 
-    128, 200,   0,   0,  15,   0, 
-      0,   0, 255, 255, 255, 255, 
-     37,   0,   0,   0, 236, 254, 
-      0,   0,  15,   0,   0,   0, 
-    255, 255, 255, 255,  46,   0, 
-      0,   0, 200, 254,   0,   0, 
-     15,   0,   0,   0, 255, 255, 
-    255, 255,  55,   0,   0,   0, 
-    128, 236,   0,   0,  15,   0, 
-      0,   0, 255, 255, 255, 255, 
-     64,   0,   0,   0,   0, 200, 
-      0,   0,  15,   0,   0,   0, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0, 236, 255,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    128, 254,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0, 232, 
-      0,   0,  15,   0,   0,   0, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0, 232, 255,   0,   0, 
-     15,   0,   0,   0, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-      0, 255,   0,   0,  15,   0, 
-      0,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0, 240, 255, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0, 240,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     16, 247,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 142,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0, 113,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    206,   8,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 140,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  16, 115,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  49,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 206, 140, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 140,   8,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     16,  49,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 102, 102, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 108,  54,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    232,  23,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 240,  15, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 142, 113,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    156,  57,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   5,   0,   0,   0, 
-      5,   0,   0,   0,   5,   0, 
-      0,   0,   7,   0,   0,   0, 
-      6,   0,   0,   0,   6,   0, 
-      0,   0,   6,   0,   0,   0, 
-     11,   0,   0,   0,   5,   0, 
-      0,   0,   4,   0,   0,   0, 
-      4,   0,   0,   0,  11,   0, 
-      0,   0,   4,   0,   0,   0, 
-      5,   0,   0,   0,   4,   0, 
-      0,   0,  11,   0,   0,   0, 
-      4,   0,   0,   0,   4,   0, 
-      0,   0,   5,   0,   0,   0, 
-      9,   0,   0,   0,   5,   0, 
-      0,   0,   5,   0,   0,   0, 
-      5,   0,   0,   0,   8,   0, 
-      0,   0,   6,   0,   0,   0, 
-      5,   0,   0,   0,   5,   0, 
-      0,   0,   8,   0,   0,   0, 
-      5,   0,   0,   0,   6,   0, 
-      0,   0,   5,   0,   0,   0, 
-      8,   0,   0,   0,   5,   0, 
-      0,   0,   5,   0,   0,   0, 
-      6,   0,   0,   0,   6,   0, 
-      0,   0,   6,   0,   0,   0, 
-      6,   0,   0,   0,   6,   0, 
-      0,   0,  10,   0,   0,   0, 
-     10,   0,   0,   0,  10,   0, 
-      0,   0,  10,   0,   0,   0, 
-     11,   0,   0,   0,   9,   0, 
-      0,   0,   9,   0,   0,   0, 
-      9,   0,   0,   0,  12,   0, 
-      0,   0,   8,   0,   0,   0, 
-      8,   0,   0,   0,   8,   0, 
-      0,   0,  16,   0,   0,   0, 
-      4,   0,   0,   0,   4,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  89,   0, 
-      0,   4,  70, 142,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  88,  24,   0,   4, 
-      0, 112,  16,   0,   0,   0, 
-      0,   0,  85,  85,   0,   0, 
-    162,   0,   0,   4,   0, 112, 
-     16,   0,   1,   0,   0,   0, 
-     16,   0,   0,   0, 158,   0, 
-      0,   4,   0, 224,  17,   0, 
-      0,   0,   0,   0,  16,   0, 
-      0,   0,  95,   0,   0,   2, 
-      0,  64,   2,   0,  95,   0, 
-      0,   2,  18,  16,   2,   0, 
-    104,   0,   0,   2,  24,   0, 
-      0,   0, 105,   0,   0,   4, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   4,   0,   0,   0, 
-    105,   0,   0,   4,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,   0,   0, 160,   0, 
-      0,   5,   0, 240,  17,   0, 
-      0,   0,   0,   0,  84,   0, 
-      0,   0,  64,   0,   0,   0, 
-    155,   0,   0,   4,  64,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   6,  18,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  16, 
-      2,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   8,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10, 128,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16, 128,  65,   0,   0,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,  79,   0,   0,  10, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0, 166,  10,  16,   0, 
-      1,   0,   0,   0,   2,  64, 
-      0,   0,  16,   0,   0,   0, 
-     32,   0,   0,   0,   8,   0, 
-      0,   0,   4,   0,   0,   0, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     78,   0,   0,   9,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-      0, 208,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     35,   0,   0,  11, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16, 128,  65,   0, 
-      0,   0,   0,   0,   0,   0, 
-     26, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   8, 
-    194,   0,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  45,   0, 
-      0,   7, 242,   0,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     70, 126,  16,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,   6,   5, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 127, 255, 255, 127,   0, 
-    255, 255, 255, 127, 255, 255, 
-    127,   0,  79,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 255, 239, 255,  71, 
-    255, 239, 255,  71,   6,   8, 
-     16,   0,   5,   0,   0,   0, 
-     79,   0,   0,  10,  50,   0, 
-     16,   0,   3,   0,   0,   0, 
-    134,   0,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0, 128,  56,   0,   0, 
-    128,  56,   0,   0,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  50,   0,  16,   0, 
-      6,   0,   0,   0, 134,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  30,   0,   0,  11, 
-     50,   0,  16,   0,   6,   0, 
-      0,   0,  70,   0,  16, 128, 
-     65,   0,   0,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-    113,   0,   0,   0, 113,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,  10, 162,   0,  16,   0, 
-      5,   0,   0,   0,  86,  13, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0, 128,   0, 
-      0,   0,   0,   0,   0,   0, 
-    128,   0,  85,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     85,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,  10,  50,   0,  16,   0, 
-      5,   0,   0,   0, 134,   0, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0, 200,   0,   0,   0, 200, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-     50,   0,  16,   0,   3,   0, 
-      0,   0,  70,   0,  16,   0, 
-      3,   0,   0,   0,  70,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,  10, 
-     50,   0,  16,   0,   5,   0, 
-      0,   0,  70,   0,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0, 255,  15,   0,   0, 
-    255,  15,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  50,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,  10,  50,   0,  16,   0, 
-      3,   0,   0,   0,  70,   0, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     50,   0,  16,   0,   3,   0, 
-      0,   0,  70,   0,  16,   0, 
-      3,   0,   0,   0,  70,   0, 
-     16,   0,   5,   0,   0,   0, 
-     85,   0,   0,   7,  50,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,   1,   0, 
-      0,  10,  50,   0,  16,   0, 
-      3,   0,   0,   0,  70,   0, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,  12, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0, 166,  14,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      6,   4,  16,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     50,   0,  16,   0,   5,   0, 
-      0,   0,  70,   0,  16,   0, 
-      4,   0,   0,   0, 230,  10, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-    166,  10,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 127, 
-    255, 255, 127,   0,  79,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0, 255, 239, 255,  71, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  79,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0, 128,  56, 
-     85,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  30,   0, 
-      0,   8,  34,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16, 128,  65,   0,   0,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0, 113,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0, 128,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0, 200, 
-     55,   0,   0,   9,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255,  15,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0, 255, 127,   0,   0, 
-     55,   0,   0,   9,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 127,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      3,   0,   0,   0,   6,   5, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0, 255,   3, 
-      0,   0,   0, 124,   0,   0, 
-    255,   3,   0,   0,   0, 124, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,  18,   0, 
-      0,   1,  31,   0,   4,   3, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   5, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  48,   0, 
-      0,   1,   1,   0,   0,   7, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   4,   0,   0, 
-      3,   0,   4,   3,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    254,   3,   0,   0,  18,   0, 
-      0,   1,  54,   0,   0,   5, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0, 144, 255, 255, 255, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  41,   0,   0,   7, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,  56, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  18,   0,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  48,   0,   0,   1, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   4,   0,   0,   3,   0, 
-      4,   3,  10,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     22,   0,   0,   1,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0, 254,   3, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   5,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   5, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    144, 255, 255, 255,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,  56,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0, 166,  10,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 255,   3, 
-      0,   0,   0, 124,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  18,   0,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  48,   0,   0,   1, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   4,   0,   0,   3,   0, 
-      4,   3,  26,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  41,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     22,   0,   0,   1,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0, 254,   3, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   8, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 144, 255, 
-    255, 255,  21,   0,   0,   1, 
-     21,   0,   0,   1,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,  56, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     16,   0,   0,  10, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-    208, 179,  89,  62,  89,  23, 
-     55,  63, 152, 221, 147,  61, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     32,   0,   0,   8,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  95,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     78,   0,   0,  11, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-      0, 208,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-     31,   0,   0,   0,   0,   0, 
-      0,   0,  79,   0,   0,  10, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 123,   0,   0, 255, 123, 
-      0,   0, 255, 123,   0,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  78,   0,   0,  11, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,   0, 208,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,   0,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0, 224, 255, 
-     15,   0, 224, 255,  15,   0, 
-    224, 255,  15,   0,   0,   0, 
-      0,   0,  78,   0,   0,  11, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,   0, 208,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,   0,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-      0,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1, 128, 255, 255,   1, 128, 
-    255, 255,   1, 128, 255, 255, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 127,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 127,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 127,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0, 128,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0, 128,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0, 128,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 127,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 127,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 127,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0, 128,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0, 128,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0, 128,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 127, 127,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 127, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 127, 127,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 127, 255,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,  80,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   3,   0,   4,   3, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     85,   0,   0,   8, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10, 144, 144,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  48,  32,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-     49,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,  48, 
-     32,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,  49,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  55,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  55,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  55,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  48,  32,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,  48, 
-     32,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,  49,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  55,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  55,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  21,   0,   0,   1, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,  54,   0,   0,   6, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  40,   0,   0,   5, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0, 230,  10,  16,   0, 
-      0,   0,   0,   0,  40,   0, 
-      0,   5,  66,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  43,   0, 
-      0,   5, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     16,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      6,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  43,   0,   0,   5, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  16,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,  49,   0,   0,   7, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     29,   0,   0,   7,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  56,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     14,   0,   0,   7, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  28,   0, 
-      0,   5, 130,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     79,   0,   0,   7, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  55,   0,   0,  10, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0, 246,  15,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-    246,  15,  16,   0,   3,   0, 
-      0,   0,  70,   0,  16,   0, 
-      3,   0,   0,   0, 230,  10, 
-     16,   0,   0,   0,   0,   0, 
-     55,   0,   0,   9,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     55,   0,   0,   9,  50,   0, 
-     16,   0,   6,   0,   0,   0, 
-    246,  15,  16,   0,   3,   0, 
-      0,   0, 230,  10,  16,   0, 
-      0,   0,   0,   0,  70,   0, 
-     16,   0,   3,   0,   0,   0, 
-     55,   0,   0,   9,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     40,   0,   0,   5,  50,   0, 
-     16,   0,   7,   0,   0,   0, 
-    230,  10,  16,   0,   0,   0, 
-      0,   0,  40,   0,   0,   5, 
-     66,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  43,   0,   0,   5, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  16,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   8, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  26, 144, 
-    144,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  43,   0,   0,   5, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  16,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  49,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     29,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  56,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     14,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,  28,   0, 
-      0,   5, 130,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-     79,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  55,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0, 246,  15,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     55,   0,   0,   9,  50,   0, 
-     16,   0,   8,   0,   0,   0, 
-    246,  15,  16,   0,   4,   0, 
-      0,   0,  70,   0,  16,   0, 
-      3,   0,   0,   0, 230,  10, 
-     16,   0,   0,   0,   0,   0, 
-     55,   0,   0,   9,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     55,   0,   0,   9,  50,   0, 
-     16,   0,   9,   0,   0,   0, 
-    246,  15,  16,   0,   4,   0, 
-      0,   0, 230,  10,  16,   0, 
-      0,   0,   0,   0,  70,   0, 
-     16,   0,   3,   0,   0,   0, 
-     55,   0,   0,   9,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     32,   0,   0,  11, 194,   0, 
-     16,   0,   0,   0,   0,   0, 
-    166, 138,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     95,   0,   0,   0,  96,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10, 144, 208,   0, 
-     32,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-      6,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-     11,   0,   0,   0,   6,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  32,   0,   0,  10, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   9,  34,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     10, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  41,   0,   0,   9, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  10, 144, 
-    208,   0,  32,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  41,   0,   0,   9, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  10, 144, 
-    208,   0,  32,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     86,   5,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     86,   5,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,  55,   0, 
-      0,  15, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  15, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-     12,   0,   0,   0,   6,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0,   6,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  41,   0,   0,   9, 
-    114,   0,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  10, 144, 
-    208,   0,  32,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  41,   0,   0,   9, 
-    114,   0,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  10, 144, 
-    208,   0,  32,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     86,   5,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     86,   5,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-     17,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  18,   0, 
-      0,   1,  54,   0,   0,   6, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,   9, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  10, 144, 208,   0, 
-     32,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  15, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-    246,  15,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-     14,   0,   0,   0, 246,  15, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     33,   0,   0,  10, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     17,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  32,   0,   0,  10, 
-    114,   0,  16,   0,  18,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   9, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  10, 144, 208,   0, 
-     32,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  41,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0, 246,  15,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0, 246,  15,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     21,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  32,   0,   0,  10, 
-    114,   0,  16,   0,  22,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,   2,  64, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   8, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16, 128,  65,   0, 
-      0,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  20,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,  19,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  21,   0,   0,   0, 
-    246,  15,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     20,   0,   0,   0,  70,   2, 
-     16,   0,  22,   0,   0,   0, 
-    246,  15,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     16,   0,   0,   0,  70,   2, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,  55,   0, 
-      0,  15, 114,   0,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  15, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-      6,   0,   0,   0, 246,  15, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0, 246,  15,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     33,   0,   0,  10, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  33,   0, 
-      0,  10, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  32,   0,   0,  10, 
-    114,   0,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     18,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0, 246,  15, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-     17,   0,   0,   0, 246,  15, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,  19,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  18,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     32,   0,   0,  10, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-     21,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-      2,  64,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-    255, 127,   0,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  18,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     18,   0,   0,   0,  70,   2, 
-     16,   0,  18,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     18,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-    246,  15,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  21,   0,   0,   0, 
-    246,  15,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  21,   0, 
-      0,   1,  30,   0,   0,   8, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16, 128, 
-     65,   0,   0,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58, 128, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  10, 114,   0,  16,   0, 
-      6,   0,   0,   0, 166, 154, 
-    144,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  30,   0,   0,   8, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16, 128, 
-     65,   0,   0,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,  55,   0, 
-      0,  10, 114,   0,  16,   0, 
-      9,   0,   0,   0, 166, 154, 
-    144,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  30,   0,   0,   8, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16, 128, 
-     65,   0,   0,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,  10, 114,   0,  16,   0, 
-      3,   0,   0,   0, 166, 154, 
-    144,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  31,   0,   4,   4, 
-     42, 144, 144,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     33,   0,   0,  10, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,  12, 114,   0,  16,   0, 
-     12,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-    150, 151, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     13,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,  12,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,  13,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  13,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-     12,   0,   0,   0,  33,   0, 
-      0,   7, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  34,   0, 
-      0,   7, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-     15,   0,   0,   0,  10,   0, 
-     16,   0,  15,   0,   0,   0, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,  15,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   9,  18,   0,  16,   0, 
-     15,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     10, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   9,  34,   0,  16,   0, 
-     15,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     26, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   9,  66,   0,  16,   0, 
-     15,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     42, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   9, 130,   0,  16,   0, 
-     15,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     58, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-     15,   0,   0,   0,  70,  14, 
-     16,   0,  15,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255,   1,   0,   0,   7, 
-    114,   0,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,   6,   0, 
-     16,   0,  15,   0,   0,   0, 
-     30,   0,   0,  10, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,   1,   0, 
-      0,   7, 114,   0,  16,   0, 
-     18,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-    150,   7,  16,   0,  15,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     33,   0,   0,   7, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-     18,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     34,   0,   0,   7, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,  33,   0, 
-      0,  10, 114,   0,  16,   0, 
-     20,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,   7, 
-    114,   0,  16,   0,  21,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  22,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  34,   0,   0,   7, 
-    114,   0,  16,   0,  22,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  22,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  23,   0,   0,   0, 
-     70,   2,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     21,   0,   0,   0,  70,   2, 
-     16,   0,  22,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     23,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,  19,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   1,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0, 150,   7, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  18,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  21,   0, 
-      0,   0,  70,   2,  16,   0, 
-     17,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      1,   0,   0,   7, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0, 150,   7,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  22,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,  18,   0, 
-      0,   1,  41,   0,   0,   9, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  10, 144, 
-    208,   0,  32,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0, 255, 255, 255, 255, 
-      1,   0,   0,   7, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-    246,  15,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,   1,   0, 
-      0,   7, 114,   0,  16,   0, 
-     11,   0,   0,   0, 246,  15, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   1,   0,   0,   7, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0, 246,  15,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      1,   0,   0,   7, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0, 246,  15,  16,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     21,   0,   0,   1,  30,   0, 
-      0,  12, 242,   0,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-     70, 158, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,   1,   0,   0,   7, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,   6,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,  16,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,   1,   0, 
-      0,   7, 226,   0,  16,   0, 
-      6,   0,   0,   0,   6,   0, 
-     16,   0,  10,   0,   0,   0, 
-      6,   9,  16,   0,  16,   0, 
-      0,   0,  30,   0,   0,   8, 
-    226,   0,  16,   0,   6,   0, 
-      0,   0,   6,   0,  16, 128, 
-     65,   0,   0,   0,   9,   0, 
-      0,   0,  86,  14,  16,   0, 
-      6,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-    150,   7,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      3,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,  60,   0, 
-      0,   8, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42, 144, 144,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,   0,   0,   7, 226,   0, 
-     16,   0,   6,   0,   0,   0, 
-     86,  14,  16,   0,   9,   0, 
-      0,   0,   6,   9,  16,   0, 
-     11,   0,   0,   0,   1,   0, 
-      0,   7, 114,   0,  16,   0, 
-     14,   0,   0,   0, 150,   7, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  30,   0,   0,   8, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0, 150,   7,  16, 128, 
-     65,   0,   0,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      6,   0,   0,   0,  86,  14, 
-     16,   0,   6,   0,   0,   0, 
-      6,   9,  16,   0,  14,   0, 
-      0,   0,   6,   9,  16,   0, 
-     11,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      6,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-     86,  14,  16,   0,   6,   0, 
-      0,   0,   6,   9,  16,   0, 
-     11,   0,   0,   0,   1,   0, 
-      0,   7, 114,   0,  16,   0, 
-     11,   0,   0,   0, 150,   7, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,   1,   0,   0,   7, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0, 150,   7,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     30,   0,   0,   8, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-    150,   7,  16, 128,  65,   0, 
-      0,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0, 246,  15,  16,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,   1,   0,   0,   7, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0, 150,   7,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-      1,   0,   0,   7, 226,   0, 
-     16,   0,  10,   0,   0,   0, 
-     86,  14,  16,   0,  10,   0, 
-      0,   0,   6,   9,  16,   0, 
-     13,   0,   0,   0,  30,   0, 
-      0,   8, 114,   0,  16,   0, 
-      9,   0,   0,   0, 150,   7, 
-     16, 128,  65,   0,   0,   0, 
-      9,   0,   0,   0, 150,   7, 
-     16,   0,  10,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     30,   0,   0,   7, 226,   0, 
-     16,   0,  10,   0,   0,   0, 
-      6,   9,  16,   0,   3,   0, 
-      0,   0,  86,  14,  16,   0, 
-      6,   0,   0,   0,  55,   0, 
-      0,  10, 226,   0,  16,   0, 
-      6,   0,   0,   0, 166, 154, 
-    144,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  86,  14, 
-     16,   0,  10,   0,   0,   0, 
-     86,  14,  16,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-    226,   0,  16,   0,  10,   0, 
-      0,   0,   6,   9,  16,   0, 
-      3,   0,   0,   0,   6,   9, 
-     16,   0,  11,   0,   0,   0, 
-     55,   0,   0,  10, 226,   0, 
-     16,   0,  10,   0,   0,   0, 
-    166, 154, 144,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     86,  14,  16,   0,  10,   0, 
-      0,   0,   6,   9,  16,   0, 
-     11,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  55,   0,   0,  10, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0, 166, 154, 144,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     79,   0,   0,  12,  50,   0, 
-     16,   0,  11,   0,   0,   0, 
-      6, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   2,  64, 
-      0,   0,  15,   0,   0,   0, 
-     16,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     41,   0,   0,   9, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  10, 144, 208,   0, 
-     32,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  32,   0, 
-      0,   7, 114,   0,  16,   0, 
-     12,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  32,   0,   0,   7, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0, 246,  15,  16,   0, 
-      0,   0,   0,   0, 150,   7, 
-     16,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     15,   0,   0,   0, 150,   7, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  30,   0,   0,  10, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,  10, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   9, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     10, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   9, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     10, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-     13,   0,   0,   0, 150,   7, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     12,   0,   0,   0,   6,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     13,   0,   0,   0,   6,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0, 150,   7,  16,   0, 
-      6,   0,   0,   0,  33,   0, 
-      0,  10, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0, 150,   7,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     36,   0,   0,   8, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16, 128,  65,   0, 
-      0,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  36,   0,   0,   8, 
-    114,   0,  16,   0,  17,   0, 
-      0,   0, 150,   7,  16, 128, 
-     65,   0,   0,   0,   6,   0, 
-      0,   0, 150,   7,  16,   0, 
-      6,   0,   0,   0,  33,   0, 
-      0,   7, 114,   0,  16,   0, 
-     18,   0,   0,   0,  70,   2, 
-     16,   0,  16,   0,   0,   0, 
-      6,   0,  16,   0,  10,   0, 
-      0,   0,  33,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     17,   0,   0,   0,   6,   0, 
-     16,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     21,   0,   0,   0,  70,   2, 
-     16,   0,  17,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  30,   0,   0,  10, 
-    114,   0,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,  64,   0,   0,   0,  64, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,  10, 114,   0, 
-     16,   0,  21,   0,   0,   0, 
-     70,   2,  16,   0,  21,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     20,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  21,   0, 
-      0,   0,  70,   2,  16,   0, 
-     21,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,  19,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,  21,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     17,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      3,   0,   0,   0,  86,   5, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      6,   0,   0,   0,  86,   5, 
-     16,   0,  11,   0,   0,   0, 
-      6,   9,  16,   0,  15,   0, 
-      0,   0,  86,  14,  16,   0, 
-      6,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      3,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      6,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-      6,   9,  16,   0,  13,   0, 
-      0,   0,  86,  14,  16,   0, 
-      6,   0,   0,   0,  32,   0, 
-      0,   7, 114,   0,  16,   0, 
-     12,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-    150,   7,  16,   0,  10,   0, 
-      0,   0,  32,   0,   0,   7, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0, 246,  15,  16,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-    150,   7,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  30,   0,   0,  10, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,  10, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   9, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     10, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   9, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-     10, 144, 208,   0,  32,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-     12,   0,   0,   0, 150,   7, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  12, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     12,   0,   0,   0,   6,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0, 150,   7,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 210,   0,  16,   0, 
-     11,   0,   0,   0,   6,   0, 
-     16,   0,  11,   0,   0,   0, 
-      6,   9,  16,   0,  13,   0, 
-      0,   0,   6,   9,  16,   0, 
-      9,   0,   0,   0,  33,   0, 
-      0,  10, 114,   0,  16,   0, 
-     13,   0,   0,   0, 150,   7, 
-     16,   0,  10,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,  10, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     36,   0,   0,   8, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-    150,   7,  16, 128,  65,   0, 
-      0,   0,  10,   0,   0,   0, 
-    150,   7,  16,   0,  10,   0, 
-      0,   0,  36,   0,   0,   8, 
-    114,   0,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16, 128, 
-     65,   0,   0,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  33,   0, 
-      0,   7, 114,   0,  16,   0, 
-     17,   0,   0,   0,  70,   2, 
-     16,   0,  15,   0,   0,   0, 
-      6,   0,  16,   0,  10,   0, 
-      0,   0,  33,   0,   0,   7, 
-    114,   0,  16,   0,  18,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,   6,   0, 
-     16,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     20,   0,   0,   0,  70,   2, 
-     16,   0,  16,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  30,   0,   0,  10, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,   2,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,  64,   0,   0,   0,  64, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,  10, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  20,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  64,   0,   0,   0,  64, 
-      0,   0,   0,  64,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 127,   0,   0, 255, 127, 
-      0,   0, 255, 127,   0,   0, 
-      0,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     17,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  12, 114,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  18,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     17,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     18,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     10,   0,   0,   0,  86,   5, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0, 150,   7,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      9,   0,   0,   0,  86,   5, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     10,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      9,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-    134,   3,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  29,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  29,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  48,   0, 
-      0,   1,  80,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      3,   0,   4,   3,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     85,   0,   0,   8, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10, 144, 144,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-     11,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   8, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     43,   0,   0,   5, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  16,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     29,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  49,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     56,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  14,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  28,   0,   0,   5, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  55,   0, 
-      0,  11, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10, 144, 208,   0,  46,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     55,   0,   0,   9, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     30,   0,   0,   9, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,  58, 144, 144, 128, 
-     65,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     38,   0,   0,   9,   0, 208, 
-      0,   0, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-    246, 159, 144,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     35,   0,   0,   9, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  10,   0, 
-      0,   0, 246,  15,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     30,   0,   0,  10, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,   2,  64,   0,   0, 
-     32,   0,   0,   0,  32,   0, 
-      0,   0,  32,   0,   0,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  38,   0,   0,  11, 
-      0, 208,   0,   0, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,   0,   0,   0,  31,   0, 
-      0,   0,  31,   0,   0,   0, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  34,   0,   0,  10, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     38,   0,   0,  11,   0, 208, 
-      0,   0, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-      2,  64,   0,   0, 225, 255, 
-    255, 255, 225, 255, 255, 255, 
-    225, 255, 255, 255,   0,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  42,   0,   0,   7, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     34,   0,   0,  10, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     60,   0,   0,  10, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-     11,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  18,   0, 
-      0,   1,  30,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   8, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16, 128,  65,   0, 
-      0,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  43,   0,   0,   5, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,  16,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  29,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  49,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  56,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     14,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  28,   0, 
-      0,   5, 130,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     55,   0,   0,  11, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  10, 144, 208,   0, 
-     46,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   9, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  58, 144, 
-    144, 128,  65,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  38,   0,   0,   9, 
-      0, 208,   0,   0, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-    150,   7,  16,   0,   6,   0, 
-      0,   0, 246, 159, 144,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  35,   0,   0,   9, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0, 246,  15, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  30,   0,   0,  10, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-     32,   0,   0,   0,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  38,   0, 
-      0,  11,   0, 208,   0,   0, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,   2,  64, 
-      0,   0,  31,   0,   0,   0, 
-     31,   0,   0,   0,  31,   0, 
-      0,   0,   0,   0,   0,   0, 
-     42,   0,   0,   7, 114,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  34,   0, 
-      0,  10, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  38,   0,   0,  11, 
-      0, 208,   0,   0, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,   2,  64,   0,   0, 
-    225, 255, 255, 255, 225, 255, 
-    255, 255, 225, 255, 255, 255, 
-      0,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  40,   0,   0,   5, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-      0,   7, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,  34,   0,   0,  10, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     40,   0,   0,   5, 114,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,  60,   0,   0,  10, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-     15,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     21,   0,   0,   1,   1,   0, 
-      0,  10,  50,   0,  16,   0, 
-     12,   0,   0,   0,   6,   0, 
-     16,   0,  11,   0,   0,   0, 
-      2,  64,   0,   0, 255,   3, 
-      0,   0,   0, 124,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,  12,   0, 
-      0,   0,  85,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,  18,   0, 
-      0,   1,  31,   0,   4,   3, 
-     10,   0,  16,   0,  12,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-     12,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  48,   0, 
-      0,   1,   1,   0,   0,   7, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   0,   4,   0,   0, 
-      3,   0,   4,   3,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,  12,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-    254,   3,   0,   0,  18,   0, 
-      0,   1,  54,   0,   0,   5, 
-     18,   0,  16,   0,  12,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0, 144, 255, 255, 255, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  41,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0, 128,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,  56, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  10,   0, 
-     16,   0,  12,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,  12,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-      1,   0,   0,  10, 146,   0, 
-     16,   0,  11,   0,   0,   0, 
-     86,   5,  16,   0,  11,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255,   3,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0, 124,   0,   0,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-     11,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,  10,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-     18,   0,   0,   1,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  10,   0, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,  11,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-     12,   0,   0,   0,  58,   0, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,   0,   4, 
-      0,   0,   3,   0,   4,   3, 
-     58,   0,  16,   0,  12,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0, 255, 255, 255, 255, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,  11,   0,   0,   0, 
-     58,   0,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,   1,   0,   0,   7, 
-     18,   0,  16,   0,  11,   0, 
-      0,   0,  58,   0,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0, 254,   3,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0, 144, 255, 
-    255, 255,  21,   0,   0,   1, 
-     21,   0,   0,   1,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0, 128, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,  11,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-     11,   0,   0,   0,  26,   0, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,  56,  60,   0,   0,   7, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,  11,   0,   0,   0, 
-     10,   0,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-     12,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     10,   0,  16,   0,  11,   0, 
-      0,   0,   1,   0,   0,  10, 
-     50,   0,  16,   0,  11,   0, 
-      0,   0, 166,  10,  16,   0, 
-     11,   0,   0,   0,   2,  64, 
-      0,   0, 255,   3,   0,   0, 
-      0, 124,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,  11,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  18,   0,   0,   1, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,  11,   0,   0,   0, 
-     10,   0,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-     12,   0,   0,   0,  26,   0, 
-     16,   0,  11,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  48,   0,   0,   1, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,  13,   0,   0,   0, 
-     58,   0,  16,   0,  12,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   4,   0,   0,   3,   0, 
-      4,   3,  10,   0,  16,   0, 
-     13,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  41,   0,   0,   7, 
-    130,   0,  16,   0,  12,   0, 
-      0,   0,  58,   0,  16,   0, 
-     12,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     22,   0,   0,   1,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-     11,   0,   0,   0,  58,   0, 
-     16,   0,  12,   0,   0,   0, 
-      1,  64,   0,   0, 254,   3, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-    144, 255, 255, 255,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,  11,   0,   0,   0, 
-     42,   0,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-     11,   0,   0,   0,  26,   0, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0, 128,  41,   0,   0,   7, 
-     66,   0,  16,   0,  11,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,  11,   0,   0,   0, 
-     42,   0,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,  56,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-     11,   0,   0,   0,  42,   0, 
-     16,   0,  11,   0,   0,   0, 
-     26,   0,  16,   0,  11,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,  11,   0, 
-      0,   0,  10,   0,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,  12,   0,   0,   0, 
-     10,   0,  16,   0,  11,   0, 
-      0,   0,  26,   0,  16,   0, 
-     11,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-     11,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0,  10,   0,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,   0,   0,   0,   8, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-     13,   0,   0,   0,  16,   0, 
-      0,   7,  18,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,   0,   0,   0,   7, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  10,   0, 
-     16,   0,  11,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,  55,   0,   0,   9, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0, 236, 120, 173,  96, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   8, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  58, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0,  70,   2, 
-     16,   0,   1,   0,   0,   0, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0, 167,   0, 
-      0,   9, 226,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0,   6, 249,  17,   0, 
-      0,   0,   0,   0,  49,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0, 168,   0,   0,   8, 
-    114, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0, 134,   3,  16,   0, 
-      4,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-    167,   0,   0,   9, 226,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0,   6, 249, 
-     17,   0,   0,   0,   0,   0, 
-     49,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0, 134,   3, 
-     16,   0,   4,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0, 167,   0,   0,   9, 
-    226,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-      6, 249,  17,   0,   0,   0, 
-      0,   0,  49,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-    134,   3,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  79,   0,   0,  10, 
-     98,   0,  16,   0,   0,   0, 
-      0,   0, 166,  10,  16,   0, 
-      1,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-    226,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-      6, 249,  17,   0,   0,   0, 
-      0,   0,  49,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     40,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-    134,   3,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 226,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0,   6, 249,  17,   0, 
-      0,   0,   0,   0,  49,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  40,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0, 168,   0,   0,   8, 
-    114, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0, 134,   3,  16,   0, 
-      2,   0,   0,   0,  21,   0, 
-      0,   1, 167,   0,   0,   9, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-      6, 112,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  49,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    114,   0,  16,   0,   1,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  40,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 126,  16,   0, 
-      1,   0,   0,   0,  21,   0, 
-      0,   1, 168,   0,   0,   9, 
-    242, 224,  17,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70,  14,  16,   0,   1,   0, 
-      0,   0,  21,   0,   0,   1, 
-     62,   0,   0,   1
-};
diff --git a/thirdparty/directxtex/Shaders/Compiled/BC7Encode_EncodeBlockCS.inc b/thirdparty/directxtex/Shaders/Compiled/BC7Encode_EncodeBlockCS.inc
deleted file mode 100644
index 6e6c40c..0000000
--- a/thirdparty/directxtex/Shaders/Compiled/BC7Encode_EncodeBlockCS.inc
+++ /dev/null
@@ -1,10164 +0,0 @@
-#if 0
-//
-// Generated by Microsoft (R) D3D Shader Disassembler
-//
-//
-// Input signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Input
-//
-// Output signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Output
-cs_4_0
-dcl_globalFlags refactoringAllowed
-dcl_immediateConstantBuffer { { 0x0000cccc, -0.000000, 15, 0},
-                              { 0x00008888, 65981199646559862278586368.000000, 15, 0},
-                              { 0x0000eeee, 15358528172589056.000000, 15, 0},
-                              { 0x0000ecc8, 3584194248704.000000, 15, 0},
-                              { 0x0000c880, -0.000000, 15, 0},
-                              { 0x0000feec, -0.000000, 15, 0},
-                              { 0x0000fec8, 14680365989888.000000, 15, 0},
-                              { 0x0000ec80, 15362462362632192.000000, 15, 0},
-                              { 0x0000c800, -0.000000, 15, 0},
-                              { 0x0000ffec, -0.000000, 15, 0},
-                              { 0x0000fe80, -0.000000, 15, 0},
-                              { 0x0000e800, -0.000000, 15, 0},
-                              { 0x0000ffe8, -0.000000, 15, 0},
-                              { 0x0000ff00, -0.000000, 15, 0},
-                              { 0x0000fff0, -0.000000, 15, 0},
-                              { 0x0000f000, 0.000000, 15, 0},
-                              { 0x0000f710, -0.000000, 15, 0},
-                              { 142, 0.000000, 2, 0},
-                              { 0x00007100, -0.000000, 8, 0},
-                              { 2254, 22076467445760.000000, 2, 0},
-                              { 140, -0.000000, 2, 0},
-                              { 0x00007310, 70798013459086900396556288.000000, 8, 0},
-                              { 0x00003100, -0.000000, 8, 0},
-                              { 0x00008cce, 0.000000, 15, 0},
-                              { 2188, 0x0050a4a4, 2, 0},
-                              { 0x00003110, -0.000000, 8, 0},
-                              { 0x00006666, 0.000000, 2, 0},
-                              { 0x0000366c, 17610885206241624413175808.000000, 2, 0},
-                              { 6120, -0.000000, 8, 0},
-                              { 4080, -0.000000, 8, 0},
-                              { 0x0000718e, 22097854464.000000, 2, 0},
-                              { 0x0000399c, 65888818352238724844093440.000000, 2, 0},
-                              { 0x0000aaaa, -0.000000, 15, 0},
-                              { 0x0000f0f0, 19411582976.000000, 15, 0},
-                              { 0x00005a5a, -0.000000, 6, 0},
-                              { 0x000033cc, 0.000000, 8, 0},
-                              { 0x00003c3c, 0.000000, 2, 0},
-                              { 0x000055aa, 0.000000, 8, 0},
-                              { 0x00009696, 0.000000, 15, 0},
-                              { 0x0000a55a, 22151331840.000000, 15, 0},
-                              { 0x000073ce, 9304358912.000000, 2, 0},
-                              { 5064, -0.000000, 8, 0},
-                              { 0x0000324c, 271536072765004599787520.000000, 2, 0},
-                              { 0x00003bdc, -0.000000, 2, 0},
-                              { 0x00006996, 21517107200.000000, 2, 0},
-                              { 0x0000c33c, 12724757752857622655008768.000000, 15, 0},
-                              { 0x00009966, 1365.320801, 15, 0},
-                              { 1632, 272006464738884193353728.000000, 6, 0},
-                              { 626, -0.000000, 6, 0},
-                              { 1252, 5783798415360.000000, 2, 0},
-                              { 0x00004e40, -0.000000, 6, 0},
-                              { 0x00002720, -0.000000, 8, 0},
-                              { 0x0000c936, -0.000000, 15, 0},
-                              { 0x0000936c, -0.000000, 15, 0},
-                              { 0x000039c6, -0.000000, 2, 0},
-                              { 0x0000639c, -0.000000, 2, 0},
-                              { 0x00009336, -0.000000, 15, 0},
-                              { 0x00009cc6, -0.000000, 15, 0},
-                              { 0x0000817e, -0.000000, 15, 0},
-                              { 0x0000e718, -0.000000, 15, 0},
-                              { 0x0000ccf0, 4.007874, 15, 0},
-                              { 4044, -0.000000, 2, 0},
-                              { 0x00007744, -0.000000, 2, 0},
-                              { 0x0000ee22, 0.000000, 15, 0},
-                              { 0, 0, 3, 15},
-                              { 0, 0, 3, 8},
-                              { 0, 0, 15, 8},
-                              { 1, 0, 15, 3},
-                              { 1, 0, 8, 15},
-                              { 1, 0, 3, 15},
-                              { 1, 0, 15, 3},
-                              { 2, 0, 15, 8},
-                              { 2, 0, 8, 15},
-                              { 2, 0, 8, 15},
-                              { 2, 0, 6, 15},
-                              { 2, 0, 6, 15},
-                              { 3, 0, 6, 15},
-                              { 3, 0, 5, 15},
-                              { 3, 0, 3, 15},
-                              { 3, 0, 3, 8},
-                              { 4, 0, 3, 15},
-                              { 4, 0, 3, 8},
-                              { 4, 0, 8, 15},
-                              { 4, 0, 15, 3},
-                              { 5, 0, 3, 15},
-                              { 5, 0, 3, 8},
-                              { 5, 0, 6, 15},
-                              { 5, 0, 10, 8},
-                              { 6, 0, 5, 3},
-                              { 6, 0, 8, 15},
-                              { 6, 0, 8, 6},
-                              { 6, 0, 6, 10},
-                              { 6, 0, 8, 15},
-                              { 7, 0, 5, 15},
-                              { 7, 0, 15, 10},
-                              { 7, 0, 15, 8},
-                              { 7, 0, 8, 15},
-                              { 8, 0, 15, 3},
-                              { 8, 0, 3, 15},
-                              { 8, 0, 5, 10},
-                              { 8, 0, 6, 10},
-                              { 9, 0, 10, 8},
-                              { 9, 0, 8, 9},
-                              { 9, 0, 15, 10},
-                              { 9, 0, 15, 6},
-                              { 10, 0, 3, 15},
-                              { 10, 0, 15, 8},
-                              { 10, 0, 5, 15},
-                              { 10, 0, 15, 3},
-                              { 10, 0, 15, 6},
-                              { 11, 0, 15, 6},
-                              { 11, 0, 15, 8},
-                              { 11, 0, 3, 15},
-                              { 11, 0, 15, 3},
-                              { 12, 0, 5, 15},
-                              { 12, 0, 5, 15},
-                              { 12, 0, 5, 15},
-                              { 12, 0, 8, 15},
-                              { 13, 0, 5, 15},
-                              { 13, 0, 10, 15},
-                              { 13, 0, 5, 15},
-                              { 13, 0, 10, 15},
-                              { 14, 0, 8, 15},
-                              { 14, 0, 13, 15},
-                              { 14, 0, 15, 3},
-                              { 14, 0, 12, 15},
-                              { 15, 0, 3, 15},
-                              { 15, 0, 3, 8},
-                              { 0, 15, 0, 0},
-                              { 0, 15, 0, 0},
-                              { 0, 15, 0, 0},
-                              { 0, 15, 0, 0},
-                              { 0, 15, 0, 0},
-                              { 1, 15, 0, 0},
-                              { 1, 15, 0, 0},
-                              { 1, 15, 0, 0},
-                              { 1, 15, 0, 0},
-                              { 1, 15, 0, 0},
-                              { 1, 15, 0, 0},
-                              { 1, 15, 0, 0},
-                              { 1, 15, 0, 0},
-                              { 1, 15, 0, 0},
-                              { 2, 15, 0, 0},
-                              { 2, 15, 0, 0},
-                              { 2, 15, 0, 0},
-                              { 2, 2, 0, 0},
-                              { 2, 8, 0, 0},
-                              { 2, 2, 0, 0},
-                              { 2, 2, 0, 0},
-                              { 2, 8, 0, 0},
-                              { 2, 8, 0, 0},
-                              { 3, 15, 0, 0},
-                              { 3, 2, 0, 0},
-                              { 3, 8, 0, 0},
-                              { 3, 2, 0, 0},
-                              { 3, 2, 0, 0},
-                              { 3, 8, 0, 0},
-                              { 3, 8, 0, 0},
-                              { 3, 2, 0, 0},
-                              { 3, 2, 0, 0},
-                              { 3, 15, 0, 0},
-                              { 4, 15, 0, 0},
-                              { 4, 6, 0, 0},
-                              { 4, 8, 0, 0},
-                              { 4, 2, 0, 0},
-                              { 4, 8, 0, 0},
-                              { 4, 15, 0, 0},
-                              { 4, 15, 0, 0},
-                              { 4, 2, 0, 0},
-                              { 4, 8, 0, 0},
-                              { 5, 2, 0, 0},
-                              { 5, 2, 0, 0},
-                              { 5, 2, 0, 0},
-                              { 5, 15, 0, 0},
-                              { 5, 15, 0, 0},
-                              { 5, 6, 0, 0},
-                              { 5, 6, 0, 0},
-                              { 5, 2, 0, 0},
-                              { 5, 6, 0, 0},
-                              { 6, 8, 0, 0},
-                              { 6, 15, 0, 0},
-                              { 6, 15, 0, 0},
-                              { 6, 2, 0, 0},
-                              { 6, 2, 0, 0},
-                              { 6, 15, 0, 0},
-                              { 6, 15, 0, 0},
-                              { 6, 15, 0, 0},
-                              { 6, 15, 0, 0},
-                              { 7, 15, 0, 0},
-                              { 7, 2, 0, 0},
-                              { 7, 2, 0, 0},
-                              { 7, 15, 0, 0},
-                              { 0, 3, 15, 0},
-                              { 0, 3, 8, 0},
-                              { 0, 8, 15, 0},
-                              { 0, 3, 15, 0},
-                              { 0, 8, 15, 0},
-                              { 0, 3, 15, 0},
-                              { 0, 3, 15, 0},
-                              { 0, 8, 15, 0},
-                              { 0, 8, 15, 0},
-                              { 0, 8, 15, 0},
-                              { 0, 6, 15, 0},
-                              { 1, 6, 15, 0},
-                              { 1, 6, 15, 0},
-                              { 1, 5, 15, 0},
-                              { 1, 3, 15, 0},
-                              { 1, 3, 8, 0},
-                              { 1, 3, 15, 0},
-                              { 1, 3, 8, 0},
-                              { 1, 8, 15, 0},
-                              { 1, 3, 15, 0},
-                              { 1, 3, 15, 0},
-                              { 1, 3, 8, 0},
-                              { 1, 6, 15, 0},
-                              { 1, 8, 10, 0},
-                              { 1, 3, 5, 0},
-                              { 1, 8, 15, 0},
-                              { 1, 6, 8, 0},
-                              { 1, 6, 10, 0},
-                              { 1, 8, 15, 0},
-                              { 1, 5, 15, 0},
-                              { 1, 10, 15, 0},
-                              { 1, 8, 15, 0},
-                              { 1, 8, 15, 0},
-                              { 2, 3, 15, 0},
-                              { 2, 3, 15, 0},
-                              { 2, 5, 10, 0},
-                              { 2, 6, 10, 0},
-                              { 2, 8, 10, 0},
-                              { 2, 8, 9, 0},
-                              { 2, 10, 15, 0},
-                              { 2, 6, 15, 0},
-                              { 2, 3, 15, 0},
-                              { 2, 8, 15, 0},
-                              { 2, 5, 15, 0},
-                              { 2, 3, 15, 0},
-                              { 2, 6, 15, 0},
-                              { 2, 6, 15, 0},
-                              { 2, 8, 15, 0},
-                              { 2, 3, 15, 0},
-                              { 2, 3, 15, 0},
-                              { 2, 5, 15, 0},
-                              { 2, 5, 15, 0},
-                              { 2, 5, 15, 0},
-                              { 2, 8, 15, 0},
-                              { 3, 5, 15, 0},
-                              { 3, 10, 15, 0},
-                              { 3, 5, 15, 0},
-                              { 3, 10, 15, 0},
-                              { 3, 8, 15, 0},
-                              { 3, 13, 15, 0},
-                              { 3, 3, 15, 0},
-                              { 3, 12, 15, 0},
-                              { 3, 3, 15, 0},
-                              { 3, 3, 8, 0} }
-dcl_constantbuffer CB0[2], immediateIndexed
-dcl_resource_texture2d (float,float,float,float) t0
-dcl_resource_structured t1, 16
-dcl_uav_structured u0, 16
-dcl_input vThreadIDInGroupFlattened
-dcl_input vThreadGroupID.x
-dcl_temps 15
-dcl_tgsm_structured g0, 100, 64
-dcl_thread_group 64, 1, 1
-ushr r0.x, vThreadIDInGroupFlattened.x, l(4)
-ishl r0.y, vThreadGroupID.x, l(2)
-iadd r0.y, r0.y, cb0[1].x
-iadd r0.x, r0.x, r0.y
-and r0.y, vThreadIDInGroupFlattened.x, l(48)
-iadd r0.z, -r0.y, vThreadIDInGroupFlattened.x
-ld_structured r1.xyz, r0.x, l(4), t1.xyzx
-and r0.w, r1.x, l(0x7fffffff)
-ld_structured r2.x, r0.x, l(4), t1.xxxx
-ushr r1.x, r2.x, l(31)
-ult r2.xyzw, r0.zzzz, l(16, 8, 4, 2)
-if_nz r2.x
-  udiv r1.w, null, r0.x, cb0[0].y
-  imad r3.x, -r1.w, cb0[0].y, r0.x
-  ishl r3.x, r3.x, l(2)
-  ishl r1.w, r1.w, l(2)
-  and r3.y, r0.z, l(3)
-  iadd r3.x, r3.y, r3.x
-  ushr r4.x, r0.z, l(2)
-  iadd r3.y, r1.w, r4.x
-  mov r3.zw, l(0,0,0,0)
-  ld r3.xyzw, r3.xyzw, t0.xyzw
-  mul r3.xyzw, r3.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000)
-  ftou r3.xyzw, r3.xyzw
-  umin r3.xyzw, r3.xyzw, l(255, 255, 255, 255)
-  ieq r4.xy, r0.wwww, l(4, 5, 0, 0)
-  or r1.w, r4.y, r4.x
-  ieq r4.xyz, r1.zzzz, l(1, 2, 3, 0)
-  movc r5.zw, r4.zzzz, r3.wwwz, r3.zzzw
-  mov r5.xy, r3.xyxx
-  movc r5.yzw, r4.yyyy, r3.wwzy, r5.yyzw
-  movc r4.xyzw, r4.xxxx, r3.wyzx, r5.xyzw
-  movc r3.xyzw, r1.wwww, r4.xyzw, r3.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(0), r3.xyzw
-endif 
-sync_g_t
-iadd r1.w, r1.y, l(-64)
-if_nz r2.x
-  ld_structured r3.xyzw, vThreadIDInGroupFlattened.x, l(0), g0.xyzw
-  ishl r4.x, r0.z, l(1)
-  ushr r4.x, icb[r1.w + 0].y, r4.x
-  and r4.x, r4.x, l(3)
-  ieq r4.yz, r0.wwww, l(0, 0, 2, 0)
-  or r4.y, r4.z, r4.y
-  ieq r4.x, r4.x, l(2)
-  movc r5.xyzw, r4.xxxx, r3.xyzw, l(-1,-1,-1,-1)
-  and r3.xyzw, r3.xyzw, r4.xxxx
-  movc r5.xyzw, r4.yyyy, r5.xyzw, l(-1,-1,-1,-1)
-  and r3.xyzw, r3.xyzw, r4.yyyy
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r5.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r3.xyzw
-endif 
-sync_g_t
-if_nz r2.y
-  ld_structured r3.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r4.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r5.x, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r6.xyzw, r5.x, l(36), g0.xyzw
-  ld_structured r5.xyzw, r5.x, l(52), g0.xyzw
-  umin r3.xyzw, r3.xyzw, r6.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r3.xyzw
-  umax r3.xyzw, r4.xyzw, r5.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r3.xyzw
-endif 
-sync_g_t
-if_nz r2.z
-  ld_structured r3.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r4.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r5.x, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r6.xyzw, r5.x, l(36), g0.xyzw
-  ld_structured r5.xyzw, r5.x, l(52), g0.xyzw
-  umin r3.xyzw, r3.xyzw, r6.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r3.xyzw
-  umax r3.xyzw, r4.xyzw, r5.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r3.xyzw
-endif 
-sync_g_t
-if_nz r2.w
-  ld_structured r3.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r4.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r5.x, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r6.xyzw, r5.x, l(36), g0.xyzw
-  ld_structured r5.xyzw, r5.x, l(52), g0.xyzw
-  umin r3.xyzw, r3.xyzw, r6.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r3.xyzw
-  umax r3.xyzw, r4.xyzw, r5.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r3.xyzw
-endif 
-sync_g_t
-ult r3.xy, r0.zzzz, l(1, 3, 0, 0)
-if_nz r3.x
-  ld_structured r4.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r5.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r3.z, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r6.xyzw, r3.z, l(36), g0.xyzw
-  ld_structured r7.xyzw, r3.z, l(52), g0.xyzw
-  umin r4.xyzw, r4.xyzw, r6.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r4.xyzw
-  umax r4.xyzw, r5.xyzw, r7.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r4.xyzw
-endif 
-sync_g_t
-ieq r3.zw, r0.zzzz, l(0, 0, 2, 1)
-if_nz r3.z
-  ld_structured r4.xyzw, r0.y, l(36), g0.xyzw
-  ld_structured r5.xyzw, r0.y, l(52), g0.xyzw
-else 
-  mov r4.xyzw, l(-1,-1,-1,-1)
-  mov r5.xyzw, l(0,0,0,0)
-endif 
-if_nz r2.x
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(0), g0.xyzw
-  ushr r3.z, icb[r1.y + 0].x, r0.z
-  and r3.z, r3.z, l(1)
-  ishl r7.x, r0.z, l(1)
-  ushr r7.x, icb[r1.w + 0].y, r7.x
-  and r7.x, r7.x, l(3)
-  ieq r8.xyzw, r0.wwww, l(0, 2, 1, 3)
-  ieq r7.x, r7.x, l(1)
-  movc r9.xyzw, r7.xxxx, r6.xyzw, l(-1,-1,-1,-1)
-  and r7.xyzw, r6.xyzw, r7.xxxx
-  or r8.xy, r8.ywyy, r8.xzxx
-  ieq r8.z, r0.w, l(7)
-  or r8.y, r8.z, r8.y
-  ieq r3.z, r3.z, l(1)
-  movc r10.xyzw, r3.zzzz, r6.xyzw, l(-1,-1,-1,-1)
-  and r6.xyzw, r6.xyzw, r3.zzzz
-  movc r10.xyzw, r8.yyyy, r10.xyzw, l(-1,-1,-1,-1)
-  and r6.xyzw, r6.xyzw, r8.yyyy
-  movc r9.xyzw, r8.xxxx, r9.xyzw, r10.xyzw
-  movc r6.xyzw, r8.xxxx, r7.xyzw, r6.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_nz r2.y
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r7.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r3.z, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r8.xyzw, r3.z, l(36), g0.xyzw
-  ld_structured r9.xyzw, r3.z, l(52), g0.xyzw
-  umin r6.xyzw, r6.xyzw, r8.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r6.xyzw
-  umax r6.xyzw, r7.xyzw, r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_nz r2.z
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r7.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r3.z, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r8.xyzw, r3.z, l(36), g0.xyzw
-  ld_structured r9.xyzw, r3.z, l(52), g0.xyzw
-  umin r6.xyzw, r6.xyzw, r8.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r6.xyzw
-  umax r6.xyzw, r7.xyzw, r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_nz r2.w
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r7.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r3.z, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r8.xyzw, r3.z, l(36), g0.xyzw
-  ld_structured r9.xyzw, r3.z, l(52), g0.xyzw
-  umin r6.xyzw, r6.xyzw, r8.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r6.xyzw
-  umax r6.xyzw, r7.xyzw, r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_nz r3.x
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r7.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r3.z, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r8.xyzw, r3.z, l(36), g0.xyzw
-  ld_structured r9.xyzw, r3.z, l(52), g0.xyzw
-  umin r6.xyzw, r6.xyzw, r8.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r6.xyzw
-  umax r6.xyzw, r7.xyzw, r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_nz r3.w
-  ld_structured r4.xyzw, r0.y, l(36), g0.xyzw
-  ld_structured r5.xyzw, r0.y, l(52), g0.xyzw
-endif 
-if_nz r2.x
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(0), g0.xyzw
-  ushr r3.z, icb[r1.y + 0].x, r0.z
-  and r3.z, r3.z, l(1)
-  ishl r7.x, r0.z, l(1)
-  ushr r7.x, icb[r1.w + 0].y, r7.x
-  and r7.x, r7.x, l(3)
-  ieq r8.xyzw, r0.wwww, l(0, 2, 1, 3)
-  movc r9.xyzw, r7.xxxx, l(-1,-1,-1,-1), r6.xyzw
-  movc r7.xyzw, r7.xxxx, l(0,0,0,0), r6.xyzw
-  or r8.xy, r8.ywyy, r8.xzxx
-  ieq r10.xyzw, r0.wwww, l(7, 4, 5, 6)
-  or r8.y, r8.y, r10.x
-  movc r11.xyzw, r3.zzzz, l(-1,-1,-1,-1), r6.xyzw
-  movc r12.xyzw, r3.zzzz, l(0,0,0,0), r6.xyzw
-  or r3.z, r10.z, r10.y
-  or r3.z, r10.w, r3.z
-  movc r10.xyzw, r3.zzzz, r6.xyzw, l(-1,-1,-1,-1)
-  and r6.xyzw, r6.xyzw, r3.zzzz
-  movc r10.xyzw, r8.yyyy, r11.xyzw, r10.xyzw
-  movc r6.xyzw, r8.yyyy, r12.xyzw, r6.xyzw
-  movc r9.xyzw, r8.xxxx, r9.xyzw, r10.xyzw
-  movc r6.xyzw, r8.xxxx, r7.xyzw, r6.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_nz r2.y
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r7.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r2.y, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r8.xyzw, r2.y, l(36), g0.xyzw
-  ld_structured r9.xyzw, r2.y, l(52), g0.xyzw
-  umin r6.xyzw, r6.xyzw, r8.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r6.xyzw
-  umax r6.xyzw, r7.xyzw, r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_nz r2.z
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r7.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r2.y, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r8.xyzw, r2.y, l(36), g0.xyzw
-  ld_structured r9.xyzw, r2.y, l(52), g0.xyzw
-  umin r6.xyzw, r6.xyzw, r8.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r6.xyzw
-  umax r6.xyzw, r7.xyzw, r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_nz r2.w
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r7.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r2.y, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r8.xyzw, r2.y, l(36), g0.xyzw
-  ld_structured r9.xyzw, r2.y, l(52), g0.xyzw
-  umin r6.xyzw, r6.xyzw, r8.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r6.xyzw
-  umax r6.xyzw, r7.xyzw, r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_nz r3.x
-  ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r7.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r2.y, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r8.xyzw, r2.y, l(36), g0.xyzw
-  ld_structured r9.xyzw, r2.y, l(52), g0.xyzw
-  umin r6.xyzw, r6.xyzw, r8.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r6.xyzw
-  umax r6.xyzw, r7.xyzw, r9.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r6.xyzw
-endif 
-sync_g_t
-if_z r0.z
-  ld_structured r4.xyzw, r0.y, l(36), g0.xyzw
-  ld_structured r5.xyzw, r0.y, l(52), g0.xyzw
-endif 
-if_nz r3.y
-  ieq r2.yzw, r0.wwww, l(0, 1, 4, 5)
-  ushr r3.x, r1.z, r0.z
-  and r3.x, r3.x, l(1)
-  ishl r3.y, r0.z, l(1)
-  ushr r6.x, r1.z, r3.y
-  iadd r3.y, r3.y, l(1)
-  ushr r6.y, r1.z, r3.y
-  and r3.yz, r6.xxyx, l(0, 1, 1, 0)
-  movc r3.xy, r2.yyyy, r3.xxxx, r3.yzyy
-  if_z r0.w
-    imad r6.xyz, r4.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-    ushr r6.xyz, r6.xyzx, l(16)
-    and r6.xyz, r6.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-    iadd r6.xyz, r3.xxxx, r6.xyzx
-    ishl r6.xyz, r6.xyzx, l(3)
-    ushr r7.xyz, r6.xyzx, l(5)
-    or r7.xyz, r6.xyzx, r7.xyzx
-    imad r8.xyz, r5.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-    ushr r8.xyz, r8.xyzx, l(16)
-    and r8.xyz, r8.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-    iadd r8.xyz, r3.yyyy, r8.xyzx
-    ishl r8.xyz, r8.xyzx, l(3)
-    ushr r9.xyz, r8.xyzx, l(5)
-    or r5.xyz, r8.xyzx, r9.xyzx
-    mov r5.w, l(255)
-    mov r4.xyw, l(255,2040,0,2040)
-  else 
-    if_nz r2.y
-      imad r9.xyz, r4.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-      ushr r9.xyz, r9.xyzx, l(16)
-      and r9.xyz, r9.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-      iadd r9.xyz, r3.xxxx, r9.xyzx
-      ishl r6.xyz, r9.xyzx, l(1)
-      ushr r9.xyz, r6.xyzx, l(7)
-      or r7.xyz, r6.xyzx, r9.xyzx
-      imad r9.xyz, r5.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-      ushr r9.xyz, r9.xyzx, l(16)
-      and r9.xyz, r9.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-      iadd r9.xyz, r3.yyyy, r9.xyzx
-      ishl r8.xyz, r9.xyzx, l(1)
-      ushr r9.xyz, r8.xyzx, l(7)
-      or r5.xyz, r8.xyzx, r9.xyzx
-      mov r5.w, l(255)
-      mov r4.xyw, l(255,510,0,510)
-    else 
-      ieq r2.y, r0.w, l(2)
-      if_nz r2.y
-        imad r9.xyz, r4.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-        ushr r9.xyz, r9.xyzx, l(16)
-        ishl r6.xyz, r9.xyzx, l(3)
-        ushr r9.xyz, r6.xyzx, l(5)
-        or r7.xyz, r6.xyzx, r9.xyzx
-        imad r9.xyz, r5.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-        ushr r9.xyz, r9.xyzx, l(16)
-        ishl r8.xyz, r9.xyzx, l(3)
-        ushr r9.xyz, r8.xyzx, l(5)
-        or r5.xyz, r8.xyzx, r9.xyzx
-        mov r5.w, l(255)
-        mov r4.xyw, l(255,2040,0,2040)
-      else 
-        ieq r2.y, r0.w, l(3)
-        if_nz r2.y
-          and r9.xyz, r4.xyzx, l(-2, -2, -2, 0)
-          iadd r6.xyz, r3.xxxx, r9.xyzx
-          and r9.xyz, r5.xyzx, l(-2, -2, -2, 0)
-          iadd r8.xyz, r3.yyyy, r9.xyzx
-          mov r7.xyz, r6.xyzx
-          mov r5.xyz, r8.xyzx
-          mov r5.w, l(255)
-          mov r4.xyw, l(255,255,0,255)
-        else 
-          ieq r2.y, r0.w, l(4)
-          if_nz r2.y
-            imad r9.xyzw, r4.xyzw, l(7967, 7967, 7967, 0x00003f3f), l(0x00008000, 0x00008000, 0x00008000, 0x00008000)
-            ushr r9.xyzw, r9.xyzw, l(16)
-            ishl r6.xyz, r9.xyzx, l(3)
-            ishl r6.w, r9.w, l(2)
-            ushr r9.xyz, r6.xyzx, l(5)
-            ushr r9.w, r6.w, l(6)
-            or r7.xyzw, r6.xyzw, r9.xyzw
-            imad r9.xyzw, r5.xyzw, l(7967, 7967, 7967, 0x00003f3f), l(0x00008000, 0x00008000, 0x00008000, 0x00008000)
-            ushr r9.xyzw, r9.xyzw, l(16)
-            ishl r4.xzw, r9.xxzy, l(3)
-            ishl r4.y, r9.w, l(2)
-            ushr r9.xyz, r4.xwzx, l(5)
-            ushr r9.w, r4.y, l(6)
-            or r5.xyzw, r4.xwzy, r9.xyzw
-            mov r8.xyz, r4.xwzx
-            mov r4.x, r7.w
-            mov r4.w, r6.w
-          else 
-            ieq r2.y, r0.w, l(5)
-            if_nz r2.y
-              imad r9.xyz, r4.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-              ushr r9.xyz, r9.xyzx, l(16)
-              ishl r6.xyz, r9.xyzx, l(1)
-              ushr r9.xyz, r6.xyzx, l(7)
-              or r7.xyz, r6.xyzx, r9.xyzx
-              imad r9.xyz, r5.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-              ushr r9.xyz, r9.xyzx, l(16)
-              ishl r8.xyz, r9.xyzx, l(1)
-              ushr r9.xyz, r8.xyzx, l(7)
-              or r5.xyz, r8.xyzx, r9.xyzx
-              mov r4.x, r4.w
-              mov r4.y, r5.w
-            else 
-              ieq r2.y, r0.w, l(6)
-              if_nz r2.y
-                and r9.xyzw, r4.xyzw, l(-2, -2, -2, -2)
-                iadd r6.xyzw, r3.xxxx, r9.xyzw
-                and r9.xyzw, r5.xyzw, l(-2, -2, -2, -2)
-                iadd r4.xyzw, r3.yyyy, r9.xwzy
-                mov r7.xyz, r6.xyzx
-                mov r5.xyzw, r4.xwzy
-                mov r8.xyz, r4.xwzx
-                mov r4.xw, r6.wwww
-              else 
-                imad r9.xyzw, r4.xyzw, l(0x00003f3f, 0x00003f3f, 0x00003f3f, 0x00003f3f), l(0x00008000, 0x00008000, 0x00008000, 0x00008000)
-                ushr r9.xyzw, r9.xyzw, l(16)
-                and r9.xyzw, r9.xyzw, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0x0000fffe)
-                iadd r9.xyzw, r3.xxxx, r9.xyzw
-                ishl r6.xyzw, r9.xyzw, l(2)
-                ushr r10.xyzw, r6.xyzw, l(6)
-                or r4.xyzw, r6.wxzy, r10.wxzy
-                imad r10.xyzw, r5.xyzw, l(0x00003f3f, 0x00003f3f, 0x00003f3f, 0x00003f3f), l(0x00008000, 0x00008000, 0x00008000, 0x00008000)
-                ushr r10.xyzw, r10.xyzw, l(16)
-                and r10.xyzw, r10.xyzw, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0x0000fffe)
-                iadd r10.xyzw, r3.yyyy, r10.xwyz
-                ishl r8.xyzw, r10.xzwy, l(2)
-                ushr r11.xyzw, r8.xyzw, l(6)
-                or r5.xyzw, r8.xyzw, r11.xyzw
-                mov r10.x, r9.w
-                ishl r3.xy, r10.xyxx, l(2)
-                mov r7.xyz, r4.ywzy
-                mov r4.yw, r3.yyyx
-              endif 
-            endif 
-          endif 
-        endif 
-      endif 
-    endif 
-  endif 
-  ineg r9.xyz, r7.xyzx
-  ineg r9.w, r4.x
-  iadd r10.xyzw, r5.xyzw, r9.xyzw
-  ult r2.y, r0.w, l(4)
-  movc r2.y, r2.y, l(0), r10.w
-  or r2.z, r2.w, r2.z
-  if_nz r2.z
-    if_z r0.z
-      imul null, r2.zw, r10.xxxy, r10.xxxy
-      iadd r2.z, r2.w, r2.z
-      imad r2.z, r10.z, r10.z, r2.z
-      imul null, r2.w, r2.y, r2.y
-      ld_structured r11.xyzw, r0.y, l(0), g0.xyzw
-      iadd r3.xyz, -r7.xyzx, r11.xyzx
-      imul null, r3.xy, r3.xyxx, r10.xyxx
-      iadd r3.x, r3.y, r3.x
-      imad r3.x, r10.z, r3.z, r3.x
-      iadd r3.y, -r4.x, r11.w
-      imul null, r3.y, r2.y, r3.y
-      ilt r3.z, l(0), r2.z
-      ilt r10.w, l(0), r3.x
-      and r3.z, r3.z, r10.w
-      itof r3.x, r3.x
-      mul r3.x, r3.x, l(63.499989)
-      ftou r3.x, r3.x
-      ishl r2.z, r2.z, l(5)
-      ult r2.z, r2.z, r3.x
-      and r2.z, r2.z, r3.z
-      movc r11.xyz, r2.zzzz, r5.xyzx, r7.xyzx
-      movc r5.xyz, r2.zzzz, r7.xyzx, r5.xyzx
-      movc r12.xyz, r2.zzzz, r8.xyzx, r6.xyzx
-      movc r8.xyz, r2.zzzz, r6.xyzx, r8.xyzx
-      ilt r2.z, l(0), r2.w
-      ilt r3.x, l(0), r3.y
-      and r2.z, r2.z, r3.x
-      itof r3.x, r3.y
-      mul r3.x, r3.x, l(63.499989)
-      ftou r3.x, r3.x
-      ishl r2.w, r2.w, l(5)
-      ult r2.w, r2.w, r3.x
-      and r2.z, r2.w, r2.z
-      mov r4.z, r5.w
-      movc r13.xyzw, r2.zzzz, r4.zxyw, r4.xzwy
-      mov r11.w, r13.x
-      mov r5.w, r13.y
-      mov r12.w, r13.z
-      mov r6.xyzw, r12.xyzw
-      mov r8.w, r13.w
-    else 
-      mov r7.w, r4.x
-      mov r11.xyzw, r7.xyzw
-      mov r6.w, r4.w
-      mov r8.w, r4.y
-    endif 
-  else 
-    if_z r0.z
-      mov r2.z, l(0)
-    else 
-      if_nz r3.w
-        mov r2.z, icb[r1.y + 0].z
-      else 
-        mov r2.z, icb[r1.y + 0].w
-      endif 
-    endif 
-    imul null, r3.xy, r10.xyxx, r10.xyxx
-    iadd r2.w, r3.y, r3.x
-    imad r2.w, r10.z, r10.z, r2.w
-    imad r2.w, r2.y, r2.y, r2.w
-    iadd r2.z, r0.y, r2.z
-    ld_structured r3.xyzw, r2.z, l(0), g0.xyzw
-    iadd r3.xyzw, r9.xyzw, r3.xyzw
-    imul null, r3.xy, r3.xyxx, r10.xyxx
-    iadd r2.z, r3.y, r3.x
-    imad r2.z, r10.z, r3.z, r2.z
-    imad r2.y, r2.y, r3.w, r2.z
-    ilt r2.z, l(0), r2.w
-    ilt r3.x, l(0), r2.y
-    and r2.z, r2.z, r3.x
-    itof r2.y, r2.y
-    mul r2.y, r2.y, l(63.499989)
-    ftou r2.y, r2.y
-    ishl r2.w, r2.w, l(5)
-    ult r2.y, r2.w, r2.y
-    and r2.y, r2.y, r2.z
-    mov r7.w, r4.x
-    movc r11.xyzw, r2.yyyy, r5.xyzw, r7.xyzw
-    movc r5.xyzw, r2.yyyy, r7.xyzw, r5.xyzw
-    mov r8.w, r4.y
-    mov r4.xyz, r6.xyzx
-    movc r6.xyzw, r2.yyyy, r8.xyzw, r4.xyzw
-    movc r8.xyzw, r2.yyyy, r4.xyzw, r8.xyzw
-  endif 
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r11.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r5.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(68), r6.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(84), r8.xyzw
-endif 
-sync_g_t
-if_nz r2.x
-  ieq r2.xyzw, r0.wwww, l(0, 1, 6, 4)
-  or r3.x, r2.y, r2.x
-  movc r3.yz, r1.xxxx, l(0,1,2,0), l(0,2,1,0)
-  movc r3.yz, r2.wwww, r3.yyzy, l(0,2,2,0)
-  movc r3.yz, r2.zzzz, l(0,0,0,0), r3.yyzy
-  movc r3.xy, r3.xxxx, l(1,1,0,0), r3.yzyy
-  ieq r4.xyzw, r0.wwww, l(2, 3, 7, 5)
-  ishl r2.z, r0.z, l(1)
-  ushr r1.w, icb[r1.w + 0].y, r2.z
-  and r1.w, r1.w, l(3)
-  or r2.xyz, r2.xywx, r4.xywx
-  or r2.y, r4.z, r2.y
-  ushr r2.w, icb[r1.y + 0].x, r0.z
-  and r2.y, r2.y, r2.w
-  and r2.y, r2.y, l(1)
-  movc r1.w, r2.x, r1.w, r2.y
-  iadd r1.w, r0.y, r1.w
-  ld_structured r4.xyzw, r1.w, l(36), g0.xyzw
-  ld_structured r5.xyzw, r1.w, l(52), g0.xyzw
-  iadd r5.xyzw, -r4.xyzw, r5.xyzw
-  ult r1.w, r0.w, l(4)
-  movc r1.w, r1.w, l(0), r5.w
-  if_nz r2.z
-    imul null, r2.xy, r5.xyxx, r5.xyxx
-    iadd r2.x, r2.y, r2.x
-    imad r2.x, r5.z, r5.z, r2.x
-    imul null, r2.y, r1.w, r1.w
-    ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(0), g0.xyzw
-    iadd r7.xyzw, -r4.xyzw, r6.xyzw
-    imul null, r2.zw, r5.xxxy, r7.xxxy
-    iadd r2.z, r2.w, r2.z
-    imad r2.z, r5.z, r7.z, r2.z
-    ige r2.w, l(0), r2.x
-    ige r3.z, l(0), r2.z
-    or r2.w, r2.w, r3.z
-    ilt r3.z, r2.z, r2.x
-    itof r2.xz, r2.xxzx
-    mul r2.z, r2.z, l(63.499989)
-    div r2.x, r2.z, r2.x
-    ftou r2.x, r2.x
-    ishl r3.yw, r3.xxxy, l(6)
-    iadd r2.x, r2.x, r3.y
-    iadd r6.xy, r3.ywyy, l(11, 11, 0, 0)
-    udiv null, r6.xy, r6.xyxx, l(68, 68, 0, 0)
-    ult r7.xy, r3.ywyy, l(1, 1, 0, 0)
-    movc r6.xy, r7.xyxx, l(15,15,0,0), r6.xyxx
-    movc r2.x, r3.z, icb[r2.x + 64].x, r6.x
-    movc r7.y, r2.w, l(0), r2.x
-    imul null, r2.x, r1.w, r7.w
-    ige r2.zw, l(0, 0, 0, 0), r2.yyyx
-    or r2.z, r2.w, r2.z
-    ilt r2.w, r2.x, r2.y
-    itof r2.xy, r2.xyxx
-    mul r2.x, r2.x, l(63.499989)
-    div r2.x, r2.x, r2.y
-    ftou r2.x, r2.x
-    iadd r2.x, r2.x, r3.w
-    movc r2.x, r2.w, icb[r2.x + 64].x, r6.y
-    movc r7.x, r2.z, l(0), r2.x
-    movc r2.xy, r1.xxxx, r7.xyxx, r7.yxyy
-  else 
-    imul null, r2.zw, r5.xxxy, r5.xxxy
-    iadd r2.z, r2.w, r2.z
-    imad r2.z, r5.z, r5.z, r2.z
-    imad r2.z, r1.w, r1.w, r2.z
-    ld_structured r6.xyzw, vThreadIDInGroupFlattened.x, l(0), g0.xyzw
-    iadd r4.xyzw, -r4.xyzw, r6.xyzw
-    imul null, r3.yz, r4.xxyx, r5.xxyx
-    iadd r2.w, r3.z, r3.y
-    imad r2.w, r5.z, r4.z, r2.w
-    imad r1.w, r1.w, r4.w, r2.w
-    ige r2.w, l(0), r2.z
-    ige r3.y, l(0), r1.w
-    or r2.w, r2.w, r3.y
-    ilt r3.y, r1.w, r2.z
-    itof r1.w, r1.w
-    mul r1.w, r1.w, l(63.499989)
-    itof r2.z, r2.z
-    div r1.w, r1.w, r2.z
-    ftou r1.w, r1.w
-    ishl r2.z, r3.x, l(6)
-    iadd r1.w, r1.w, r2.z
-    iadd r3.x, r2.z, l(11)
-    udiv null, r3.x, r3.x, l(68)
-    ult r2.z, r2.z, l(1)
-    movc r2.z, r2.z, l(15), r3.x
-    movc r1.w, r3.y, icb[r1.w + 64].x, r2.z
-    movc r2.x, r2.w, l(0), r1.w
-    mov r2.y, l(0)
-  endif 
-  store_structured g0.xy, vThreadIDInGroupFlattened.x, l(16), r2.xyxx
-endif 
-sync_g_t
-if_z r0.z
-  if_z r0.w
-    ishl r0.z, r1.y, l(1)
-    iadd r0.z, r0.z, l(-128)
-    iadd r0.z, r0.z, l(1)
-    ld_structured r2.xyz, r0.y, l(68), g0.xyzx
-    ishl r3.x, r2.x, l(1)
-    ishl r3.y, r2.y, l(25)
-    ishl r3.z, r2.z, l(17)
-    and r3.xyz, r3.xyzx, l(480, 0xe0000000, 0x01e00000, 0)
-    or r0.z, r0.z, r3.x
-    ld_structured r4.xyz, r0.y, l(84), g0.xyzx
-    ishl r5.x, r4.x, l(5)
-    ishl r5.y, r4.z, l(21)
-    and r2.xw, r5.xxxy, l(7680, 0, 0, 0x1e000000)
-    or r0.z, r0.z, r2.x
-    iadd r3.xw, r0.yyyy, l(1, 0, 0, 2)
-    ld_structured r5.xyz, r3.x, l(68), g0.xyzx
-    ishl r6.x, r5.x, l(9)
-    ishl r6.y, r5.y, l(1)
-    ishl r6.z, r5.z, l(25)
-    and r6.xyz, r6.xyzx, l(0x0001e000, 480, 0xe0000000, 0)
-    or r0.z, r0.z, r6.x
-    ld_structured r7.xyz, r3.x, l(84), g0.xyzx
-    ishl r8.x, r7.x, l(13)
-    ishl r8.y, r7.y, l(5)
-    and r4.xw, r8.xxxy, l(0x001e0000, 0, 0, 7680)
-    or r0.z, r0.z, r4.x
-    ld_structured r8.xyz, r3.w, l(68), g0.xyzx
-    ishl r9.x, r8.x, l(17)
-    ishl r9.y, r8.y, l(9)
-    ishl r9.z, r8.z, l(1)
-    and r9.xyz, r9.xyzx, l(0x01e00000, 0x0001e000, 480, 0)
-    or r0.z, r0.z, r9.x
-    ld_structured r10.xyz, r3.w, l(84), g0.xyzx
-    ishl r11.x, r10.x, l(21)
-    ishl r11.y, r10.y, l(13)
-    ishl r11.z, r10.z, l(5)
-    and r11.xyz, r11.xyzx, l(0x1e000000, 0x001e0000, 7680, 0)
-    or r0.z, r0.z, r11.x
-    or r12.x, r3.y, r0.z
-    ld_structured r13.xy, r0.y, l(68), g0.xyxx
-    ushr r0.z, r13.y, l(7)
-    and r0.z, r0.z, l(1)
-    ushr r1.w, r4.y, l(3)
-    and r1.w, r1.w, l(30)
-    iadd r0.z, r0.z, r1.w
-    iadd r0.z, r6.y, r0.z
-    iadd r0.z, r4.w, r0.z
-    iadd r0.z, r9.y, r0.z
-    iadd r0.z, r11.y, r0.z
-    iadd r0.z, r3.z, r0.z
-    iadd r0.z, r2.w, r0.z
-    iadd r12.y, r6.z, r0.z
-    ld_structured r2.x, r3.x, l(76), g0.xxxx
-    ushr r0.z, r2.x, l(7)
-    and r0.z, r0.z, l(1)
-    ushr r1.w, r7.z, l(3)
-    and r1.w, r1.w, l(30)
-    iadd r0.z, r0.z, r1.w
-    iadd r0.z, r9.z, r0.z
-    iadd r0.z, r11.z, r0.z
-    ishl r1.w, r13.x, l(10)
-    and r1.w, r1.w, l(8192)
-    iadd r0.z, r0.z, r1.w
-    ld_structured r2.x, r0.y, l(84), g0.xxxx
-    ishl r1.w, r2.x, l(11)
-    and r1.w, r1.w, l(0x00004000)
-    iadd r0.z, r0.z, r1.w
-    ld_structured r2.x, r3.x, l(68), g0.xxxx
-    ishl r1.w, r2.x, l(12)
-    and r1.w, r1.w, l(0x00008000)
-    iadd r0.z, r0.z, r1.w
-    ld_structured r2.x, r3.x, l(84), g0.xxxx
-    ishl r1.w, r2.x, l(13)
-    and r1.w, r1.w, l(0x00010000)
-    iadd r0.z, r0.z, r1.w
-    ld_structured r2.x, r3.w, l(68), g0.xxxx
-    ishl r1.w, r2.x, l(14)
-    and r1.w, r1.w, l(0x00020000)
-    iadd r0.z, r0.z, r1.w
-    ld_structured r2.x, r3.w, l(84), g0.xxxx
-    ishl r1.w, r2.x, l(15)
-    and r1.w, r1.w, l(0x00040000)
-    iadd r0.z, r0.z, r1.w
-    ld_structured r2.x, r0.y, l(16), g0.xxxx
-    ishl r1.w, r2.x, l(19)
-    iadd r0.z, r0.z, r1.w
-    umin r1.w, l(4), icb[r1.y + 128].y
-    mov r12.z, r0.z
-    mov r2.x, l(1)
-    loop 
-      ult r2.y, r1.w, r2.x
-      breakc_nz r2.y
-      iadd r2.y, r0.y, r2.x
-      ld_structured r3.x, r2.y, l(16), g0.xxxx
-      imad r2.y, r2.x, l(3), l(18)
-      ishl r2.y, r3.x, r2.y
-      or r12.z, r2.y, r12.z
-      iadd r2.x, r2.x, l(1)
-    endloop 
-    ult r0.z, icb[r1.y + 128].y, l(4)
-    if_nz r0.z
-      iadd r0.z, r0.y, l(4)
-      ld_structured r3.x, r0.z, l(16), g0.xxxx
-      ishl r0.z, r3.x, l(29)
-      or r12.z, r0.z, r12.z
-      iadd r2.z, r2.x, l(1)
-      mov r2.y, l(0)
-    else 
-      iadd r0.z, r0.y, l(4)
-      ld_structured r3.x, r0.z, l(16), g0.xxxx
-      ushr r0.z, r3.x, l(2)
-      and r0.z, r0.z, l(1)
-      mov r2.y, r0.z
-      mov r2.z, r2.x
-      loop 
-        ult r1.w, icb[r1.y + 128].y, r2.z
-        breakc_nz r1.w
-        iadd r1.w, r0.y, r2.z
-        ld_structured r3.x, r1.w, l(16), g0.xxxx
-        imad r1.w, r2.z, l(3), l(-14)
-        ishl r1.w, r3.x, r1.w
-        or r2.y, r1.w, r2.y
-        iadd r2.z, r2.z, l(1)
-      endloop 
-    endif 
-    mov r0.z, r2.y
-    mov r1.w, r2.z
-    loop 
-      ult r2.x, icb[r1.y + 128].z, r1.w
-      breakc_nz r2.x
-      iadd r2.x, r0.y, r1.w
-      ld_structured r3.x, r2.x, l(16), g0.xxxx
-      imad r2.x, r1.w, l(3), l(-15)
-      ishl r2.x, r3.x, r2.x
-      or r0.z, r0.z, r2.x
-      iadd r1.w, r1.w, l(1)
-    endloop 
-    mov r12.w, r0.z
-    mov r2.x, r1.w
-    loop 
-      uge r2.y, r2.x, l(16)
-      breakc_nz r2.y
-      iadd r2.y, r0.y, r2.x
-      ld_structured r3.x, r2.y, l(16), g0.xxxx
-      imad r2.y, r2.x, l(3), l(-16)
-      ishl r2.y, r3.x, r2.y
-      or r12.w, r2.y, r12.w
-      iadd r2.x, r2.x, l(1)
-    endloop 
-  else 
-    ieq r0.z, r0.w, l(1)
-    if_nz r0.z
-      ishl r0.z, r1.y, l(2)
-      iadd r0.z, r0.z, l(2)
-      ld_structured r2.xyz, r0.y, l(68), g0.xyzx
-      ishl r3.x, r2.x, l(6)
-      ishl r3.y, r2.z, l(22)
-      and r2.xz, r3.xxyx, l(0x00003f00, 0, 0x3f000000, 0)
-      or r0.z, r0.z, r2.x
-      ld_structured r3.xyz, r0.y, l(84), g0.xyzx
-      ishl r4.x, r3.x, l(12)
-      ishl r4.y, r3.y, l(4)
-      ishl r4.z, r3.z, l(28)
-      and r3.xyz, r4.xyzx, l(0x000fc000, 4032, 0xc0000000, 0)
-      or r0.z, r0.z, r3.x
-      iadd r1.w, r0.y, l(1)
-      ld_structured r4.xyz, r1.w, l(68), g0.xyzx
-      ishl r5.x, r4.x, l(18)
-      ishl r5.y, r4.y, l(10)
-      ishl r5.z, r4.z, l(2)
-      and r4.xyz, r5.xyzx, l(0x03f00000, 0x0003f000, 1008, 0)
-      or r0.z, r0.z, r4.x
-      ld_structured r5.xyz, r1.w, l(84), g0.xyzx
-      ishl r6.x, r5.x, l(24)
-      ishl r6.y, r5.y, l(16)
-      ishl r6.z, r5.z, l(8)
-      and r5.xyz, r6.xyzx, l(0xfc000000, 0x00fc0000, 0x0000fc00, 0)
-      or r12.x, r0.z, r5.x
-      ushr r0.z, r2.y, l(2)
-      and r0.z, r0.z, l(63)
-      iadd r0.z, r3.y, r0.z
-      iadd r0.z, r4.y, r0.z
-      iadd r0.z, r5.y, r0.z
-      iadd r0.z, r2.z, r0.z
-      iadd r12.y, r3.z, r0.z
-      ld_structured r2.x, r0.y, l(92), g0.xxxx
-      ushr r0.z, r2.x, l(4)
-      and r0.z, r0.z, l(15)
-      iadd r0.z, r4.z, r0.z
-      iadd r0.z, r5.z, r0.z
-      ld_structured r2.x, r0.y, l(68), g0.xxxx
-      ishl r2.x, r2.x, l(15)
-      and r2.x, r2.x, l(0x00010000)
-      iadd r0.z, r0.z, r2.x
-      ld_structured r2.x, r1.w, l(68), g0.xxxx
-      ishl r2.x, r2.x, l(16)
-      and r2.x, r2.x, l(0x00020000)
-      iadd r0.z, r0.z, r2.x
-      ld_structured r2.x, r0.y, l(16), g0.xxxx
-      ishl r2.x, r2.x, l(18)
-      iadd r0.z, r0.z, r2.x
-      ieq r2.y, l(15), icb[r1.y + 128].y
-      if_nz r2.y
-        iadd r3.xyzw, r0.yyyy, l(15, 14, 13, 12)
-        ld_structured r4.x, r3.x, l(16), g0.xxxx
-        ishl r2.y, r4.x, l(30)
-        ld_structured r4.x, r3.y, l(16), g0.xxxx
-        ishl r2.z, r4.x, l(27)
-        or r2.y, r2.z, r2.y
-        ld_structured r4.x, r3.z, l(16), g0.xxxx
-        ishl r2.z, r4.x, l(24)
-        or r2.y, r2.z, r2.y
-        ld_structured r3.x, r3.w, l(16), g0.xxxx
-        ishl r2.z, r3.x, l(21)
-        or r2.y, r2.z, r2.y
-        iadd r3.xyzw, r0.yyyy, l(11, 10, 9, 8)
-        ld_structured r4.x, r3.x, l(16), g0.xxxx
-        ishl r2.z, r4.x, l(18)
-        or r2.y, r2.z, r2.y
-        ld_structured r4.x, r3.y, l(16), g0.xxxx
-        ishl r2.z, r4.x, l(15)
-        or r2.y, r2.z, r2.y
-        ld_structured r4.x, r3.z, l(16), g0.xxxx
-        ishl r2.z, r4.x, l(12)
-        or r2.y, r2.z, r2.y
-        ld_structured r3.x, r3.w, l(16), g0.xxxx
-        ishl r2.z, r3.x, l(9)
-        or r2.y, r2.z, r2.y
-        iadd r3.xyzw, r0.yyyy, l(7, 6, 5, 4)
-        ld_structured r4.x, r3.x, l(16), g0.xxxx
-        ishl r2.z, r4.x, l(6)
-        or r2.y, r2.z, r2.y
-        ld_structured r4.x, r3.y, l(16), g0.xxxx
-        ishl r2.z, r4.x, l(3)
-        or r2.y, r2.z, r2.y
-        ld_structured r4.x, r3.z, l(16), g0.xxxx
-        or r12.w, r2.y, r4.x
-        ld_structured r3.x, r3.w, l(16), g0.xxxx
-        ishl r2.y, r3.x, l(29)
-        iadd r2.zw, r0.yyyy, l(0, 0, 3, 2)
-        ld_structured r3.x, r2.z, l(16), g0.xxxx
-        ishl r2.z, r3.x, l(26)
-        or r2.y, r2.z, r2.y
-        ld_structured r3.x, r2.w, l(16), g0.xxxx
-        ishl r2.z, r3.x, l(23)
-        or r2.y, r2.z, r2.y
-        ld_structured r3.x, r1.w, l(16), g0.xxxx
-        ishl r2.z, r3.x, l(20)
-        or r2.y, r2.z, r2.y
-        or r2.y, r2.x, r2.y
-        or r12.z, r0.z, r2.y
-      else 
-        ieq r2.y, l(2), icb[r1.y + 128].y
-        if_nz r2.y
-          iadd r3.xyzw, r0.yyyy, l(15, 14, 13, 12)
-          ld_structured r4.x, r3.x, l(16), g0.xxxx
-          ishl r2.y, r4.x, l(29)
-          ld_structured r4.x, r3.y, l(16), g0.xxxx
-          ishl r2.z, r4.x, l(26)
-          or r2.y, r2.z, r2.y
-          ld_structured r4.x, r3.z, l(16), g0.xxxx
-          ishl r2.z, r4.x, l(23)
-          or r2.y, r2.z, r2.y
-          ld_structured r3.x, r3.w, l(16), g0.xxxx
-          ishl r2.z, r3.x, l(20)
-          or r2.y, r2.z, r2.y
-          iadd r3.xyzw, r0.yyyy, l(11, 10, 9, 8)
-          ld_structured r4.x, r3.x, l(16), g0.xxxx
-          ishl r2.z, r4.x, l(17)
-          or r2.y, r2.z, r2.y
-          ld_structured r4.x, r3.y, l(16), g0.xxxx
-          ishl r2.z, r4.x, l(14)
-          or r2.y, r2.z, r2.y
-          ld_structured r4.x, r3.z, l(16), g0.xxxx
-          ishl r2.z, r4.x, l(11)
-          or r2.y, r2.z, r2.y
-          ld_structured r3.x, r3.w, l(16), g0.xxxx
-          ishl r2.z, r3.x, l(8)
-          or r2.y, r2.z, r2.y
-          iadd r3.xyzw, r0.yyyy, l(7, 6, 5, 4)
-          ld_structured r4.x, r3.x, l(16), g0.xxxx
-          ishl r2.z, r4.x, l(5)
-          or r2.y, r2.z, r2.y
-          ld_structured r4.x, r3.y, l(16), g0.xxxx
-          ishl r2.z, r4.x, l(2)
-          or r2.y, r2.z, r2.y
-          ld_structured r4.x, r3.z, l(16), g0.xxxx
-          ushr r2.z, r4.x, l(1)
-          or r12.w, r2.z, r2.y
-          ishl r2.y, r4.x, l(31)
-          ld_structured r3.x, r3.w, l(16), g0.xxxx
-          ishl r2.z, r3.x, l(28)
-          or r2.y, r2.z, r2.y
-          iadd r2.zw, r0.yyyy, l(0, 0, 3, 2)
-          ld_structured r3.x, r2.z, l(16), g0.xxxx
-          ishl r2.z, r3.x, l(25)
-          or r2.y, r2.z, r2.y
-          ld_structured r3.x, r2.w, l(16), g0.xxxx
-          ishl r2.z, r3.x, l(23)
-          or r2.y, r2.z, r2.y
-          ld_structured r3.x, r1.w, l(16), g0.xxxx
-          ishl r2.z, r3.x, l(20)
-          or r2.y, r2.z, r2.y
-          or r2.y, r2.x, r2.y
-          or r12.z, r0.z, r2.y
-        else 
-          ieq r2.y, l(8), icb[r1.y + 128].y
-          if_nz r2.y
-            iadd r3.xyzw, r0.yyyy, l(15, 14, 13, 12)
-            ld_structured r4.x, r3.x, l(16), g0.xxxx
-            ishl r2.y, r4.x, l(29)
-            ld_structured r4.x, r3.y, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(26)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.z, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(23)
-            or r2.y, r2.z, r2.y
-            ld_structured r3.x, r3.w, l(16), g0.xxxx
-            ishl r2.z, r3.x, l(20)
-            or r2.y, r2.z, r2.y
-            iadd r3.xyzw, r0.yyyy, l(11, 10, 9, 8)
-            ld_structured r4.x, r3.x, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(17)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.y, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(14)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.z, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(11)
-            or r2.y, r2.z, r2.y
-            ld_structured r3.x, r3.w, l(16), g0.xxxx
-            ishl r2.z, r3.x, l(9)
-            or r2.y, r2.z, r2.y
-            iadd r3.xyzw, r0.yyyy, l(7, 6, 5, 4)
-            ld_structured r4.x, r3.x, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(6)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.y, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(3)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.z, l(16), g0.xxxx
-            or r12.w, r2.y, r4.x
-            ld_structured r3.x, r3.w, l(16), g0.xxxx
-            ishl r2.y, r3.x, l(29)
-            iadd r2.zw, r0.yyyy, l(0, 0, 3, 2)
-            ld_structured r3.x, r2.z, l(16), g0.xxxx
-            ishl r2.z, r3.x, l(26)
-            or r2.y, r2.z, r2.y
-            ld_structured r3.x, r2.w, l(16), g0.xxxx
-            ishl r2.z, r3.x, l(23)
-            or r2.y, r2.z, r2.y
-            ld_structured r3.x, r1.w, l(16), g0.xxxx
-            ishl r2.z, r3.x, l(20)
-            or r2.y, r2.z, r2.y
-            or r2.y, r2.x, r2.y
-            or r12.z, r0.z, r2.y
-          else 
-            iadd r3.xyzw, r0.yyyy, l(15, 14, 13, 12)
-            ld_structured r4.x, r3.x, l(16), g0.xxxx
-            ishl r2.y, r4.x, l(29)
-            ld_structured r4.x, r3.y, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(26)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.z, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(23)
-            or r2.y, r2.z, r2.y
-            ld_structured r3.x, r3.w, l(16), g0.xxxx
-            ishl r2.z, r3.x, l(20)
-            or r2.y, r2.z, r2.y
-            iadd r3.xyzw, r0.yyyy, l(11, 10, 9, 8)
-            ld_structured r4.x, r3.x, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(17)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.y, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(14)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.z, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(11)
-            or r2.y, r2.z, r2.y
-            ld_structured r3.x, r3.w, l(16), g0.xxxx
-            ishl r2.z, r3.x, l(8)
-            or r2.y, r2.z, r2.y
-            iadd r3.xyzw, r0.yyyy, l(7, 6, 5, 4)
-            ld_structured r4.x, r3.x, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(5)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.y, l(16), g0.xxxx
-            ishl r2.z, r4.x, l(3)
-            or r2.y, r2.z, r2.y
-            ld_structured r4.x, r3.z, l(16), g0.xxxx
-            or r12.w, r2.y, r4.x
-            ld_structured r3.x, r3.w, l(16), g0.xxxx
-            ishl r2.y, r3.x, l(29)
-            iadd r2.zw, r0.yyyy, l(0, 0, 3, 2)
-            ld_structured r3.x, r2.z, l(16), g0.xxxx
-            ishl r2.z, r3.x, l(26)
-            or r2.y, r2.z, r2.y
-            ld_structured r3.x, r2.w, l(16), g0.xxxx
-            ishl r2.z, r3.x, l(23)
-            or r2.y, r2.z, r2.y
-            ld_structured r3.x, r1.w, l(16), g0.xxxx
-            ishl r1.w, r3.x, l(20)
-            or r1.w, r1.w, r2.y
-            or r1.w, r2.x, r1.w
-            or r12.z, r0.z, r1.w
-          endif 
-        endif 
-      endif 
-    else 
-      ieq r0.z, r0.w, l(2)
-      if_nz r0.z
-        ishl r0.z, r1.y, l(3)
-        iadd r0.z, r0.z, l(-512)
-        iadd r0.z, r0.z, l(4)
-        ld_structured r2.xyz, r0.y, l(68), g0.xyzx
-        ishl r3.x, r2.x, l(6)
-        ishl r3.y, r2.y, l(4)
-        ishl r3.z, r2.z, l(2)
-        and r3.xyz, r3.xyzx, l(0x00003e00, 3968, 992, 0)
-        or r0.z, r0.z, r3.x
-        ld_structured r4.xyz, r0.y, l(84), g0.xyzx
-        ishl r5.x, r4.x, l(11)
-        ishl r5.y, r4.y, l(9)
-        ishl r5.z, r4.z, l(7)
-        and r5.xyz, r5.xyzx, l(0x0007c000, 0x0001f000, 0x00007c00, 0)
-        or r0.z, r0.z, r5.x
-        iadd r2.xw, r0.yyyy, l(1, 0, 0, 2)
-        ld_structured r6.xyz, r2.x, l(68), g0.xyzx
-        ishl r7.x, r6.x, l(16)
-        ishl r7.y, r6.y, l(14)
-        ishl r7.z, r6.z, l(12)
-        and r7.xyz, r7.xyzx, l(0x00f80000, 0x003e0000, 0x000f8000, 0)
-        or r0.z, r0.z, r7.x
-        ld_structured r8.xyz, r2.x, l(84), g0.xyzx
-        ishl r9.x, r8.x, l(21)
-        ishl r9.y, r8.y, l(19)
-        ishl r9.z, r8.z, l(17)
-        and r9.xyz, r9.xyzx, l(0x1f000000, 0x07c00000, 0x01f00000, 0)
-        or r0.z, r0.z, r9.x
-        ld_structured r10.xyz, r2.w, l(68), g0.xyzx
-        ishl r11.x, r10.x, l(26)
-        ishl r11.y, r10.y, l(24)
-        ishl r11.z, r10.z, l(22)
-        and r11.xyz, r11.xyzx, l(0xe0000000, 0xf8000000, 0x3e000000, 0)
-        or r12.x, r0.z, r11.x
-        ld_structured r13.x, r2.w, l(68), g0.xxxx
-        ushr r0.z, r13.x, l(6)
-        and r0.z, r0.z, l(3)
-        ld_structured r13.xyz, r2.w, l(84), g0.xyzx
-        ushr r14.x, r13.x, l(1)
-        ushr r14.y, r13.y, l(3)
-        and r3.xw, r14.xxxy, l(124, 0, 0, 31)
-        iadd r0.z, r0.z, r3.x
-        iadd r0.z, r3.y, r0.z
-        iadd r0.z, r5.y, r0.z
-        iadd r0.z, r7.y, r0.z
-        iadd r0.z, r9.y, r0.z
-        iadd r12.y, r11.y, r0.z
-        iadd r0.z, r3.z, r3.w
-        iadd r0.z, r5.z, r0.z
-        iadd r0.z, r7.z, r0.z
-        iadd r0.z, r9.z, r0.z
-        iadd r0.z, r11.z, r0.z
-        ishl r1.w, r13.z, l(27)
-        and r1.w, r1.w, l(0xc0000000)
-        iadd r12.z, r0.z, r1.w
-        ld_structured r2.x, r2.w, l(92), g0.xxxx
-        ushr r0.z, r2.x, l(5)
-        and r0.z, r0.z, l(7)
-        ld_structured r2.x, r0.y, l(16), g0.xxxx
-        ishl r1.w, r2.x, l(3)
-        iadd r0.z, r0.z, r1.w
-        mov r1.w, r0.z
-        mov r2.x, l(1)
-        loop 
-          ult r2.y, icb[r1.y + 128].y, r2.x
-          breakc_nz r2.y
-          iadd r2.y, r0.y, r2.x
-          ld_structured r3.x, r2.y, l(16), g0.xxxx
-          ishl r2.y, r2.x, l(1)
-          iadd r2.y, r2.y, l(2)
-          ishl r2.y, r3.x, r2.y
-          or r1.w, r1.w, r2.y
-          iadd r2.x, r2.x, l(1)
-        endloop 
-        mov r0.z, r1.w
-        mov r2.y, r2.x
-        loop 
-          ult r2.z, icb[r1.y + 128].z, r2.y
-          breakc_nz r2.z
-          iadd r2.z, r0.y, r2.y
-          ld_structured r3.x, r2.z, l(16), g0.xxxx
-          ishl r2.z, r2.y, l(1)
-          iadd r2.z, r2.z, l(1)
-          ishl r2.z, r3.x, r2.z
-          or r0.z, r0.z, r2.z
-          iadd r2.y, r2.y, l(1)
-        endloop 
-        mov r12.w, r0.z
-        mov r1.w, r2.y
-        loop 
-          uge r2.x, r1.w, l(16)
-          breakc_nz r2.x
-          iadd r2.x, r0.y, r1.w
-          ld_structured r3.x, r2.x, l(16), g0.xxxx
-          ishl r2.x, r1.w, l(1)
-          ishl r2.x, r3.x, r2.x
-          or r12.w, r2.x, r12.w
-          iadd r1.w, r1.w, l(1)
-        endloop 
-      else 
-        ieq r0.z, r0.w, l(3)
-        if_nz r0.z
-          ishl r0.z, r1.y, l(4)
-          iadd r0.z, r0.z, l(8)
-          ld_structured r2.xyz, r0.y, l(68), g0.xyzx
-          ishl r3.x, r2.x, l(9)
-          ishl r3.y, r2.y, l(5)
-          ishl r3.z, r2.z, l(1)
-          and r3.xyz, r3.xyzx, l(0x0001fc00, 8128, 508, 0)
-          or r0.z, r0.z, r3.x
-          ld_structured r4.xyz, r0.y, l(84), g0.xyzx
-          ishl r5.x, r4.x, l(16)
-          ishl r5.y, r4.y, l(12)
-          ishl r5.z, r4.z, l(8)
-          and r5.xyz, r5.xyzx, l(0x00fe0000, 0x000fe000, 0x0000fe00, 0)
-          or r0.z, r0.z, r5.x
-          iadd r1.w, r0.y, l(1)
-          ld_structured r6.xyz, r1.w, l(68), g0.xyzx
-          ishl r7.x, r6.x, l(23)
-          ishl r7.y, r6.y, l(19)
-          ishl r7.z, r6.z, l(15)
-          and r7.xyz, r7.xyzx, l(0x7f000000, 0x07f00000, 0x007f0000, 0)
-          or r0.z, r0.z, r7.x
-          ld_structured r8.xyz, r1.w, l(84), g0.xyzx
-          ishl r9.x, r8.x, l(30)
-          ishl r9.y, r8.y, l(26)
-          ishl r9.z, r8.z, l(22)
-          and r9.xyz, r9.xyzx, l(0x80000000, 0xf8000000, 0x3f800000, 0)
-          or r12.x, r0.z, r9.x
-          ld_structured r10.xy, r1.w, l(84), g0.xyxx
-          ushr r11.x, r10.x, l(2)
-          ushr r11.y, r10.y, l(6)
-          and r2.xw, r11.xxxy, l(63, 0, 0, 3)
-          iadd r2.xy, r3.yzyy, r2.xwxx
-          iadd r2.xy, r5.yzyy, r2.xyxx
-          iadd r2.xy, r7.yzyy, r2.xyxx
-          iadd r2.xy, r9.yzyy, r2.xyxx
-          ld_structured r3.x, r0.y, l(68), g0.xxxx
-          ishl r0.z, r3.x, l(30)
-          and r0.z, r0.z, l(0x40000000)
-          iadd r0.z, r0.z, r2.y
-          ld_structured r3.x, r0.y, l(84), g0.xxxx
-          ishl r2.y, r3.x, l(31)
-          iadd r12.z, r0.z, r2.y
-          ld_structured r3.x, r1.w, l(68), g0.xxxx
-          and r0.z, r3.x, l(1)
-          ld_structured r3.x, r1.w, l(84), g0.xxxx
-          ishl r1.w, r3.x, l(1)
-          and r1.w, r1.w, l(2)
-          iadd r0.z, r0.z, r1.w
-          ld_structured r3.x, r0.y, l(16), g0.xxxx
-          ishl r1.w, r3.x, l(2)
-          iadd r0.z, r0.z, r1.w
-          mov r1.w, r0.z
-          mov r2.y, l(1)
-          loop 
-            ult r2.z, icb[r1.y + 128].y, r2.y
-            breakc_nz r2.z
-            iadd r2.z, r0.y, r2.y
-            ld_structured r3.x, r2.z, l(16), g0.xxxx
-            ishl r2.z, r2.y, l(1)
-            iadd r2.z, r2.z, l(1)
-            ishl r2.z, r3.x, r2.z
-            or r1.w, r1.w, r2.z
-            iadd r2.y, r2.y, l(1)
-          endloop 
-          mov r12.w, r1.w
-          mov r0.z, r2.y
-          loop 
-            uge r2.z, r0.z, l(16)
-            breakc_nz r2.z
-            iadd r2.z, r0.z, r0.y
-            ld_structured r3.x, r2.z, l(16), g0.xxxx
-            ishl r2.z, r0.z, l(1)
-            ishl r2.z, r3.x, r2.z
-            or r12.w, r2.z, r12.w
-            iadd r0.z, r0.z, l(1)
-          endloop 
-          mov r12.y, r2.x
-        else 
-          ieq r0.z, r0.w, l(4)
-          if_nz r0.z
-            ishl r0.z, r1.z, l(5)
-            and r0.z, r0.z, l(96)
-            iadd r0.z, r0.z, l(16)
-            ishl r1.x, r1.x, l(7)
-            iadd r0.z, r0.z, r1.x
-            ld_structured r2.xyzw, r0.y, l(68), g0.xyzw
-            ishl r3.x, r2.x, l(5)
-            ishl r3.y, r2.y, l(15)
-            ishl r3.z, r2.z, l(25)
-            ishl r3.w, r2.w, l(4)
-            and r2.xyzw, r3.xyzw, l(7936, 0x007c0000, 0xf0000000, 4032)
-            iadd r0.z, r0.z, r2.x
-            ld_structured r3.xyzw, r0.y, l(84), g0.xyzw
-            ishl r4.xz, r3.xxwx, l(10)
-            ishl r4.y, r3.y, l(20)
-            and r3.xyw, r4.xyxz, l(0x0003e000, 0x0f800000, 0, 0x0003f000)
-            iadd r0.z, r0.z, r3.x
-            iadd r0.z, r2.y, r0.z
-            iadd r0.z, r3.y, r0.z
-            iadd r12.x, r2.z, r0.z
-            ld_structured r4.x, r0.y, l(76), g0.xxxx
-            ushr r0.z, r4.x, l(7)
-            and r0.z, r0.z, l(1)
-            ushr r1.x, r3.z, l(2)
-            and r1.x, r1.x, l(62)
-            iadd r0.z, r0.z, r1.x
-            iadd r0.z, r2.w, r0.z
-            iadd r0.z, r3.w, r0.z
-            ld_structured r2.xy, r0.y, l(16), g0.xyxx
-            ishl r3.x, r2.x, l(18)
-            ishl r3.y, r2.y, l(17)
-            and r1.xw, r3.xxxy, l(0x00040000, 0, 0, 0x00060000)
-            iadd r0.z, r0.z, r1.x
-            iadd r2.xyzw, r0.yyyy, l(1, 2, 3, 4)
-            ld_structured r3.xy, r2.x, l(16), g0.xyxx
-            ishl r3.xy, r3.xyxx, l(19)
-            iadd r0.z, r0.z, r3.x
-            ld_structured r4.xy, r2.y, l(16), g0.xyxx
-            ishl r1.x, r4.x, l(21)
-            ishl r2.x, r4.y, l(22)
-            or r0.z, r0.z, r1.x
-            ld_structured r4.xy, r2.z, l(16), g0.xyxx
-            ishl r1.x, r4.x, l(23)
-            ishl r2.y, r4.y, l(25)
-            or r0.z, r0.z, r1.x
-            ld_structured r4.xy, r2.w, l(16), g0.xyxx
-            ishl r1.x, r4.x, l(25)
-            ishl r2.z, r4.y, l(28)
-            or r0.z, r0.z, r1.x
-            iadd r4.xyzw, r0.yyyy, l(5, 6, 7, 8)
-            ld_structured r5.xy, r4.x, l(16), g0.xyxx
-            ishl r1.x, r5.x, l(27)
-            ishl r2.w, r5.y, l(31)
-            or r0.z, r0.z, r1.x
-            ld_structured r5.xy, r4.y, l(16), g0.xyxx
-            ishl r1.x, r5.x, l(29)
-            ishl r3.x, r5.y, l(2)
-            or r0.z, r0.z, r1.x
-            ld_structured r5.xy, r4.z, l(16), g0.xyxx
-            ishl r1.x, r5.x, l(31)
-            ishl r3.z, r5.y, l(5)
-            or r12.y, r0.z, r1.x
-            ld_structured r5.x, r4.z, l(16), g0.xxxx
-            ushr r0.z, r5.x, l(1)
-            ld_structured r5.xy, r4.w, l(16), g0.xyxx
-            ishl r1.x, r5.x, l(1)
-            ishl r3.w, r5.y, l(8)
-            or r0.z, r0.z, r1.x
-            iadd r5.xyzw, r0.yyyy, l(9, 10, 11, 12)
-            ld_structured r6.xy, r5.x, l(16), g0.xyxx
-            ishl r1.x, r6.x, l(3)
-            ishl r4.y, r6.y, l(11)
-            or r0.z, r0.z, r1.x
-            ld_structured r6.xy, r5.y, l(16), g0.xyxx
-            ishl r1.x, r6.x, l(5)
-            ishl r4.z, r6.y, l(14)
-            or r0.z, r0.z, r1.x
-            ld_structured r6.xy, r5.z, l(16), g0.xyxx
-            ishl r1.x, r6.x, l(7)
-            ishl r4.w, r6.y, l(17)
-            or r0.z, r0.z, r1.x
-            ld_structured r5.xy, r5.w, l(16), g0.xyxx
-            ishl r1.x, r5.x, l(9)
-            ishl r5.x, r5.y, l(20)
-            or r0.z, r0.z, r1.x
-            iadd r5.yzw, r0.yyyy, l(0, 13, 14, 15)
-            ld_structured r6.xy, r5.y, l(16), g0.xyxx
-            ishl r1.x, r6.x, l(11)
-            ishl r5.y, r6.y, l(23)
-            or r0.z, r0.z, r1.x
-            ld_structured r6.xy, r5.z, l(16), g0.xyxx
-            ishl r1.x, r6.x, l(13)
-            ishl r5.z, r6.y, l(26)
-            or r0.z, r0.z, r1.x
-            ld_structured r6.xy, r5.w, l(16), g0.xyxx
-            ishl r1.x, r6.x, l(15)
-            ishl r5.w, r6.y, l(29)
-            or r0.z, r0.z, r1.x
-            or r0.z, r1.w, r0.z
-            or r0.z, r3.y, r0.z
-            or r0.z, r2.x, r0.z
-            or r0.z, r2.y, r0.z
-            or r0.z, r2.z, r0.z
-            or r12.z, r2.w, r0.z
-            ld_structured r2.x, r4.x, l(20), g0.xxxx
-            ushr r0.z, r2.x, l(1)
-            or r0.z, r3.x, r0.z
-            or r0.z, r3.z, r0.z
-            or r0.z, r3.w, r0.z
-            or r0.z, r4.y, r0.z
-            or r0.z, r4.z, r0.z
-            or r0.z, r4.w, r0.z
-            or r0.z, r5.x, r0.z
-            or r0.z, r5.y, r0.z
-            or r0.z, r5.z, r0.z
-            or r12.w, r5.w, r0.z
-          else 
-            ieq r0.z, r0.w, l(5)
-            if_nz r0.z
-              ishl r0.z, r1.z, l(6)
-              iadd r0.z, r0.z, l(32)
-              ld_structured r2.xyzw, r0.y, l(68), g0.xyzw
-              ishl r3.x, r2.x, l(7)
-              ishl r3.y, r2.y, l(21)
-              ishl r3.z, r2.z, l(3)
-              ishl r1.x, r2.w, l(18)
-              and r2.xyz, r3.xyzx, l(0x00007f00, 0x1fc00000, 2032, 0)
-              or r0.z, r0.z, r2.x
-              ld_structured r3.xyzw, r0.y, l(84), g0.xyzw
-              ishl r4.x, r3.x, l(14)
-              ishl r4.y, r3.y, l(28)
-              ishl r4.z, r3.z, l(10)
-              ishl r1.z, r3.w, l(26)
-              and r3.xyz, r4.xyzx, l(0x003f8000, 0xe0000000, 0x0003f800, 0)
-              or r0.z, r0.z, r3.x
-              or r0.z, r2.y, r0.z
-              or r12.x, r3.y, r0.z
-              ld_structured r4.x, r0.y, l(88), g0.xxxx
-              ushr r0.z, r4.x, l(4)
-              and r0.z, r0.z, l(15)
-              iadd r0.z, r2.z, r0.z
-              iadd r0.z, r3.z, r0.z
-              iadd r0.z, r1.x, r0.z
-              or r12.y, r1.z, r0.z
-              ld_structured r2.x, r0.y, l(96), g0.xxxx
-              ushr r0.z, r2.x, l(6)
-              ld_structured r2.xy, r0.y, l(16), g0.xyxx
-              ishl r1.x, r2.x, l(2)
-              ishl r1.z, r2.y, l(1)
-              or r0.z, r0.z, r1.x
-              iadd r2.xyzw, r0.yyyy, l(1, 2, 3, 4)
-              ld_structured r3.xy, r2.x, l(16), g0.xyxx
-              ishl r1.x, r3.x, l(3)
-              ishl r1.w, r3.y, l(2)
-              or r0.z, r0.z, r1.x
-              ld_structured r3.xy, r2.y, l(16), g0.xyxx
-              ishl r1.x, r3.x, l(5)
-              ishl r2.x, r3.y, l(4)
-              or r0.z, r0.z, r1.x
-              ld_structured r3.xy, r2.z, l(16), g0.xyxx
-              ishl r1.x, r3.x, l(7)
-              ishl r2.y, r3.y, l(6)
-              or r0.z, r0.z, r1.x
-              ld_structured r3.xy, r2.w, l(16), g0.xyxx
-              ishl r1.x, r3.x, l(9)
-              ishl r2.z, r3.y, l(8)
-              or r0.z, r0.z, r1.x
-              iadd r3.xyzw, r0.yyyy, l(5, 6, 7, 8)
-              ld_structured r4.xy, r3.x, l(16), g0.xyxx
-              ishl r1.x, r4.x, l(11)
-              ishl r2.w, r4.y, l(10)
-              or r0.z, r0.z, r1.x
-              ld_structured r4.xy, r3.y, l(16), g0.xyxx
-              ishl r1.x, r4.x, l(13)
-              ishl r3.x, r4.y, l(12)
-              or r0.z, r0.z, r1.x
-              ld_structured r4.xy, r3.z, l(16), g0.xyxx
-              ishl r1.x, r4.x, l(15)
-              ishl r3.y, r4.y, l(14)
-              or r0.z, r0.z, r1.x
-              ld_structured r4.xy, r3.w, l(16), g0.xyxx
-              ishl r1.x, r4.x, l(17)
-              ishl r3.z, r4.y, l(16)
-              or r0.z, r0.z, r1.x
-              iadd r4.xyzw, r0.yyyy, l(9, 10, 11, 12)
-              ld_structured r5.xy, r4.x, l(16), g0.xyxx
-              ishl r1.x, r5.x, l(19)
-              ishl r3.w, r5.y, l(18)
-              or r0.z, r0.z, r1.x
-              ld_structured r5.xy, r4.y, l(16), g0.xyxx
-              ishl r1.x, r5.x, l(21)
-              ishl r4.x, r5.y, l(20)
-              or r0.z, r0.z, r1.x
-              ld_structured r5.xy, r4.z, l(16), g0.xyxx
-              ishl r1.x, r5.x, l(23)
-              ishl r4.y, r5.y, l(22)
-              or r0.z, r0.z, r1.x
-              ld_structured r5.xy, r4.w, l(16), g0.xyxx
-              ishl r1.x, r5.x, l(25)
-              ishl r4.z, r5.y, l(24)
-              or r0.z, r0.z, r1.x
-              iadd r5.xyz, r0.yyyy, l(13, 14, 15, 0)
-              ld_structured r6.xy, r5.x, l(16), g0.xyxx
-              ishl r1.x, r6.x, l(27)
-              ishl r4.w, r6.y, l(26)
-              or r0.z, r0.z, r1.x
-              ld_structured r6.xy, r5.y, l(16), g0.xyxx
-              ishl r1.x, r6.x, l(29)
-              ishl r5.x, r6.y, l(28)
-              or r0.z, r0.z, r1.x
-              ld_structured r6.xy, r5.z, l(16), g0.xyxx
-              ishl r1.x, r6.x, l(31)
-              ishl r5.y, r6.y, l(30)
-              or r12.z, r0.z, r1.x
-              ld_structured r6.x, r5.z, l(16), g0.xxxx
-              ushr r0.z, r6.x, l(1)
-              or r0.z, r1.z, r0.z
-              or r0.z, r1.w, r0.z
-              or r0.z, r2.x, r0.z
-              or r0.z, r2.y, r0.z
-              or r0.z, r2.z, r0.z
-              or r0.z, r2.w, r0.z
-              or r0.z, r3.x, r0.z
-              or r0.z, r3.y, r0.z
-              or r0.z, r3.z, r0.z
-              or r0.z, r3.w, r0.z
-              or r0.z, r4.x, r0.z
-              or r0.z, r4.y, r0.z
-              or r0.z, r4.z, r0.z
-              or r0.z, r4.w, r0.z
-              or r0.z, r5.x, r0.z
-              or r12.w, r5.y, r0.z
-            else 
-              ieq r0.z, r0.w, l(6)
-              if_nz r0.z
-                ld_structured r2.xyzw, r0.y, l(68), g0.xyzw
-                ishl r3.x, r2.x, l(6)
-                ishl r3.y, r2.y, l(20)
-                ishl r3.z, r2.z, l(2)
-                ishl r3.w, r2.w, l(16)
-                and r2.xyzw, r3.xyzw, l(0x00003f80, 0x0fe00000, 1016, 0x00fe0000)
-                iadd r0.z, r2.x, l(64)
-                ld_structured r3.xyzw, r0.y, l(84), g0.xyzw
-                ishl r4.x, r3.x, l(13)
-                ishl r4.y, r3.y, l(27)
-                ishl r4.z, r3.z, l(9)
-                ishl r4.w, r3.w, l(23)
-                and r3.xyzw, r4.xyzw, l(0x001fc000, 0xf0000000, 0x0001fc00, 0x7f000000)
-                iadd r0.z, r0.z, r3.x
-                iadd r0.z, r2.y, r0.z
-                iadd r12.x, r3.y, r0.z
-                ld_structured r4.xy, r0.y, l(84), g0.xyxx
-                ushr r0.z, r4.y, l(5)
-                and r0.z, r0.z, l(7)
-                iadd r0.z, r2.z, r0.z
-                iadd r0.z, r3.z, r0.z
-                iadd r0.z, r2.w, r0.z
-                iadd r0.z, r3.w, r0.z
-                ld_structured r2.x, r0.y, l(68), g0.xxxx
-                ishl r0.w, r2.x, l(31)
-                iadd r12.y, r0.w, r0.z
-                and r0.z, r4.x, l(1)
-                ld_structured r2.x, r0.y, l(16), g0.xxxx
-                ishl r0.w, r2.x, l(1)
-                iadd r0.z, r0.w, r0.z
-                iadd r2.xyzw, r0.yyyy, l(1, 2, 3, 4)
-                ld_structured r3.x, r2.x, l(16), g0.xxxx
-                ishl r0.w, r3.x, l(4)
-                or r0.z, r0.w, r0.z
-                ld_structured r3.x, r2.y, l(16), g0.xxxx
-                ishl r0.w, r3.x, l(8)
-                or r0.z, r0.w, r0.z
-                ld_structured r3.x, r2.z, l(16), g0.xxxx
-                ishl r0.w, r3.x, l(12)
-                or r0.z, r0.w, r0.z
-                ld_structured r2.x, r2.w, l(16), g0.xxxx
-                ishl r0.w, r2.x, l(16)
-                or r0.z, r0.w, r0.z
-                iadd r2.xyzw, r0.yyyy, l(5, 6, 7, 8)
-                ld_structured r3.x, r2.x, l(16), g0.xxxx
-                ishl r0.w, r3.x, l(20)
-                or r0.z, r0.w, r0.z
-                ld_structured r3.x, r2.y, l(16), g0.xxxx
-                ishl r0.w, r3.x, l(24)
-                or r0.z, r0.w, r0.z
-                ld_structured r3.x, r2.z, l(16), g0.xxxx
-                ishl r0.w, r3.x, l(28)
-                or r12.z, r0.w, r0.z
-                ld_structured r2.x, r2.w, l(16), g0.xxxx
-                iadd r3.xyzw, r0.yyyy, l(9, 10, 11, 12)
-                ld_structured r4.x, r3.x, l(16), g0.xxxx
-                ishl r0.z, r4.x, l(4)
-                or r0.z, r0.z, r2.x
-                ld_structured r2.x, r3.y, l(16), g0.xxxx
-                ishl r0.w, r2.x, l(8)
-                or r0.z, r0.w, r0.z
-                ld_structured r2.x, r3.z, l(16), g0.xxxx
-                ishl r0.w, r2.x, l(12)
-                or r0.z, r0.w, r0.z
-                ld_structured r2.x, r3.w, l(16), g0.xxxx
-                ishl r0.w, r2.x, l(16)
-                or r0.z, r0.w, r0.z
-                iadd r1.xzw, r0.yyyy, l(13, 0, 14, 15)
-                ld_structured r2.x, r1.x, l(16), g0.xxxx
-                ishl r0.w, r2.x, l(20)
-                or r0.z, r0.w, r0.z
-                ld_structured r2.x, r1.z, l(16), g0.xxxx
-                ishl r0.w, r2.x, l(24)
-                or r0.z, r0.w, r0.z
-                ld_structured r2.x, r1.w, l(16), g0.xxxx
-                ishl r0.w, r2.x, l(28)
-                or r12.w, r0.w, r0.z
-              else 
-                ishl r0.z, r1.y, l(8)
-                iadd r0.z, r0.z, l(128)
-                ld_structured r2.xyzw, r0.y, l(68), g0.xyzw
-                ishl r3.x, r2.x, l(11)
-                ishl r3.y, r2.z, l(19)
-                ishl r3.z, r2.w, l(7)
-                and r1.xzw, r3.xxyz, l(0x0007c000, 0, 0x07c00000, 0x00007c00)
-                or r0.z, r0.z, r1.x
-                ld_structured r3.xyzw, r0.y, l(84), g0.xyzw
-                ishl r4.x, r3.x, l(16)
-                ishl r4.y, r3.y, l(4)
-                ishl r4.z, r3.z, l(24)
-                ishl r4.w, r3.w, l(12)
-                and r4.xyzw, r4.xyzw, l(0x00f80000, 3968, 0xf8000000, 0x000f8000)
-                or r0.z, r0.z, r4.x
-                iadd r0.w, r0.y, l(1)
-                ld_structured r5.xyzw, r0.w, l(68), g0.xyzw
-                ishl r6.x, r5.x, l(21)
-                ishl r6.y, r5.y, l(9)
-                ishl r6.z, r5.w, l(17)
-                and r6.xyz, r6.xyzx, l(0x1f000000, 0x0001f000, 0x01f00000, 0)
-                or r0.z, r0.z, r6.x
-                ld_structured r7.xyzw, r0.w, l(84), g0.xyzw
-                ishl r8.x, r7.x, l(26)
-                ishl r8.y, r7.y, l(14)
-                ishl r8.z, r7.z, l(2)
-                ishl r8.w, r7.w, l(22)
-                and r8.xyzw, r8.xyzw, l(0xe0000000, 0x003e0000, 992, 0x3e000000)
-                or r12.x, r0.z, r8.x
-                ld_structured r9.x, r0.w, l(84), g0.xxxx
-                ushr r10.x, r9.x, l(6)
-                ushr r10.y, r9.x, l(1)
-                and r6.xw, r10.xxxy, l(3, 0, 0, 2)
-                ushr r0.z, r2.y, l(1)
-                and r0.z, r0.z, l(124)
-                iadd r0.z, r0.z, r6.x
-                iadd r0.z, r4.y, r0.z
-                iadd r0.z, r6.y, r0.z
-                iadd r0.z, r8.y, r0.z
-                iadd r0.z, r1.z, r0.z
-                iadd r12.y, r4.z, r0.z
-                ushr r0.z, r5.z, l(3)
-                and r0.z, r0.z, l(31)
-                iadd r0.z, r8.z, r0.z
-                iadd r0.z, r1.w, r0.z
-                iadd r0.z, r4.w, r0.z
-                iadd r0.z, r6.z, r0.z
-                iadd r0.z, r8.w, r0.z
-                ld_structured r2.x, r0.y, l(68), g0.xxxx
-                ishl r1.x, r2.x, l(28)
-                and r1.x, r1.x, l(0x40000000)
-                iadd r0.z, r0.z, r1.x
-                ld_structured r2.x, r0.y, l(84), g0.xxxx
-                ishl r1.x, r2.x, l(29)
-                and r1.x, r1.x, l(0x80000000)
-                iadd r12.z, r0.z, r1.x
-                ld_structured r2.x, r0.w, l(68), g0.xxxx
-                ushr r0.z, r2.x, l(2)
-                and r0.z, r0.z, l(1)
-                iadd r0.z, r6.w, r0.z
-                ld_structured r2.x, r0.y, l(16), g0.xxxx
-                ishl r0.w, r2.x, l(2)
-                iadd r0.z, r0.w, r0.z
-                mov r0.w, r0.z
-                mov r1.x, l(1)
-                loop 
-                  ult r1.z, icb[r1.y + 128].y, r1.x
-                  breakc_nz r1.z
-                  iadd r1.z, r0.y, r1.x
-                  ld_structured r2.x, r1.z, l(16), g0.xxxx
-                  ishl r1.z, r1.x, l(1)
-                  iadd r1.z, r1.z, l(1)
-                  ishl r1.z, r2.x, r1.z
-                  or r0.w, r0.w, r1.z
-                  iadd r1.x, r1.x, l(1)
-                endloop 
-                mov r12.w, r0.w
-                mov r0.z, r1.x
-                loop 
-                  uge r1.y, r0.z, l(16)
-                  breakc_nz r1.y
-                  iadd r1.y, r0.z, r0.y
-                  ld_structured r2.x, r1.y, l(16), g0.xxxx
-                  ishl r1.y, r0.z, l(1)
-                  ishl r1.y, r2.x, r1.y
-                  or r12.w, r1.y, r12.w
-                  iadd r0.z, r0.z, l(1)
-                endloop 
-              endif 
-            endif 
-          endif 
-        endif 
-      endif 
-    endif 
-  endif 
-  store_structured u0.xyzw, r0.x, l(0), r12.xyzw
-endif 
-ret 
-// Approximately 0 instruction slots used
-#endif
-
-const BYTE BC7Encode_EncodeBlockCS[] =
-{
-     68,  88,  66,  67,  33, 143, 
-     96, 195, 201,  25,   5,  15, 
-     19,  60,  35, 103, 143, 233, 
-    183,  96,   1,   0,   0,   0, 
-    200, 193,   0,   0,   3,   0, 
-      0,   0,  44,   0,   0,   0, 
-     60,   0,   0,   0,  76,   0, 
-      0,   0,  73,  83,  71,  78, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     79,  83,  71,  78,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  83,  72, 
-     69,  88, 116, 193,   0,   0, 
-     64,   0,   5,   0,  93,  48, 
-      0,   0, 106,   8,   0,   1, 
-     53,  24,   0,   0,   2,   4, 
-      0,   0, 204, 204,   0,   0, 
-     80,  80, 104, 170,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-    136, 136,   0,   0,  64,  80, 
-     90, 106,  15,   0,   0,   0, 
-      0,   0,   0,   0, 238, 238, 
-      0,   0,   0,  66,  90,  90, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0, 200, 236,   0,   0, 
-    168, 160,  80,  84,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-    128, 200,   0,   0,   0,   0, 
-    165, 165,  15,   0,   0,   0, 
-      0,   0,   0,   0, 236, 254, 
-      0,   0,  80,  80, 160, 160, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0, 200, 254,   0,   0, 
-    160, 160,  85,  85,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-    128, 236,   0,   0,  80,  80, 
-     90,  90,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0, 200, 
-      0,   0,   0,   0,  85, 170, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0, 236, 255,   0,   0, 
-      0,  85,  85, 170,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-    128, 254,   0,   0,   0,  85, 
-    170, 170,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0, 232, 
-      0,   0, 144, 144, 144, 144, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0, 232, 255,   0,   0, 
-    148, 148, 148, 148,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0, 255,   0,   0, 164, 164, 
-    164, 164,  15,   0,   0,   0, 
-      0,   0,   0,   0, 240, 255, 
-      0,   0,  80, 148, 165, 169, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0, 240,   0,   0, 
-     80,  66,  10,  42,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-     16, 247,   0,   0,  64,  80, 
-    148, 165,  15,   0,   0,   0, 
-      0,   0,   0,   0, 142,   0, 
-      0,   0,  84,  80,  66,  10, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0, 113,   0,   0, 
-      0, 165, 165, 165,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-    206,   8,   0,   0, 160, 160, 
-    160,  85,   2,   0,   0,   0, 
-      0,   0,   0,   0, 140,   0, 
-      0,   0,  84,  84, 168, 168, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  16, 115,   0,   0, 
-     64,  64, 106, 106,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  49,   0,   0,   0,  80, 
-    164, 164,   8,   0,   0,   0, 
-      0,   0,   0,   0, 206, 140, 
-      0,   0,   0,   5,  26,  26, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0, 140,   8,   0,   0, 
-    164, 164,  80,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     16,  49,   0,   0, 144, 144, 
-    165, 170,   8,   0,   0,   0, 
-      0,   0,   0,   0, 102, 102, 
-      0,   0,  20, 105, 105,  20, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0, 108,  54,   0,   0, 
-      0,  20, 105, 105,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-    232,  23,   0,   0, 160, 133, 
-    133, 160,   8,   0,   0,   0, 
-      0,   0,   0,   0, 240,  15, 
-      0,   0,  20,  20, 130, 170, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0, 142, 113,   0,   0, 
-     80, 164, 164,  80,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-    156,  57,   0,   0,   0,   2, 
-     90, 106,   2,   0,   0,   0, 
-      0,   0,   0,   0, 170, 170, 
-      0,   0,   0, 128, 165, 169, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0, 240, 240,   0,   0, 
-    168, 160, 144,  80,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-     90,  90,   0,   0,  80, 144, 
-    160, 168,   6,   0,   0,   0, 
-      0,   0,   0,   0, 204,  51, 
-      0,   0,  36,  36,  36,  36, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,  60,  60,   0,   0, 
-      0,  85, 170,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-    170,  85,   0,   0,  36,  73, 
-    146,  36,   8,   0,   0,   0, 
-      0,   0,   0,   0, 150, 150, 
-      0,   0,  36, 146,  73,  36, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  90, 165,   0,   0, 
-     80,  10, 165,  80,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-    206, 115,   0,   0,  80, 165, 
-     10,  80,   2,   0,   0,   0, 
-      0,   0,   0,   0, 200,  19, 
-      0,   0,  68,  68, 170, 170, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,  76,  50,   0,   0, 
-      0,   0, 102, 102,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-    220,  59,   0,   0, 160, 165, 
-    160, 165,   2,   0,   0,   0, 
-      0,   0,   0,   0, 150, 105, 
-      0,   0, 160,  80, 160,  80, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  60, 195,   0,   0, 
-     40, 105,  40, 105,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-    102, 153,   0,   0,  68, 170, 
-    170,  68,  15,   0,   0,   0, 
-      0,   0,   0,   0,  96,   6, 
-      0,   0,   0, 102, 102, 102, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0, 114,   2,   0,   0, 
-     68,  68,  68, 170,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-    228,   4,   0,   0, 168,  84, 
-    168,  84,   2,   0,   0,   0, 
-      0,   0,   0,   0,  64,  78, 
-      0,   0, 128, 149, 128, 149, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,  32,  39,   0,   0, 
-      0, 150, 150, 150,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54, 201,   0,   0, 168,  84, 
-     84, 168,  15,   0,   0,   0, 
-      0,   0,   0,   0, 108, 147, 
-      0,   0, 128, 149, 149, 128, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0, 198,  57,   0,   0, 
-     20,  20,  20, 170,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-    156,  99,   0,   0,   0,   0, 
-    150, 150,   2,   0,   0,   0, 
-      0,   0,   0,   0,  54, 147, 
-      0,   0,  20,  20, 170, 170, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0, 198, 156,   0,   0, 
-    160,  80,  80, 160,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-    126, 129,   0,   0, 160, 165, 
-    165, 160,  15,   0,   0,   0, 
-      0,   0,   0,   0,  24, 231, 
-      0,   0,   0,   0,   0, 150, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0, 240, 204,   0,   0, 
-    128,  64, 128,  64,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-    204,  15,   0,   0, 168, 169, 
-    168, 169,   2,   0,   0,   0, 
-      0,   0,   0,   0,  68, 119, 
-      0,   0,  68, 170, 170, 170, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  34, 238,   0,   0, 
-     84,  82,  74,  42,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   8,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   8,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  15,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      8,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   8,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      8,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  15,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   8,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      3,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,   6,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     10,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-     10,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   8,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  10,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     10,   0,   0,   0,   9,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,   0,   0,   8,   0, 
-      0,   0,   9,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,   9,   0,   0,   0, 
-      9,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-     10,   0,   0,   0,   9,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   6,   0, 
-      0,   0,  10,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-     10,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      8,   0,   0,   0,  10,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,  10,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-     10,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,  11,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   6,   0, 
-      0,   0,  11,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   8,   0,   0,   0, 
-     11,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,  11,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,  12,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-     12,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,  12,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,  12,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-     13,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,  13,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,   0,   0,  15,   0, 
-      0,   0,  13,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-     13,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-     15,   0,   0,   0,  14,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,  14,   0,   0,   0, 
-      0,   0,   0,   0,  13,   0, 
-      0,   0,  15,   0,   0,   0, 
-     14,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,  14,   0, 
-      0,   0,   0,   0,   0,   0, 
-     12,   0,   0,   0,  15,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   6,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      6,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      3,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   3,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      3,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   6,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   8,   0,   0,   0, 
-     10,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      3,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   6,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      6,   0,   0,   0,  10,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     10,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   5,   0,   0,   0, 
-     10,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      6,   0,   0,   0,  10,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   8,   0, 
-      0,   0,  10,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   8,   0,   0,   0, 
-      9,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     10,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   6,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      6,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   6,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  10,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     10,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  13,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  12,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      3,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-     89,   0,   0,   4,  70, 142, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  88,  24, 
-      0,   4,   0, 112,  16,   0, 
-      0,   0,   0,   0,  85,  85, 
-      0,   0, 162,   0,   0,   4, 
-      0, 112,  16,   0,   1,   0, 
-      0,   0,  16,   0,   0,   0, 
-    158,   0,   0,   4,   0, 224, 
-     17,   0,   0,   0,   0,   0, 
-     16,   0,   0,   0,  95,   0, 
-      0,   2,   0,  64,   2,   0, 
-     95,   0,   0,   2,  18,  16, 
-      2,   0, 104,   0,   0,   2, 
-     15,   0,   0,   0, 160,   0, 
-      0,   5,   0, 240,  17,   0, 
-      0,   0,   0,   0, 100,   0, 
-      0,   0,  64,   0,   0,   0, 
-    155,   0,   0,   4,  64,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   6,  18,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  16, 
-      2,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   8,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10, 128,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     48,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16, 128,  65,   0,   0,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     70, 114,  16,   0,   1,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0, 255, 255, 255, 127, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,   6, 112, 
-     16,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,  79,   0, 
-      0,  10, 242,   0,  16,   0, 
-      2,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,  16,   0, 
-      0,   0,   8,   0,   0,   0, 
-      4,   0,   0,   0,   2,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  78,   0,   0,   9, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,   0, 208,   0,   0, 
-     10,   0,  16,   0,   0,   0, 
-      0,   0,  26, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  35,   0,   0,  11, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16, 128, 
-     65,   0,   0,   0,   1,   0, 
-      0,   0,  26, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   8, 194,   0,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     45,   0,   0,   7, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,  70, 126,  16,   0, 
-      0,   0,   0,   0,  56,   0, 
-      0,  10, 242,   0,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-    127,  67,   0,   0, 127,  67, 
-      0,   0, 127,  67,   0,   0, 
-    127,  67,  28,   0,   0,   5, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-      3,   0,   0,   0,  84,   0, 
-      0,  10, 242,   0,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0, 255,   0, 
-      0,   0, 255,   0,   0,   0, 
-    255,   0,   0,   0, 255,   0, 
-      0,   0,  32,   0,   0,  10, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0, 246,  15,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   4,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-      4,   0,   0,   0, 166,  10, 
-     16,   0,   1,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-    194,   0,  16,   0,   5,   0, 
-      0,   0, 166,  10,  16,   0, 
-      4,   0,   0,   0, 246,  11, 
-     16,   0,   3,   0,   0,   0, 
-    166,  14,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   5, 
-     50,   0,  16,   0,   5,   0, 
-      0,   0,  70,   0,  16,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-      5,   0,   0,   0,  86,   5, 
-     16,   0,   4,   0,   0,   0, 
-    246,   6,  16,   0,   3,   0, 
-      0,   0,  86,  14,  16,   0, 
-      5,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-      4,   0,   0,   0,   6,   0, 
-     16,   0,   4,   0,   0,   0, 
-    118,   2,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-      3,   0,   0,   0, 246,  15, 
-     16,   0,   1,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,  70,  14,  16,   0, 
-      3,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  30,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0, 192, 255, 255, 255, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   8,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26, 144, 144,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,   0,   0,   7, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     32,   0,   0,  10,  98,   0, 
-     16,   0,   4,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  32,   0,   0,   7, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     55,   0,   0,  12, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-      6,   0,  16,   0,   4,   0, 
-      0,   0,  70,  14,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-      1,   0,   0,   7, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,   6,   0,  16,   0, 
-      4,   0,   0,   0,  55,   0, 
-      0,  12, 242,   0,  16,   0, 
-      5,   0,   0,   0,  86,   5, 
-     16,   0,   4,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,   1,   0, 
-      0,   7, 242,   0,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     86,   5,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   8, 242,   0,  16,   0, 
-      4,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     84,   0,   0,   7, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     83,   0,   0,   7, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   8, 242,   0,  16,   0, 
-      4,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     84,   0,   0,   7, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     83,   0,   0,   7, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   8, 242,   0,  16,   0, 
-      4,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     84,   0,   0,   7, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     83,   0,   0,   7, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  79,   0,   0,  10, 
-     50,   0,  16,   0,   3,   0, 
-      0,   0, 166,  10,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  66,   0,  16,   0, 
-      3,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      4,   0,   0,   0,  70,  14, 
-     16,   0,   4,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0,  83,   0, 
-      0,   7, 242,   0,  16,   0, 
-      4,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     32,   0,   0,  10, 194,   0, 
-     16,   0,   3,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      3,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  18,   0, 
-      0,   1,  54,   0,   0,   8, 
-    242,   0,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,  54,   0, 
-      0,   8, 242,   0,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     21,   0,   0,   1,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   8, 242,   0,  16,   0, 
-      6,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     85,   0,   0,   8,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10, 144, 144,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   8,  18,   0,  16,   0, 
-      7,   0,   0,   0,  26, 144, 
-    144,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  32,   0, 
-      0,  10, 242,   0,  16,   0, 
-      8,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,   3,   0, 
-      0,   0,  32,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     55,   0,   0,  12, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-      6,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-      1,   0,   0,   7, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   6,   0,  16,   0, 
-      7,   0,   0,   0,  60,   0, 
-      0,   7,  50,   0,  16,   0, 
-      8,   0,   0,   0, 214,   5, 
-     16,   0,   8,   0,   0,   0, 
-    134,   0,  16,   0,   8,   0, 
-      0,   0,  32,   0,   0,   7, 
-     66,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  32,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  55,   0,   0,  12, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0, 166,  10,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255,   1,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0, 166,  10, 
-     16,   0,   3,   0,   0,   0, 
-     55,   0,   0,  12, 242,   0, 
-     16,   0,  10,   0,   0,   0, 
-     86,   5,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-      1,   0,   0,   7, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  86,   5,  16,   0, 
-      8,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-      9,   0,   0,   0,   6,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-      6,   0,   0,   0,   6,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   8, 242,   0,  16,   0, 
-      6,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  84,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  83,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   8, 242,   0,  16,   0, 
-      6,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  84,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  83,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   8, 242,   0,  16,   0, 
-      6,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  84,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  83,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      3,   0,   0,   0, 167,   0, 
-      0,   8, 242,   0,  16,   0, 
-      6,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  84,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  83,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      3,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  21,   0, 
-      0,   1,  31,   0,   4,   3, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   8,  66,   0,  16,   0, 
-      3,   0,   0,   0,  10, 144, 
-    144,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   8, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  26, 144, 144,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  32,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0, 246,  15,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0,   3,   0,   0,   0, 
-     55,   0,   0,  12, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-      6,   0,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     55,   0,   0,  12, 242,   0, 
-     16,   0,   7,   0,   0,   0, 
-      6,   0,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     60,   0,   0,   7,  50,   0, 
-     16,   0,   8,   0,   0,   0, 
-    214,   5,  16,   0,   8,   0, 
-      0,   0, 134,   0,  16,   0, 
-      8,   0,   0,   0,  32,   0, 
-      0,  10, 242,   0,  16,   0, 
-     10,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   7,   0, 
-      0,   0,   4,   0,   0,   0, 
-      5,   0,   0,   0,   6,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,  10,   0,   0,   0, 
-     55,   0,   0,  12, 242,   0, 
-     16,   0,  11,   0,   0,   0, 
-    166,  10,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     55,   0,   0,  12, 242,   0, 
-     16,   0,  12,   0,   0,   0, 
-    166,  10,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,  10,   0, 
-      0,   0,  26,   0,  16,   0, 
-     10,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  55,   0,   0,  12, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0, 166,  10,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255,   1,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0, 166,  10, 
-     16,   0,   3,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,  10,   0,   0,   0, 
-     86,   5,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-     11,   0,   0,   0,  70,  14, 
-     16,   0,  10,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     86,   5,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-     12,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-      6,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,  10,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-      6,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  83,   0, 
-      0,   7, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  83,   0, 
-      0,   7, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  83,   0, 
-      0,   7, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  83,   0, 
-      0,   7, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   7,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   0,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     21,   0,   0,   1,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      3,   0,   0,   0,  32,   0, 
-      0,  10, 226,   0,  16,   0, 
-      2,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      4,   0,   0,   0,   5,   0, 
-      0,   0,  85,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,   0,   0,  10, 
-     98,   0,  16,   0,   3,   0, 
-      0,   0,   6,   1,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,   9,  50,   0, 
-     16,   0,   3,   0,   0,   0, 
-     86,   5,  16,   0,   2,   0, 
-      0,   0,   6,   0,  16,   0, 
-      3,   0,   0,   0, 150,   5, 
-     16,   0,   3,   0,   0,   0, 
-     31,   0,   0,   3,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     35,   0,   0,  15, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,   6,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     35,   0,   0,  15, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  86,   5,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0, 255,   0, 
-      0,   0,  54,   0,   0,   8, 
-    178,   0,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255,   0,   0,   0, 248,   7, 
-      0,   0,   0,   0,   0,   0, 
-    248,   7,   0,   0,  18,   0, 
-      0,   1,  31,   0,   4,   3, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  35,   0,   0,  15, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0, 127, 127,   0,   0, 
-    127, 127,   0,   0, 127, 127, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-      9,   0,   0,   0,   6,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  35,   0,   0,  15, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0, 127, 127,   0,   0, 
-    127, 127,   0,   0, 127, 127, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-      9,   0,   0,   0,  86,   5, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255,   0,   0,   0,  54,   0, 
-      0,   8, 178,   0,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0, 255,   0,   0,   0, 
-    254,   1,   0,   0,   0,   0, 
-      0,   0, 254,   1,   0,   0, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  35,   0,   0,  15, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,  31,  31,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     35,   0,   0,  15, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0, 255,   0,   0,   0, 
-     54,   0,   0,   8, 178,   0, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0, 255,   0, 
-      0,   0, 248,   7,   0,   0, 
-      0,   0,   0,   0, 248,   7, 
-      0,   0,  18,   0,   0,   1, 
-     32,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-    255, 255, 254, 255, 255, 255, 
-    254, 255, 255, 255,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,   6,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255, 255, 255, 254, 255, 
-    255, 255, 254, 255, 255, 255, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-      8,   0,   0,   0,  86,   5, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,  54,   0,   0,   5, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   5, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0, 255,   0, 
-      0,   0,  54,   0,   0,   8, 
-    178,   0,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255,   0,   0,   0, 255,   0, 
-      0,   0,   0,   0,   0,   0, 
-    255,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     35,   0,   0,  15, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-     63,  63,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-     85,   0,   0,   7, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  60,   0,   0,   7, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-     35,   0,   0,  15, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-     63,  63,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-     85,   0,   0,   7, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 210,   0,  16,   0, 
-      4,   0,   0,   0,   6,   6, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-    198,   2,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  85,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  60,   0,   0,   7, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0, 198,   6,  16,   0, 
-      4,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-     54,   0,   0,   5, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-    198,   2,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  35,   0,   0,  15, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0, 127, 127,   0,   0, 
-    127, 127,   0,   0, 127, 127, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     35,   0,   0,  15, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-    127, 127,   0,   0, 127, 127, 
-      0,   0, 127, 127,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-     54,   0,   0,   5,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  18,   0,   0,   1, 
-     32,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-    255, 255, 254, 255, 255, 255, 
-    254, 255, 255, 255, 254, 255, 
-    255, 255,  30,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,   6,   0,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255, 255, 255, 254, 255, 
-    255, 255, 254, 255, 255, 255, 
-    254, 255, 255, 255,  30,   0, 
-      0,   7, 242,   0,  16,   0, 
-      4,   0,   0,   0,  86,   5, 
-     16,   0,   3,   0,   0,   0, 
-    198,   6,  16,   0,   9,   0, 
-      0,   0,  54,   0,   0,   5, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   5, 242,   0,  16,   0, 
-      5,   0,   0,   0, 198,   6, 
-     16,   0,   4,   0,   0,   0, 
-     54,   0,   0,   5, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-    198,   2,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   5, 
-    146,   0,  16,   0,   4,   0, 
-      0,   0, 246,  15,  16,   0, 
-      6,   0,   0,   0,  18,   0, 
-      0,   1,  35,   0,   0,  15, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,  63,  63,   0,   0, 
-     63,  63,   0,   0,  63,  63, 
-      0,   0,  63,  63,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,  85,   0,   0,   7, 
-    242,   0,  16,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0,  30,   0, 
-      0,   7, 242,   0,  16,   0, 
-      9,   0,   0,   0,   6,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7, 242,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,  14,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  60,   0, 
-      0,   7, 242,   0,  16,   0, 
-      4,   0,   0,   0,  54,   6, 
-     16,   0,   6,   0,   0,   0, 
-     54,   6,  16,   0,  10,   0, 
-      0,   0,  35,   0,   0,  15, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,  63,  63,   0,   0, 
-     63,  63,   0,   0,  63,  63, 
-      0,   0,  63,  63,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,  85,   0,   0,   7, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,  14,  16,   0,  10,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0,  30,   0, 
-      0,   7, 242,   0,  16,   0, 
-     10,   0,   0,   0,  86,   5, 
-     16,   0,   3,   0,   0,   0, 
-    198,   9,  16,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0, 134,   7,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7, 242,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  60,   0, 
-      0,   7, 242,   0,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,  11,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  50,   0,  16,   0, 
-      3,   0,   0,   0,  70,   0, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  54,   0,   0,   5, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0, 214,   6,  16,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   5, 162,   0,  16,   0, 
-      4,   0,   0,   0,  86,   1, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     40,   0,   0,   5, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  31,   0,   0,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   4,  16,   0,  10,   0, 
-      0,   0,   6,   4,  16,   0, 
-     10,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  35,   0,   0,   9, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-     11,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   8, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16, 128,  65,   0,   0,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0,  50,   0,  16,   0, 
-      3,   0,   0,   0,  70,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   0,  16,   0,  10,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     35,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     30,   0,   0,   8,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16, 128,  65,   0, 
-      0,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,  11,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  34,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  34,   0,   0,   7, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  43,   0, 
-      0,   5,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     56,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  28,   0, 
-      0,   5,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  79,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-    166,  10,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-    166,  10,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-    166,  10,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-    166,  10,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     34,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  34,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     43,   0,   0,   5,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  56,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     28,   0,   0,   5,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     79,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   5, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-     13,   0,   0,   0, 166,  10, 
-     16,   0,   2,   0,   0,   0, 
-     38,  13,  16,   0,   4,   0, 
-      0,   0, 134,   7,  16,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-     11,   0,   0,   0,  10,   0, 
-     16,   0,  13,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,  13,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-     13,   0,   0,   0,  54,   0, 
-      0,   5, 242,   0,  16,   0, 
-      6,   0,   0,   0,  70,  14, 
-     16,   0,  12,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   5, 
-    242,   0,  16,   0,  11,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  21,   0,   0,   1, 
-     18,   0,   0,   1,  31,   0, 
-      0,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42, 144, 
-    144,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  18,   0, 
-      0,   1,  54,   0,   0,   6, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58, 144, 144,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1,  38,   0, 
-      0,   8,   0, 208,   0,   0, 
-     50,   0,  16,   0,   3,   0, 
-      0,   0,  70,   0,  16,   0, 
-     10,   0,   0,   0,  70,   0, 
-     16,   0,  10,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  35,   0, 
-      0,   9, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  35,   0, 
-      0,   9, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-      9,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0,  50,   0,  16,   0, 
-      3,   0,   0,   0,  70,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   0,  16,   0,  10,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     35,   0,   0,   9,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     35,   0,   0,   9,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     34,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  34,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     43,   0,   0,   5,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  56,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     28,   0,   0,   5,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-     11,   0,   0,   0,  86,   5, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,  70,  14,  16,   0, 
-      7,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-      5,   0,   0,   0,  86,   5, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   7,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      8,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     54,   0,   0,   5, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  55,   0,   0,   9, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  86,   5,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,  55,   0,   0,   9, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  86,   5,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   4,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,  21,   0,   0,   1, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70,  14,  16,   0,  11,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  84,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      2,   0,   0,   0,  32,   0, 
-      0,  10, 242,   0,  16,   0, 
-      2,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      6,   0,   0,   0,   4,   0, 
-      0,   0,  60,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     55,   0,   0,  15,  98,   0, 
-     16,   0,   3,   0,   0,   0, 
-      6,   0,  16,   0,   1,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  12,  98,   0, 
-     16,   0,   3,   0,   0,   0, 
-    246,  15,  16,   0,   2,   0, 
-      0,   0,  86,   6,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,  12,  98,   0, 
-     16,   0,   3,   0,   0,   0, 
-    166,  10,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  86,   6, 
-     16,   0,   3,   0,   0,   0, 
-     55,   0,   0,  12,  50,   0, 
-     16,   0,   3,   0,   0,   0, 
-      6,   0,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 150,   5, 
-     16,   0,   3,   0,   0,   0, 
-     32,   0,   0,  10, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      2,   0,   0,   0,   3,   0, 
-      0,   0,   7,   0,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   8, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  26, 144, 144,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   2,   0, 
-      0,   0,  70,   3,  16,   0, 
-      2,   0,   0,   0,  70,   3, 
-     16,   0,   4,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   8, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10, 144, 
-    144,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     52,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   8, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,  14,  16, 128,  65,   0, 
-      0,   0,   4,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,  79,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     55,   0,   0,   9, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0,  50,   0,  16,   0, 
-      2,   0,   0,   0,  70,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   0,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     35,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   8, 242,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16, 128,  65,   0,   0,   0, 
-      4,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   5,   0,   0,   0, 
-      6,   4,  16,   0,   7,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     35,   0,   0,   9,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     33,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  33,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     34,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  43,   0, 
-      0,   5,  82,   0,  16,   0, 
-      2,   0,   0,   0,   6,   2, 
-     16,   0,   2,   0,   0,   0, 
-     56,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  14,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  28,   0,   0,   5, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7, 162,   0,  16,   0, 
-      3,   0,   0,   0,   6,   4, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     30,   0,   0,  10,  50,   0, 
-     16,   0,   6,   0,   0,   0, 
-    214,   5,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-     11,   0,   0,   0,  11,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  78,   0, 
-      0,  11,   0, 208,   0,   0, 
-     50,   0,  16,   0,   6,   0, 
-      0,   0,  70,   0,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,  68,   0,   0,   0, 
-     68,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     79,   0,   0,  10,  50,   0, 
-     16,   0,   7,   0,   0,   0, 
-    214,   5,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,  12,  50,   0,  16,   0, 
-      6,   0,   0,   0,  70,   0, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,  15,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  70,   0,  16,   0, 
-      6,   0,   0,   0,  55,   0, 
-      0,  11,  18,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10, 144, 208,   0,  64,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-     55,   0,   0,   9,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0,  18,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  33,   0,   0,  10, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  86,   1, 
-     16,   0,   2,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  34,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  43,   0,   0,   5, 
-     50,   0,  16,   0,   2,   0, 
-      0,   0,  70,   0,  16,   0, 
-      2,   0,   0,   0,  56,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0, 253, 255, 
-    125,  66,  14,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     28,   0,   0,   5,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     55,   0,   0,  11,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  10, 144, 208,   0, 
-     64,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  55,   0,   0,   9, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  55,   0,   0,   9, 
-     50,   0,  16,   0,   2,   0, 
-      0,   0,   6,   0,  16,   0, 
-      1,   0,   0,   0,  70,   0, 
-     16,   0,   7,   0,   0,   0, 
-     22,   5,  16,   0,   7,   0, 
-      0,   0,  18,   0,   0,   1, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0, 194,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,   5,   0,   0,   0, 
-      6,   4,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     35,   0,   0,   9,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     35,   0,   0,   9,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-    242,   0,  16,   0,   4,   0, 
-      0,   0,  70,  14,  16, 128, 
-     65,   0,   0,   0,   4,   0, 
-      0,   0,  70,  14,  16,   0, 
-      6,   0,   0,   0,  38,   0, 
-      0,   8,   0, 208,   0,   0, 
-     98,   0,  16,   0,   3,   0, 
-      0,   0,   6,   1,  16,   0, 
-      4,   0,   0,   0,   6,   1, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  35,   0, 
-      0,   9, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  35,   0, 
-      0,   9, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  33,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  33,   0,   0,   7, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  34,   0, 
-      0,   7,  34,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  43,   0,   0,   5, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  56,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0, 253, 255, 
-    125,  66,  43,   0,   0,   5, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  14,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  28,   0,   0,   5, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  78,   0, 
-      0,   8,   0, 208,   0,   0, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     79,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,   9,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,  11, 130,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10, 144, 208,   0,  64,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     55,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  21,   0,   0,   1, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70,   0,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      0,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0,  31,   0, 
-      0,   3,  58,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0, 128, 255, 255, 255, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  68,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0, 224,   1, 
-      0,   0,   0,   0,   0, 224, 
-      0,   0, 224,   1,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     84,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,   1,   0,   0,  10, 
-    146,   0,  16,   0,   2,   0, 
-      0,   0,   6,   4,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,  30,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  30, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,  10, 146,   0,  16,   0, 
-      3,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  25,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0, 224,   1,   0, 
-    224,   1,   0,   0,   0,   0, 
-      0, 224,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,  13,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-      1,   0,   0,  10, 146,   0, 
-     16,   0,   4,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,  30,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  30,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   9,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   9,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 224,   1, 
-      0, 224,   1,   0, 224,   1, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     11,   0,   0,   0,  10,   0, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,  11,   0, 
-      0,   0,  26,   0,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  11,   0,   0,   0, 
-     42,   0,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,  30,   0,   0,  30,   0, 
-      0,  30,   0,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,  11,   0,   0,   0, 
-     60,   0,   0,   7,  18,   0, 
-     16,   0,  12,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-     13,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  68,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  13,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,  11,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,  12,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  76,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  30,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,  11,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-     13,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,  32,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  84,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,  64,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0, 128,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  84,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   1,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   2,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  84,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   4,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  84,   0, 
-      0,   9, 130,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     26, 144, 208,   0, 128,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  48,   0,   0,   1, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   3,   0, 
-      4,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  35,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,  12,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-     12,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-     79,   0,   0,   9,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26, 144, 208,   0, 128,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,  12,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  48,   0,   0,   1, 
-     79,   0,   0,   9, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26, 144, 208,   0, 128,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      3,   0,   4,   3,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  35,   0, 
-      0,   9, 130,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-    242, 255, 255, 255,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,  21,   0,   0,   1, 
-     54,   0,   0,   5,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  48,   0, 
-      0,   1,  79,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  42, 144, 208,   0, 
-    128,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   3,   0,   4,   3, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     35,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0, 241, 255, 255, 255, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     22,   0,   0,   1,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  48,   0,   0,   1, 
-     80,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   3,   0, 
-      4,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  35,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0, 240, 255, 
-    255, 255,  41,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,  12,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-     12,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  68,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-      1,   0,   0,  10,  82,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   1,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  63,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  63, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  84,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0, 192,  15,   0, 
-    192,  15,   0,   0,   0,   0, 
-      0, 192,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 240,   3, 
-      0, 240,   3,   0, 240,   3, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      6,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0, 252,   0,   0, 252,   0, 
-      0, 252,   0,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     18,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  63,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,  12,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  92,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   1,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   2,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  18,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  32,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     26, 144, 208,   0, 128,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-      3,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,  15,   0, 
-      0,   0,  14,   0,   0,   0, 
-     13,   0,   0,   0,  12,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-     11,   0,   0,   0,  10,   0, 
-      0,   0,   9,   0,   0,   0, 
-      8,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      7,   0,   0,   0,   6,   0, 
-      0,   0,   5,   0,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,  12,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,  30,   0, 
-      0,  10, 194,   0,  16,   0, 
-      2,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,  12,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  26, 144, 
-    208,   0, 128,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,  10, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  86,   5,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,  15,   0,   0,   0, 
-     14,   0,   0,   0,  13,   0, 
-      0,   0,  12,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  20,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-      3,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,  11,   0, 
-      0,   0,  10,   0,   0,   0, 
-      9,   0,   0,   0,   8,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  14,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-      3,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   7,   0, 
-      0,   0,   6,   0,   0,   0, 
-      5,   0,   0,   0,   4,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,  10, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,  86,   5,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  18,   0,   0,   1, 
-     32,   0,   0,   9,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  26, 144, 208,   0, 
-    128,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-     15,   0,   0,   0,  14,   0, 
-      0,   0,  13,   0,   0,   0, 
-     12,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,  10, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  86,   5,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,  11,   0,   0,   0, 
-     10,   0,   0,   0,   9,   0, 
-      0,   0,   8,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  11,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,  10, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  86,   5,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   7,   0,   0,   0, 
-      6,   0,   0,   0,   5,   0, 
-      0,   0,   4,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-     12,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-     30,   0,   0,  10, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  20,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     18,   0,   0,   1,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-      3,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,  15,   0, 
-      0,   0,  14,   0,   0,   0, 
-     13,   0,   0,   0,  12,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  29,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-     11,   0,   0,   0,  10,   0, 
-      0,   0,   9,   0,   0,   0, 
-      8,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      7,   0,   0,   0,   6,   0, 
-      0,   0,   5,   0,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,  12,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,  30,   0, 
-      0,  10, 194,   0,  16,   0, 
-      2,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     60,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,  12,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0, 254, 
-    255, 255,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  62,   0,   0, 128,  15, 
-      0,   0, 224,   3,   0,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  84,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,   0, 192,   7,   0, 
-      0, 240,   1,   0,   0, 124, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,  10, 146,   0,  16,   0, 
-      2,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   7,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 248,   0, 
-      0,   0,  62,   0,   0, 128, 
-     15,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      9,   0,   0,   0,  10,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,  31,   0,   0, 192,   7, 
-      0,   0, 240,   1,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,  11,   0,   0,   0, 
-     10,   0,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-     11,   0,   0,   0,  26,   0, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,  11,   0, 
-      0,   0,  42,   0,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0, 224,   0,   0, 
-      0, 248,   0,   0,   0,  62, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  18,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,  11,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,  13,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     13,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-     13,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  18,   0,  16,   0, 
-     14,   0,   0,   0,  10,   0, 
-     16,   0,  13,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-     34,   0,  16,   0,  14,   0, 
-      0,   0,  26,   0,  16,   0, 
-     13,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-      1,   0,   0,  10, 146,   0, 
-     16,   0,   3,   0,   0,   0, 
-      6,   4,  16,   0,  14,   0, 
-      0,   0,   2,  64,   0,   0, 
-    124,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     31,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,  12,   0,   0,   0, 
-     26,   0,  16,   0,  11,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-     11,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,  13,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0, 192,  30,   0,   0,   7, 
-     66,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     92,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  48,   0,   0,   1, 
-     79,   0,   0,   9,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26, 144, 208,   0, 128,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      3,   0,   4,   3,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     22,   0,   0,   1,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  48,   0,   0,   1, 
-     79,   0,   0,   9,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42, 144, 208,   0, 128,   0, 
-      0,   0,  26,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      3,   0,   4,   3,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     22,   0,   0,   1,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  48,   0,   0,   1, 
-     80,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   3,   0, 
-      4,   3,  10,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-     12,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,  12,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     22,   0,   0,   1,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0, 167,   0,   0,   9, 
-    114,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     70, 242,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0, 252,   1,   0, 
-    192,  31,   0,   0, 252,   1, 
-      0,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      5,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-    254,   0,   0, 224,  15,   0, 
-      0, 254,   0,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 114,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  68,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  19,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0, 127,   0,   0, 240,   7, 
-      0,   0, 127,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     84,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10,   0,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,  22,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0, 128,   0,   0, 
-      0, 248,   0,   0, 128,  63, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  18,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   9,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  84,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-     18,   0,  16,   0,  11,   0, 
-      0,   0,  10,   0,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7,  34,   0, 
-     16,   0,  11,   0,   0,   0, 
-     26,   0,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,   1,   0, 
-      0,  10, 146,   0,  16,   0, 
-      2,   0,   0,   0,   6,   4, 
-     16,   0,  11,   0,   0,   0, 
-      2,  64,   0,   0,  63,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     50,   0,  16,   0,   2,   0, 
-      0,   0, 150,   5,  16,   0, 
-      3,   0,   0,   0, 198,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  50,   0, 
-     16,   0,   2,   0,   0,   0, 
-    150,   5,  16,   0,   5,   0, 
-      0,   0,  70,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  50,   0,  16,   0, 
-      2,   0,   0,   0, 150,   5, 
-     16,   0,   7,   0,   0,   0, 
-     70,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     50,   0,  16,   0,   2,   0, 
-      0,   0, 150,   5,  16,   0, 
-      9,   0,   0,   0,  70,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     30,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,  64,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     84,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     84,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     48,   0,   0,   1,  79,   0, 
-      0,   9,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26, 144, 
-    208,   0, 128,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   3,   0, 
-      4,   3,  42,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,  54,   0,   0,   5, 
-    130,   0,  16,   0,  12,   0, 
-      0,   0,  58,   0,  16,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     48,   0,   0,   1,  80,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   3,   0,   4,   3, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,  12,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,  54,   0,   0,   5, 
-     34,   0,  16,   0,  12,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  96,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  25,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,  31,   0,   0,   0,   0, 
-    124,   0,   0,   0,   0, 240, 
-    192,  15,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  84,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     82,   0,  16,   0,   4,   0, 
-      0,   0,   6,   3,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,   1,   0, 
-      0,  10, 178,   0,  16,   0, 
-      3,   0,   0,   0,  70,   8, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0,   0, 224, 
-      3,   0,   0,   0, 128,  15, 
-      0,   0,   0,   0,   0, 240, 
-      3,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     76,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     62,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-      1,   0,   0,  10, 146,   0, 
-     16,   0,   1,   0,   0,   0, 
-      6,   4,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  30,   0,   0,  10, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  86,   5,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      2,   0,   0,   0,   3,   0, 
-      0,   0,   4,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  50,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     22,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  25,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  30,   0,   0,  10, 
-    242,   0,  16,   0,   4,   0, 
-      0,   0,  86,   5,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   5,   0,   0,   0, 
-      6,   0,   0,   0,   7,   0, 
-      0,   0,   8,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     29,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     31,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-      5,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   9,   0, 
-      0,   0,  10,   0,   0,   0, 
-     11,   0,   0,   0,  12,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   6,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     17,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,   9,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  30,   0,   0,  10, 
-    226,   0,  16,   0,   5,   0, 
-      0,   0,  86,   5,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,  14,   0, 
-      0,   0,  15,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  23,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     13,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,  12,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-     12,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  18,   0,   0,   1, 
-     32,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     68,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  21,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     18,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,   0, 127, 
-      0,   0,   0,   0, 192,  31, 
-    240,   7,   0,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     84,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  10,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     26,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-     63,   0,   0,   0,   0, 224, 
-      0, 248,   3,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  18,   0,  16,   0, 
-     12,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  88,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     15,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  96,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-      0,   0,   3,   0,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-      3,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   5,   0, 
-      0,   0,   6,   0,   0,   0, 
-      7,   0,   0,   0,   8,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     10,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     14,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  17,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  30,   0,   0,  10, 
-    242,   0,  16,   0,   4,   0, 
-      0,   0,  86,   5,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   9,   0,   0,   0, 
-     10,   0,   0,   0,  11,   0, 
-      0,   0,  12,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  18,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     21,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     23,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,  10, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-     13,   0,   0,   0,  14,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      6,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  27,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  26,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      6,   0,   0,   0,  26,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  30,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,  12,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-    130,   0,  16,   0,  12,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     20,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-    128,  63,   0,   0,   0,   0, 
-    224,  15, 248,   3,   0,   0, 
-      0,   0, 254,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  84,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     27,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   9,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  23,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 192,  31,   0,   0,   0, 
-      0, 240,   0, 252,   1,   0, 
-      0,   0,   0, 127,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,  12,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  68,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,  12,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-      0,   0,   3,   0,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  12,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,  10, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     86,   5,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      5,   0,   0,   0,   6,   0, 
-      0,   0,   7,   0,   0,   0, 
-      8,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  20,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,  12,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,  10, 242,   0,  16,   0, 
-      3,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   9,   0, 
-      0,   0,  10,   0,   0,   0, 
-     11,   0,   0,   0,  12,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     12,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,  10, 210,   0,  16,   0, 
-      1,   0,   0,   0,  86,   5, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,  13,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,  15,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  20,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-     12,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  18,   0,   0,   1, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 128,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,  11,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,   1,   0,   0,  10, 
-    210,   0,  16,   0,   1,   0, 
-      0,   0,   6,   9,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0, 192,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-    192,   7,   0, 124,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0,  12,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   4,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 248,   0, 
-    128,  15,   0,   0,   0,   0, 
-      0, 248,   0, 128,  15,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  68,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     18,   0,  16,   0,   6,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,   1,  64, 
-      0,   0,  21,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      9,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  17,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,  31, 
-      0, 240,   1,   0,   0,   0, 
-    240,   1,   0,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,  26,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   8,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,  22,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0, 224, 
-      0,   0,  62,   0, 224,   3, 
-      0,   0,   0,   0,   0,  62, 
-     60,   0,   0,   7,  18,   0, 
-     16,   0,  12,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      8,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  18,   0,  16,   0, 
-     10,   0,   0,   0,  10,   0, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  85,   0,   0,   7, 
-     34,   0,  16,   0,  10,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,  10, 146,   0, 
-     16,   0,   6,   0,   0,   0, 
-      6,   4,  16,   0,  10,   0, 
-      0,   0,   2,  64,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0, 124,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      6,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-      4,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  31,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   4,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  68,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,   1,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,  64, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  84,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  29,   0, 
-      0,   0,   1,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0, 128, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,  12,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  68,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  48,   0, 
-      0,   1,  79,   0,   0,   9, 
-     66,   0,  16,   0,   1,   0, 
-      0,   0,  26, 144, 208,   0, 
-    128,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   3,   0,   4,   3, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     66,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,  12,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   5, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  48,   0, 
-      0,   1,  80,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      3,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     60,   0,   0,   7, 130,   0, 
-     16,   0,  12,   0,   0,   0, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-     12,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1, 168,   0, 
-      0,   9, 242, 224,  17,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70,  14,  16,   0, 
-     12,   0,   0,   0,  21,   0, 
-      0,   1,  62,   0,   0,   1
-};
diff --git a/thirdparty/directxtex/Shaders/Compiled/BC7Encode_TryMode02CS.inc b/thirdparty/directxtex/Shaders/Compiled/BC7Encode_TryMode02CS.inc
deleted file mode 100644
index 072383a..0000000
--- a/thirdparty/directxtex/Shaders/Compiled/BC7Encode_TryMode02CS.inc
+++ /dev/null
@@ -1,4084 +0,0 @@
-#if 0
-//
-// Generated by Microsoft (R) D3D Shader Disassembler
-//
-//
-// Input signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Input
-//
-// Output signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Output
-cs_4_0
-dcl_globalFlags refactoringAllowed
-dcl_immediateConstantBuffer { { -0.000000, 15, 0, 0},
-                              { 65981199646559862278586368.000000, 15, 0, 0},
-                              { 15358528172589056.000000, 15, 0, 0},
-                              { 3584194248704.000000, 15, 0, 1},
-                              { -0.000000, 15, 0, 1},
-                              { -0.000000, 15, 0, 1},
-                              { 14680365989888.000000, 15, 0, 1},
-                              { 15362462362632192.000000, 15, 0, 2},
-                              { -0.000000, 15, 0, 2},
-                              { -0.000000, 15, 0, 2},
-                              { -0.000000, 15, 0, 2},
-                              { -0.000000, 15, 0, 2},
-                              { -0.000000, 15, 0, 3},
-                              { -0.000000, 15, 0, 3},
-                              { -0.000000, 15, 0, 3},
-                              { 0.000000, 15, 0, 3},
-                              { -0.000000, 15, 0, 4},
-                              { 0.000000, 2, 0, 4},
-                              { -0.000000, 8, 0, 4},
-                              { 22076467445760.000000, 2, 0, 4},
-                              { -0.000000, 2, 0, 5},
-                              { 70798013459086900396556288.000000, 8, 0, 5},
-                              { -0.000000, 8, 0, 5},
-                              { 0.000000, 15, 0, 5},
-                              { 0x0050a4a4, 2, 0, 6},
-                              { -0.000000, 8, 0, 6},
-                              { 0.000000, 2, 0, 6},
-                              { 17610885206241624413175808.000000, 2, 0, 6},
-                              { -0.000000, 8, 0, 6},
-                              { -0.000000, 8, 0, 7},
-                              { 22097854464.000000, 2, 0, 7},
-                              { 65888818352238724844093440.000000, 2, 0, 7},
-                              { -0.000000, 15, 0, 7},
-                              { 19411582976.000000, 15, 0, 8},
-                              { -0.000000, 6, 0, 8},
-                              { 0.000000, 8, 0, 8},
-                              { 0.000000, 2, 0, 8},
-                              { 0.000000, 8, 0, 9},
-                              { 0.000000, 15, 0, 9},
-                              { 22151331840.000000, 15, 0, 9},
-                              { 9304358912.000000, 2, 0, 9},
-                              { -0.000000, 8, 0, 10},
-                              { 271536072765004599787520.000000, 2, 0, 10},
-                              { -0.000000, 2, 0, 10},
-                              { 21517107200.000000, 2, 0, 10},
-                              { 12724757752857622655008768.000000, 15, 0, 10},
-                              { 1365.320801, 15, 0, 11},
-                              { 272006464738884193353728.000000, 6, 0, 11},
-                              { -0.000000, 6, 0, 11},
-                              { 5783798415360.000000, 2, 0, 11},
-                              { -0.000000, 6, 0, 12},
-                              { -0.000000, 8, 0, 12},
-                              { -0.000000, 15, 0, 12},
-                              { -0.000000, 15, 0, 12},
-                              { -0.000000, 2, 0, 13},
-                              { -0.000000, 2, 0, 13},
-                              { -0.000000, 15, 0, 13},
-                              { -0.000000, 15, 0, 13},
-                              { -0.000000, 15, 0, 14},
-                              { -0.000000, 15, 0, 14},
-                              { 4.007874, 15, 0, 14},
-                              { -0.000000, 2, 0, 14},
-                              { -0.000000, 2, 0, 15},
-                              { 0.000000, 15, 0, 15},
-                              { 0, 3, 15, 0},
-                              { 4, 3, 8, 0},
-                              { 9, 15, 8, 0},
-                              { 13, 15, 3, 0},
-                              { 17, 8, 15, 0},
-                              { 21, 3, 15, 1},
-                              { 26, 15, 3, 1},
-                              { 30, 15, 8, 1},
-                              { 34, 8, 15, 1},
-                              { 38, 8, 15, 1},
-                              { 43, 6, 15, 1},
-                              { 47, 6, 15, 1},
-                              { 51, 6, 15, 1},
-                              { 55, 5, 15, 1},
-                              { 60, 3, 15, 2},
-                              { 64, 3, 8, 2},
-                              { 0, 3, 15, 2},
-                              { 9, 3, 8, 2},
-                              { 18, 8, 15, 2},
-                              { 27, 15, 3, 2},
-                              { 37, 3, 15, 2},
-                              { 46, 3, 8, 2},
-                              { 55, 6, 15, 2},
-                              { 64, 10, 8, 3},
-                              { 0, 5, 3, 3},
-                              { 0, 8, 15, 3},
-                              { 0, 8, 6, 3},
-                              { 0, 6, 10, 3},
-                              { 0, 8, 15, 3},
-                              { 0, 5, 15, 3},
-                              { 0, 15, 10, 3},
-                              { 0, 15, 8, 3},
-                              { 0, 8, 15, 3},
-                              { 21, 15, 3, 4},
-                              { 43, 3, 15, 4},
-                              { 64, 5, 10, 4},
-                              { 0, 6, 10, 4},
-                              { 0, 10, 8, 4},
-                              { 0, 8, 9, 4},
-                              { 0, 15, 10, 4},
-                              { 0, 15, 6, 4},
-                              { 0, 3, 15, 4},
-                              { 0, 15, 8, 5},
-                              { 0, 5, 15, 5},
-                              { 0, 15, 3, 5},
-                              { 0, 15, 6, 5},
-                              { 0, 15, 6, 5},
-                              { 0, 15, 8, 5},
-                              { 0, 3, 15, 5},
-                              { 0, 15, 3, 5},
-                              { 0, 5, 15, 5},
-                              { 0, 5, 15, 6},
-                              { 0, 5, 15, 6},
-                              { 0, 8, 15, 6},
-                              { 0, 5, 15, 6},
-                              { 0, 10, 15, 6},
-                              { 0, 5, 15, 6},
-                              { 0, 10, 15, 6},
-                              { 0, 8, 15, 6},
-                              { 0, 13, 15, 6},
-                              { 0, 15, 3, 7},
-                              { 0, 12, 15, 7},
-                              { 0, 3, 15, 7},
-                              { 0, 3, 8, 7},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3} }
-dcl_constantbuffer CB0[2], immediateIndexed
-dcl_resource_texture2d (float,float,float,float) t0
-dcl_resource_structured t1, 16
-dcl_uav_structured u0, 16
-dcl_input vThreadIDInGroupFlattened
-dcl_input vThreadGroupID.x
-dcl_temps 29
-dcl_indexableTemp x0[12], 4
-dcl_indexableTemp x1[3], 4
-dcl_indexableTemp x2[3], 4
-dcl_indexableTemp x3[3], 4
-dcl_indexableTemp x4[3], 4
-dcl_indexableTemp x5[3], 4
-dcl_indexableTemp x6[3], 4
-dcl_tgsm_structured g0, 100, 64
-dcl_thread_group 64, 1, 1
-iadd r0.x, vThreadGroupID.x, cb0[1].x
-ult r1.xyzw, vThreadIDInGroupFlattened.xxxx, l(16, 32, 8, 4)
-if_nz r1.x
-  udiv r0.y, null, r0.x, cb0[0].y
-  imad r0.z, -r0.y, cb0[0].y, r0.x
-  ishl r0.z, r0.z, l(2)
-  ishl r0.y, r0.y, l(2)
-  and r0.w, vThreadIDInGroupFlattened.x, l(3)
-  iadd r2.x, r0.w, r0.z
-  ushr r0.z, vThreadIDInGroupFlattened.x, l(2)
-  iadd r2.y, r0.z, r0.y
-  mov r2.zw, l(0,0,0,0)
-  ld r2.xyzw, r2.xyzw, t0.xyzw
-  mul r2.xyzw, r2.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000)
-  ftou r2.xyzw, r2.xyzw
-  umin r2.xyzw, r2.xyzw, l(255, 255, 255, 255)
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(0), r2.xyzw
-endif 
-sync_g_t
-store_structured g0.x, vThreadIDInGroupFlattened.x, l(16), l(-1)
-movc r0.y, cb0[0].w, l(64), l(16)
-ult r0.y, vThreadIDInGroupFlattened.x, r0.y
-if_nz r0.y
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(64)
-  mov x0[0].x, l(-1)
-  mov x0[1].x, l(-1)
-  mov x0[2].x, l(-1)
-  mov x0[0].y, l(0)
-  mov x0[1].y, l(0)
-  mov x0[2].y, l(0)
-  mov x0[4].x, l(-1)
-  mov x0[5].x, l(-1)
-  mov x0[6].x, l(-1)
-  mov x0[4].y, l(0)
-  mov x0[5].y, l(0)
-  mov x0[6].y, l(0)
-  mov x0[8].x, l(-1)
-  mov x0[9].x, l(-1)
-  mov x0[10].x, l(-1)
-  mov x0[8].y, l(0)
-  mov x0[9].y, l(0)
-  mov x0[10].y, l(0)
-  iadd r0.z, r0.y, l(-64)
-  mov r0.w, l(0)
-  loop 
-    uge r2.x, r0.w, l(16)
-    breakc_nz r2.x
-    ld_structured r2.xyz, r0.w, l(0), g0.xyzx
-    ishl r2.w, r0.w, l(1)
-    ushr r2.w, icb[r0.z + 0].x, r2.w
-    and r2.w, r2.w, l(3)
-    ieq r3.x, r2.w, l(2)
-    if_nz r3.x
-      mov r3.x, x0[8].x
-      mov r3.y, x0[9].x
-      mov r3.z, x0[10].x
-      umin r3.xyz, r2.xyzx, r3.xyzx
-      mov x0[8].x, r3.x
-      mov x0[9].x, r3.y
-      mov x0[10].x, r3.z
-      mov r3.x, x0[8].y
-      mov r3.y, x0[9].y
-      mov r3.z, x0[10].y
-      umax r3.xyz, r2.xyzx, r3.xyzx
-      mov x0[8].y, r3.x
-      mov x0[9].y, r3.y
-      mov x0[10].y, r3.z
-    else 
-      ieq r2.w, r2.w, l(1)
-      if_nz r2.w
-        mov r3.x, x0[4].x
-        mov r3.y, x0[5].x
-        mov r3.z, x0[6].x
-        umin r3.xyz, r2.xyzx, r3.xyzx
-        mov x0[4].x, r3.x
-        mov x0[5].x, r3.y
-        mov x0[6].x, r3.z
-        mov r3.x, x0[4].y
-        mov r3.y, x0[5].y
-        mov r3.z, x0[6].y
-        umax r3.xyz, r2.xyzx, r3.xyzx
-        mov x0[4].y, r3.x
-        mov x0[5].y, r3.y
-        mov x0[6].y, r3.z
-      else 
-        mov r3.x, x0[0].x
-        mov r3.y, x0[1].x
-        mov r3.z, x0[2].x
-        umin r3.xyz, r2.xyzx, r3.xyzx
-        mov x0[0].x, r3.x
-        mov x0[1].x, r3.y
-        mov x0[2].x, r3.z
-        mov r3.x, x0[0].y
-        mov r3.y, x0[1].y
-        mov r3.z, x0[2].y
-        umax r2.xyz, r2.xyzx, r3.xyzx
-        mov x0[0].y, r2.x
-        mov x0[1].y, r2.y
-        mov x0[2].y, r2.z
-      endif 
-    endif 
-    iadd r0.w, r0.w, l(1)
-  endloop 
-  mov r2.x, x0[0].x
-  mov r2.y, x0[1].x
-  mov r2.z, x0[2].x
-  mov r3.x, x0[0].y
-  mov r3.y, x0[1].y
-  mov r3.z, x0[2].y
-  mov r4.x, x0[4].x
-  mov r4.y, x0[5].x
-  mov r4.z, x0[6].x
-  mov r5.x, x0[4].y
-  mov r5.y, x0[5].y
-  mov r5.z, x0[6].y
-  mov r6.x, x0[8].x
-  mov r6.y, x0[9].x
-  mov r6.z, x0[10].x
-  mov r7.x, x0[8].y
-  mov r7.y, x0[9].y
-  mov r7.z, x0[10].y
-  movc r0.w, cb0[0].w, l(1), l(4)
-  mov x1[0].x, l(0)
-  mov x1[1].x, l(0)
-  mov x1[2].x, l(0)
-  mov x2[0].x, l(-1)
-  mov x2[1].x, l(-1)
-  mov x2[2].x, l(-1)
-  imad r2.xyz, r2.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-  ushr r2.xyz, r2.xyzx, l(16)
-  and r8.xyz, r2.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-  imad r3.xyz, r3.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-  ushr r3.xyz, r3.xyzx, l(16)
-  and r9.xyz, r3.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-  ishl r2.xyz, r2.xyzx, l(3)
-  ushr r10.xyz, r2.xyzx, l(5)
-  or r2.xyz, r2.xyzx, r10.xyzx
-  ishl r3.xyz, r3.xyzx, l(3)
-  ushr r10.xyz, r3.xyzx, l(5)
-  or r3.xyz, r3.xyzx, r10.xyzx
-  imad r4.xyz, r4.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-  ushr r4.xyz, r4.xyzx, l(16)
-  and r10.xyz, r4.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-  imad r5.xyz, r5.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-  ushr r5.xyz, r5.xyzx, l(16)
-  and r11.xyz, r5.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-  ishl r4.xyz, r4.xyzx, l(3)
-  ushr r12.xyz, r4.xyzx, l(5)
-  or r4.xyz, r4.xyzx, r12.xyzx
-  ishl r5.xyz, r5.xyzx, l(3)
-  ushr r12.xyz, r5.xyzx, l(5)
-  or r5.xyz, r5.xyzx, r12.xyzx
-  imad r6.xyz, r6.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-  ushr r6.xyz, r6.xyzx, l(16)
-  and r12.xyz, r6.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-  imad r7.xyz, r7.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-  ushr r7.xyz, r7.xyzx, l(16)
-  and r13.xyz, r7.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-  ishl r6.xyz, r6.xyzx, l(3)
-  ushr r14.xyz, r6.xyzx, l(5)
-  or r6.xyz, r6.xyzx, r14.xyzx
-  ishl r7.xyz, r7.xyzx, l(3)
-  ushr r14.xyz, r7.xyzx, l(5)
-  or r7.xyz, r7.xyzx, r14.xyzx
-  mov r2.w, r3.z
-  mov r3.w, r2.y
-  mov r4.w, r5.z
-  mov r5.w, r4.y
-  mov r6.w, r7.z
-  mov r7.w, r6.y
-  mov r14.y, l(255)
-  mov r2.y, cb0[0].w
-  mov r15.x, l(0)
-  loop 
-    uge r3.z, r15.x, r0.w
-    breakc_nz r3.z
-    ieq r3.z, r2.y, l(2)
-    if_z r2.y
-      ushr r15.y, r15.x, l(1)
-      and r14.zw, r15.xxxy, l(0, 0, 1, 1)
-      iadd r16.xyz, r8.xyzx, r14.zzzz
-      ishl r16.xyz, r16.xyzx, l(3)
-      ushr r17.xyz, r16.xyzx, l(5)
-      or r16.xzw, r16.zzxy, r17.zzxy
-      iadd r17.xyz, r9.xyzx, r14.wwww
-      ishl r17.xyz, r17.xyzx, l(3)
-      ushr r18.xyz, r17.xyzx, l(5)
-      or r17.xyz, r17.yxzy, r18.yxzy
-      mov r16.y, r17.z
-      mov r17.w, r16.w
-      mov r14.zw, r17.wwwx
-      mov r17.x, r16.z
-    else 
-      mov r16.xy, r2.zwzz
-      mov r14.zw, r3.wwwy
-      mov r17.x, r2.x
-      mov r17.y, r3.x
-    endif 
-    mov x0[3].xy, l(255,255,0,0)
-    mov x0[2].xy, r16.xyxx
-    mov x0[1].xy, r14.zwzz
-    mov x0[0].xy, r17.xyxx
-    if_z r2.y
-      ushr r15.y, r15.x, l(1)
-      and r15.zw, r15.xxxy, l(0, 0, 1, 1)
-      iadd r18.xyz, r10.xyzx, r15.zzzz
-      ishl r18.xyz, r18.xyzx, l(3)
-      ushr r19.xyz, r18.xyzx, l(5)
-      or r18.xzw, r18.zzxy, r19.zzxy
-      iadd r19.xyz, r11.xyzx, r15.wwww
-      ishl r19.xyz, r19.xyzx, l(3)
-      ushr r20.xyz, r19.xyzx, l(5)
-      or r19.xyz, r19.yxzy, r20.yxzy
-      mov r18.y, r19.z
-      mov r19.w, r18.w
-      mov r15.zw, r19.wwwx
-      mov r19.x, r18.z
-    else 
-      mov r18.xy, r4.zwzz
-      mov r15.zw, r5.wwwy
-      mov r19.x, r4.x
-      mov r19.y, r5.x
-    endif 
-    mov x0[7].xy, l(255,255,0,0)
-    mov x0[6].xy, r18.xyxx
-    mov x0[5].xy, r15.zwzz
-    mov x0[4].xy, r19.xyxx
-    if_z r2.y
-      ushr r15.y, r15.x, l(1)
-      and r16.zw, r15.xxxy, l(0, 0, 1, 1)
-      iadd r20.xyz, r12.xyzx, r16.zzzz
-      ishl r20.xyz, r20.xyzx, l(3)
-      ushr r21.xyz, r20.xyzx, l(5)
-      or r20.xzw, r20.zzxy, r21.zzxy
-      iadd r21.xyz, r13.xyzx, r16.wwww
-      ishl r21.xyz, r21.xyzx, l(3)
-      ushr r22.xyz, r21.xyzx, l(5)
-      or r21.xyz, r21.yxzy, r22.yxzy
-      mov r20.y, r21.z
-      mov r21.w, r20.w
-      mov r16.zw, r21.wwwx
-      mov r21.x, r20.z
-    else 
-      mov r20.xy, r6.zwzz
-      mov r16.zw, r7.wwwy
-      mov r21.x, r6.x
-      mov r21.y, r7.x
-    endif 
-    mov x0[11].xy, l(255,255,0,0)
-    mov x0[10].xy, r20.xyxx
-    mov x0[9].xy, r16.zwzz
-    mov x0[8].xy, r21.xyxx
-    ineg r22.x, r17.x
-    ineg r22.y, r14.z
-    ineg r22.z, r16.x
-    mov r17.z, r14.w
-    mov r17.w, r16.y
-    iadd r17.xyz, r17.yzwy, r22.xyzx
-    mov x3[0].xyz, r17.xyzx
-    ineg r22.x, r19.x
-    ineg r22.y, r15.z
-    ineg r22.z, r18.x
-    mov r19.z, r15.w
-    mov r19.w, r18.y
-    iadd r15.yzw, r19.yyzw, r22.xxyz
-    mov x3[1].xyz, r15.yzwy
-    ineg r18.x, r21.x
-    ineg r18.y, r16.z
-    ineg r18.z, r20.x
-    mov r21.z, r16.w
-    mov r21.w, r20.y
-    iadd r16.xyz, r18.xyzx, r21.yzwy
-    mov x3[2].xyz, r16.xyzx
-    mov x3[2].w, l(0)
-    mov x3[1].w, l(0)
-    mov x3[0].w, l(0)
-    imul null, r14.zw, r17.xxxy, r17.xxxy
-    iadd r4.y, r14.w, r14.z
-    imad r4.y, r17.z, r17.z, r4.y
-    mov x4[0].x, r4.y
-    imul null, r14.zw, r15.yyyz, r15.yyyz
-    iadd r5.z, r14.w, r14.z
-    imad r5.z, r15.w, r15.w, r5.z
-    mov x4[1].x, r5.z
-    imul null, r14.zw, r16.xxxy, r16.xxxy
-    iadd r6.y, r14.w, r14.z
-    imad r6.y, r16.z, r16.z, r6.y
-    mov x4[2].x, r6.y
-    mov x5[0].x, l(0)
-    mov x5[1].x, icb[r0.y + 0].y
-    mov x5[2].x, icb[r0.y + 0].z
-    mov r7.z, l(0)
-    loop 
-      uge r8.w, r7.z, l(3)
-      breakc_nz r8.w
-      mov r16.xyzw, x3[r7.z + 0].xyzw
-      mov r8.w, x5[r7.z + 0].x
-      ld_structured r17.xyzw, r8.w, l(0), g0.xyzw
-      ishl r8.w, r7.z, l(2)
-      mov r9.w, x0[r8.w + 0].x
-      mov r10.w, x0[r8.w + 1].x
-      mov r11.w, x0[r8.w + 2].x
-      mov r12.w, x0[r8.w + 3].x
-      ineg r18.x, r9.w
-      ineg r18.y, r10.w
-      ineg r18.z, r11.w
-      ineg r18.w, r12.w
-      iadd r17.xyzw, r17.xyzw, r18.xyzw
-      imul null, r14.zw, r16.xxxy, r17.xxxy
-      iadd r13.w, r14.w, r14.z
-      imad r13.w, r16.z, r17.z, r13.w
-      imad r13.w, r16.w, r17.w, r13.w
-      mov r14.z, x4[r7.z + 0].x
-      ilt r14.w, l(0), r14.z
-      ilt r15.y, l(0), r13.w
-      and r14.w, r14.w, r15.y
-      itof r13.w, r13.w
-      mul r13.w, r13.w, l(63.499989)
-      ftou r13.w, r13.w
-      ishl r14.z, r14.z, l(5)
-      ult r13.w, r14.z, r13.w
-      and r13.w, r13.w, r14.w
-      if_nz r13.w
-        ineg r16.xyzw, r16.xyzw
-        mov x3[r7.z + 0].xyzw, r16.xyzw
-        mov r13.w, x0[r8.w + 0].y
-        mov r14.z, x0[r8.w + 1].y
-        mov r14.w, x0[r8.w + 2].y
-        mov r15.y, x0[r8.w + 3].y
-        mov x0[r8.w + 0].x, r13.w
-        mov x0[r8.w + 1].x, r14.z
-        mov x0[r8.w + 2].x, r14.w
-        mov x0[r8.w + 3].x, r15.y
-        mov x0[r8.w + 0].y, r9.w
-        mov x0[r8.w + 1].y, r10.w
-        mov x0[r8.w + 2].y, r11.w
-        mov x0[r8.w + 3].y, r12.w
-      endif 
-      iadd r7.z, r7.z, l(1)
-    endloop 
-    mov x6[0].x, l(0)
-    mov x6[1].x, l(0)
-    mov x6[2].x, l(0)
-    mov r16.xyzw, x3[2].xyzw
-    mov r7.z, x0[8].x
-    mov r8.w, x0[9].x
-    mov r9.w, x0[10].x
-    mov r10.w, x0[11].x
-    ineg r17.x, r7.z
-    ineg r17.y, r8.w
-    ineg r17.z, r9.w
-    ineg r17.w, r10.w
-    ige r11.w, l(0), r6.y
-    itof r12.w, r6.y
-    movc r15.yzw, r3.zzzz, l(0,128,3,32), l(0,64,7,16)
-    mov r18.xyzw, x3[1].xyzw
-    mov r3.z, x0[4].x
-    mov r13.w, x0[5].x
-    mov r14.z, x0[6].x
-    mov r14.w, x0[7].x
-    ineg r19.x, r3.z
-    ineg r19.y, r13.w
-    ineg r19.zw, r14.zzzw
-    ige r20.x, l(0), r5.z
-    itof r20.y, r5.z
-    mov r21.xyzw, x3[0].xyzw
-    mov r20.z, x0[0].x
-    mov r20.w, x0[1].x
-    mov r22.x, x0[2].x
-    mov r22.y, x0[3].x
-    ineg r23.xy, r20.zwzz
-    ineg r23.zw, r22.xxxy
-    ige r22.z, l(0), r4.y
-    itof r22.w, r4.y
-    mov r24.x, l(0)
-    loop 
-      uge r24.y, r24.x, l(16)
-      breakc_nz r24.y
-      ishl r24.y, r24.x, l(1)
-      ushr r24.y, icb[r0.z + 0].x, r24.y
-      and r24.y, r24.y, l(3)
-      ieq r24.zw, r24.yyyy, l(0, 0, 2, 1)
-      if_nz r24.z
-        ld_structured r25.xyzw, r24.x, l(0), g0.xyzw
-        iadd r25.xyzw, r17.xyzw, r25.xyzw
-        imul null, r25.xy, r16.xyxx, r25.xyxx
-        iadd r25.x, r25.y, r25.x
-        imad r25.x, r16.z, r25.z, r25.x
-        imad r25.x, r16.w, r25.w, r25.x
-        ige r25.y, l(0), r25.x
-        or r25.y, r11.w, r25.y
-        ilt r25.z, r25.x, r6.y
-        itof r25.x, r25.x
-        mul r25.x, r25.x, l(63.499989)
-        div r25.x, r25.x, r12.w
-        ftou r25.x, r25.x
-        iadd r25.x, r15.y, r25.x
-        movc r25.x, r25.z, icb[r25.x + 0].w, r15.z
-        movc r25.x, r25.y, l(0), r25.x
-      else 
-        ieq r25.y, r24.y, l(1)
-        if_nz r25.y
-          ld_structured r26.xyzw, r24.x, l(0), g0.xyzw
-          iadd r26.xyzw, r19.xyzw, r26.xyzw
-          imul null, r25.yz, r18.xxyx, r26.xxyx
-          iadd r25.y, r25.z, r25.y
-          imad r25.y, r18.z, r26.z, r25.y
-          imad r25.y, r18.w, r26.w, r25.y
-          ige r25.z, l(0), r25.y
-          or r25.z, r20.x, r25.z
-          ilt r25.w, r25.y, r5.z
-          itof r25.y, r25.y
-          mul r25.y, r25.y, l(63.499989)
-          div r25.y, r25.y, r20.y
-          ftou r25.y, r25.y
-          iadd r25.y, r15.y, r25.y
-          movc r25.y, r25.w, icb[r25.y + 0].w, r15.z
-          movc r25.x, r25.z, l(0), r25.y
-        else 
-          ld_structured r26.xyzw, r24.x, l(0), g0.xyzw
-          iadd r26.xyzw, r23.xyzw, r26.xyzw
-          imul null, r25.yz, r21.xxyx, r26.xxyx
-          iadd r25.y, r25.z, r25.y
-          imad r25.y, r21.z, r26.z, r25.y
-          imad r25.y, r21.w, r26.w, r25.y
-          ige r25.z, l(0), r25.y
-          or r25.z, r22.z, r25.z
-          ilt r25.w, r25.y, r4.y
-          itof r25.y, r25.y
-          mul r25.y, r25.y, l(63.499989)
-          div r25.y, r25.y, r22.w
-          ftou r25.y, r25.y
-          iadd r25.y, r15.y, r25.y
-          movc r25.y, r25.w, icb[r25.y + 0].w, r15.z
-          movc r25.x, r25.z, l(0), r25.y
-        endif 
-      endif 
-      iadd r25.x, r15.w, r25.x
-      iadd r25.y, l(64), -icb[r25.x + 64].x
-      ishl r24.y, r24.y, l(2)
-      mov r26.x, x0[r24.y + 0].x
-      mov r26.y, x0[r24.y + 1].x
-      mov r26.z, x0[r24.y + 2].x
-      mov r27.x, x0[r24.y + 0].y
-      mov r27.y, x0[r24.y + 1].y
-      mov r27.z, x0[r24.y + 2].y
-      imul null, r25.xzw, r27.xxyz, icb[r25.x + 64].xxxx
-      imad r25.xyz, r25.yyyy, r26.xyzx, r25.xzwx
-      iadd r25.xyz, r25.xyzx, l(32, 32, 32, 0)
-      ushr r25.xyw, r25.xyxz, l(6)
-      ld_structured r26.xyzw, r24.x, l(0), g0.xyzw
-      ult r27.xyz, r25.xywx, r26.xyzx
-      mov r25.z, r26.x
-      movc r27.xw, r27.xxxx, r25.zzzx, r25.xxxz
-      mov r25.xz, r26.yyzy
-      movc r25.xyzw, r27.yyzz, r25.xyzw, r25.yxwz
-      ult r24.y, l(255), r26.w
-      mov r14.x, r26.w
-      movc r26.xw, r24.yyyy, r14.yyyx, r14.xxxy
-      ineg r28.x, r27.w
-      ineg r28.yz, r25.yywy
-      ineg r28.w, r26.x
-      mov r26.x, r27.x
-      mov r26.yz, r25.xxzx
-      iadd r25.xyzw, r28.xyzw, r26.xyzw
-      imul null, r25.xy, r25.xyxx, r25.xyxx
-      iadd r14.x, r25.y, r25.x
-      imad r14.x, r25.z, r25.z, r14.x
-      utof r14.x, r14.x
-      utof r24.y, r25.w
-      mul r24.y, r24.y, r24.y
-      mad r14.x, r24.y, cb0[1].z, r14.x
-      ftou r14.x, r14.x
-      mov r24.y, x6[2].x
-      iadd r25.x, r14.x, r24.y
-      movc r24.y, r24.z, r25.x, r24.y
-      mov x6[2].x, r24.y
-      not r24.yz, r24.zzwz
-      and r24.w, r24.w, r24.y
-      mov r25.x, x6[1].x
-      iadd r25.y, r14.x, r25.x
-      movc r24.w, r24.w, r25.y, r25.x
-      mov x6[1].x, r24.w
-      and r24.y, r24.z, r24.y
-      mov r24.z, x6[0].x
-      iadd r14.x, r14.x, r24.z
-      movc r14.x, r24.y, r14.x, r24.z
-      mov x6[0].x, r14.x
-      iadd r24.x, r24.x, l(1)
-    endloop 
-    mov r3.z, x6[0].x
-    mov r4.y, x2[0].x
-    ult r5.z, r3.z, r4.y
-    umin r3.z, r3.z, r4.y
-    mov x2[0].x, r3.z
-    mov r3.z, x1[0].x
-    movc r3.z, r5.z, r15.x, r3.z
-    mov x1[0].x, r3.z
-    mov r3.z, x6[1].x
-    mov r4.y, x2[1].x
-    ult r5.z, r3.z, r4.y
-    umin r3.z, r3.z, r4.y
-    mov x2[1].x, r3.z
-    mov r3.z, x1[1].x
-    movc r3.z, r5.z, r15.x, r3.z
-    mov x1[1].x, r3.z
-    mov r3.z, x6[2].x
-    mov r4.y, x2[2].x
-    ult r5.z, r3.z, r4.y
-    umin r3.z, r3.z, r4.y
-    mov x2[2].x, r3.z
-    mov r3.z, x1[2].x
-    movc r3.z, r5.z, r15.x, r3.z
-    mov x1[2].x, r3.z
-    iadd r15.x, r15.x, l(1)
-  endloop 
-  mov r0.z, x2[0].x
-  mov r0.w, x2[1].x
-  iadd r0.z, r0.w, r0.z
-  mov r0.w, x2[2].x
-  iadd r0.z, r0.w, r0.z
-  store_structured g0.x, vThreadIDInGroupFlattened.x, l(16), r0.z
-  store_structured g0.x, vThreadIDInGroupFlattened.x, l(24), r0.y
-  mov r0.y, x1[2].x
-  ishl r0.y, r0.y, l(4)
-  mov r0.z, x1[1].x
-  ishl r0.z, r0.z, l(2)
-  or r0.y, r0.z, r0.y
-  mov r0.z, x1[0].x
-  or r0.y, r0.z, r0.y
-  store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r0.y
-endif 
-sync_g_t
-if_nz r1.y
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(32)
-  ld_structured r3.x, r0.y, l(16), g0.xxxx
-  ld_structured r4.x, r0.y, l(24), g0.xxxx
-  ld_structured r5.x, r0.y, l(32), g0.xxxx
-  ult r0.y, r3.x, r2.x
-  if_nz r0.y
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(16), r3.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(24), r4.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r5.x
-  endif 
-endif 
-sync_g_t
-if_nz r1.x
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(16)
-  ld_structured r3.x, r0.y, l(16), g0.xxxx
-  ld_structured r4.x, r0.y, l(24), g0.xxxx
-  ld_structured r5.x, r0.y, l(32), g0.xxxx
-  ult r0.y, r3.x, r2.x
-  if_nz r0.y
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(16), r3.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(24), r4.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r5.x
-  endif 
-endif 
-sync_g_t
-if_nz r1.z
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r3.x, r0.y, l(16), g0.xxxx
-  ld_structured r4.x, r0.y, l(24), g0.xxxx
-  ld_structured r5.x, r0.y, l(32), g0.xxxx
-  ult r0.y, r3.x, r2.x
-  if_nz r0.y
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(16), r3.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(24), r4.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r5.x
-  endif 
-endif 
-sync_g_t
-if_nz r1.w
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r2.x, r0.y, l(16), g0.xxxx
-  ld_structured r3.x, r0.y, l(24), g0.xxxx
-  ld_structured r4.x, r0.y, l(32), g0.xxxx
-  ult r0.y, r2.x, r1.x
-  if_nz r0.y
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(16), r2.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(24), r3.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r4.x
-  endif 
-endif 
-sync_g_t
-ult r0.yz, vThreadIDInGroupFlattened.xxxx, l(0, 2, 1, 0)
-if_nz r0.y
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r2.x, r0.y, l(16), g0.xxxx
-  ld_structured r3.x, r0.y, l(24), g0.xxxx
-  ld_structured r4.x, r0.y, l(32), g0.xxxx
-  ult r0.y, r2.x, r1.x
-  if_nz r0.y
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(16), r2.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(24), r3.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r4.x
-  endif 
-endif 
-sync_g_t
-if_nz r0.z
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r2.x, r0.y, l(16), g0.xxxx
-  ld_structured r3.x, r0.y, l(24), g0.xxxx
-  ld_structured r4.x, r0.y, l(32), g0.xxxx
-  ult r0.y, r2.x, r1.x
-  if_nz r0.y
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(16), r2.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(24), r3.x
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r4.x
-  endif 
-  ld_structured r1.x, r0.x, l(0), t1.xxxx
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  ult r0.y, r2.x, r1.x
-  if_nz r0.y
-    ld_structured r2.z, vThreadIDInGroupFlattened.x, l(24), g0.xxxx
-    ld_structured r2.w, vThreadIDInGroupFlattened.x, l(32), g0.xxxx
-    mov r2.y, cb0[0].w
-  else 
-    ld_structured r2.xyzw, r0.x, l(0), t1.xyzw
-  endif 
-  store_structured u0.xyzw, r0.x, l(0), r2.xyzw
-endif 
-ret 
-// Approximately 0 instruction slots used
-#endif
-
-const BYTE BC7Encode_TryMode02CS[] =
-{
-     68,  88,  66,  67, 145, 232, 
-    246,  57,  30, 232,  55,  85, 
-    166, 107, 154, 101, 228,  76, 
-     33,  91,   1,   0,   0,   0, 
-    136,  75,   0,   0,   3,   0, 
-      0,   0,  44,   0,   0,   0, 
-     60,   0,   0,   0,  76,   0, 
-      0,   0,  73,  83,  71,  78, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     79,  83,  71,  78,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  83,  72, 
-     69,  88,  52,  75,   0,   0, 
-     64,   0,   5,   0, 205,  18, 
-      0,   0, 106,   8,   0,   1, 
-     53,  24,   0,   0,   2,   3, 
-      0,   0,  80,  80, 104, 170, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     64,  80,  90, 106,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  66, 
-     90,  90,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 168, 160,  80,  84, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0, 165, 165,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  80,  80, 
-    160, 160,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0, 160, 160,  85,  85, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     80,  80,  90,  90,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-     85, 170,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,  85,  85, 170, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,  85, 170, 170,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0, 144, 144, 
-    144, 144,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0, 148, 148, 148, 148, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-    164, 164, 164, 164,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  80, 148, 
-    165, 169,  15,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  80,  66,  10,  42, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     64,  80, 148, 165,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  84,  80, 
-     66,  10,   2,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0, 165, 165, 165, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-    160, 160, 160,  85,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  84,  84, 
-    168, 168,   2,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  64,  64, 106, 106, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,  80, 164, 164,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   0,   5, 
-     26,  26,  15,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0, 164, 164,  80,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-    144, 144, 165, 170,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  20, 105, 
-    105,  20,   2,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   0,  20, 105, 105, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-    160, 133, 133, 160,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  20,  20, 
-    130, 170,   8,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,  80, 164, 164,  80, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   2,  90, 106,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,   0, 128, 
-    165, 169,  15,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0, 168, 160, 144,  80, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     80, 144, 160, 168,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  36,  36, 
-     36,  36,   8,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,   0,  85, 170,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     36,  73, 146,  36,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      9,   0,   0,   0,  36, 146, 
-     73,  36,  15,   0,   0,   0, 
-      0,   0,   0,   0,   9,   0, 
-      0,   0,  80,  10, 165,  80, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-     80, 165,  10,  80,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      9,   0,   0,   0,  68,  68, 
-    170, 170,   8,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   0,   0, 102, 102, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-    160, 165, 160, 165,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,   0,   0, 160,  80, 
-    160,  80,   2,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,  40, 105,  40, 105, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-     68, 170, 170,  68,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-     11,   0,   0,   0,   0, 102, 
-    102, 102,   6,   0,   0,   0, 
-      0,   0,   0,   0,  11,   0, 
-      0,   0,  68,  68,  68, 170, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,  11,   0,   0,   0, 
-    168,  84, 168,  84,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     11,   0,   0,   0, 128, 149, 
-    128, 149,   6,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0,   0, 150, 150, 150, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,  12,   0,   0,   0, 
-    168,  84,  84, 168,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-     12,   0,   0,   0, 128, 149, 
-    149, 128,  15,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0,  20,  20,  20, 170, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  13,   0,   0,   0, 
-      0,   0, 150, 150,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,  20,  20, 
-    170, 170,  15,   0,   0,   0, 
-      0,   0,   0,   0,  13,   0, 
-      0,   0, 160,  80,  80, 160, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  13,   0,   0,   0, 
-    160, 165, 165, 160,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,   0,   0, 
-      0, 150,  15,   0,   0,   0, 
-      0,   0,   0,   0,  14,   0, 
-      0,   0, 128,  64, 128,  64, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  14,   0,   0,   0, 
-    168, 169, 168, 169,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,  68, 170, 
-    170, 170,   2,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,  84,  82,  74,  42, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   3,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-     15,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,  17,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  21,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   0,  15,   0,   0,   0, 
-      8,   0,   0,   0,   1,   0, 
-      0,   0,  34,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   0, 
-     38,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      1,   0,   0,   0,  43,   0, 
-      0,   0,   6,   0,   0,   0, 
-     15,   0,   0,   0,   1,   0, 
-      0,   0,  47,   0,   0,   0, 
-      6,   0,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   0, 
-     51,   0,   0,   0,   6,   0, 
-      0,   0,  15,   0,   0,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   1,   0, 
-      0,   0,  60,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   2,   0,   0,   0, 
-     64,   0,   0,   0,   3,   0, 
-      0,   0,   8,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   2,   0, 
-      0,   0,   9,   0,   0,   0, 
-      3,   0,   0,   0,   8,   0, 
-      0,   0,   2,   0,   0,   0, 
-     18,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      2,   0,   0,   0,  27,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   2,   0, 
-      0,   0,  37,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   2,   0,   0,   0, 
-     46,   0,   0,   0,   3,   0, 
-      0,   0,   8,   0,   0,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   0,   6,   0,   0,   0, 
-     15,   0,   0,   0,   2,   0, 
-      0,   0,  64,   0,   0,   0, 
-     10,   0,   0,   0,   8,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   3,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,   6,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  10,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,  10,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      8,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-     21,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      4,   0,   0,   0,  43,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   4,   0, 
-      0,   0,  64,   0,   0,   0, 
-      5,   0,   0,   0,  10,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  10,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-      8,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,   9,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,  10,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   8,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   6,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   8,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-     15,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,  15,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,  12,   0,   0,   0, 
-     15,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   8,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  89,   0,   0,   4, 
-     70, 142,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     88,  24,   0,   4,   0, 112, 
-     16,   0,   0,   0,   0,   0, 
-     85,  85,   0,   0, 162,   0, 
-      0,   4,   0, 112,  16,   0, 
-      1,   0,   0,   0,  16,   0, 
-      0,   0, 158,   0,   0,   4, 
-      0, 224,  17,   0,   0,   0, 
-      0,   0,  16,   0,   0,   0, 
-     95,   0,   0,   2,   0,  64, 
-      2,   0,  95,   0,   0,   2, 
-     18,  16,   2,   0, 104,   0, 
-      0,   2,  29,   0,   0,   0, 
-    105,   0,   0,   4,   0,   0, 
-      0,   0,  12,   0,   0,   0, 
-      4,   0,   0,   0, 105,   0, 
-      0,   4,   1,   0,   0,   0, 
-      3,   0,   0,   0,   4,   0, 
-      0,   0, 105,   0,   0,   4, 
-      2,   0,   0,   0,   3,   0, 
-      0,   0,   4,   0,   0,   0, 
-    105,   0,   0,   4,   3,   0, 
-      0,   0,   3,   0,   0,   0, 
-      4,   0,   0,   0, 105,   0, 
-      0,   4,   4,   0,   0,   0, 
-      3,   0,   0,   0,   4,   0, 
-      0,   0, 105,   0,   0,   4, 
-      5,   0,   0,   0,   3,   0, 
-      0,   0,   4,   0,   0,   0, 
-    105,   0,   0,   4,   6,   0, 
-      0,   0,   3,   0,   0,   0, 
-      4,   0,   0,   0, 160,   0, 
-      0,   5,   0, 240,  17,   0, 
-      0,   0,   0,   0, 100,   0, 
-      0,   0,  64,   0,   0,   0, 
-    155,   0,   0,   4,  64,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      0,   0,   0,   0,  10,  16, 
-      2,   0,  10, 128,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  79,   0,   0,   9, 
-    242,   0,  16,   0,   1,   0, 
-      0,   0,   6,  64,   2,   0, 
-      2,  64,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-      8,   0,   0,   0,   4,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  78,   0,   0,   9, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,   0, 208,   0,   0, 
-     10,   0,  16,   0,   0,   0, 
-      0,   0,  26, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  35,   0,   0,  11, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16, 128, 
-     65,   0,   0,   0,   0,   0, 
-      0,   0,  26, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   6,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   8, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  45,   0, 
-      0,   7, 242,   0,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-     70, 126,  16,   0,   0,   0, 
-      0,   0,  56,   0,   0,  10, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 127,  67, 
-      0,   0, 127,  67,   0,   0, 
-    127,  67,   0,   0, 127,  67, 
-     28,   0,   0,   5, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   2,   0, 
-      0,   0,  84,   0,   0,  10, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0, 255,   0,   0,   0, 
-    255,   0,   0,   0, 255,   0, 
-      0,   0, 255,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70,  14,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,  64, 
-      0,   0, 255, 255, 255, 255, 
-     55,   0,   0,  10,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  79,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 192, 255, 
-    255, 255,  54,   0,   0,   5, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  48,   0, 
-      0,   1,  80,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      3,   0,   4,   3,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9, 114,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  70, 242, 
-     17,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   8, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10, 144, 
-    144,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  32,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   9,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,  84,   0,   0,   7, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   0,   0,   0,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   0,   0,   0,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-     83,   0,   0,   7, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-    130,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     84,   0,   0,   7, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-      3,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      3,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-      3,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  83,   0, 
-      0,   7, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     84,   0,   0,   7, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-      3,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      3,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-      3,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  83,   0, 
-      0,   7, 114,   0,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-     55,   0,   0,  10, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      1,   0,   0,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      2,   0,   0,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  35,   0, 
-      0,  15, 114,   0,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-     31,  31,   0,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0,   0,   0,   0,   0, 
-     35,   0,   0,  15, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,  10,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,   3,   0, 
-      0,   0,  70,   2,  16,   0, 
-      3,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-      3,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-     70,   2,  16,   0,  10,   0, 
-      0,   0,  35,   0,   0,  15, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   2,  64, 
-      0,   0,  31,  31,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-      0,   0,   0,   0,  35,   0, 
-      0,  15, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      2,  64,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-     31,  31,   0,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   4,   0, 
-      0,   0,  70,   2,  16,   0, 
-      4,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,   5,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-     35,   0,   0,  15, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0,   0,   0, 
-      0,   0,  35,   0,   0,  15, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,  31,  31,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-      6,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  14,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-     14,   0,   0,   0,   1,  64, 
-      0,   0, 255,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  48,   0,   0,   1, 
-     80,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,  15,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   3,   0, 
-      4,   3,  42,   0,  16,   0, 
-      3,   0,   0,   0,  32,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  31,   0,   0,   3, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-     34,   0,  16,   0,  15,   0, 
-      0,   0,  10,   0,  16,   0, 
-     15,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,  10, 194,   0, 
-     16,   0,  14,   0,   0,   0, 
-      6,   4,  16,   0,  15,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-     16,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-    166,  10,  16,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  16,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  60,   0, 
-      0,   7, 210,   0,  16,   0, 
-     16,   0,   0,   0, 166,   4, 
-     16,   0,  16,   0,   0,   0, 
-    166,   4,  16,   0,  17,   0, 
-      0,   0,  30,   0,   0,   7, 
-    114,   0,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-      9,   0,   0,   0, 246,  15, 
-     16,   0,  14,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,   2,  16,   0,  17,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     18,   0,   0,   0,  70,   2, 
-     16,   0,  17,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,  17,   0, 
-      0,   0,  22,   6,  16,   0, 
-     17,   0,   0,   0,  22,   6, 
-     16,   0,  18,   0,   0,   0, 
-     54,   0,   0,   5,  34,   0, 
-     16,   0,  16,   0,   0,   0, 
-     42,   0,  16,   0,  17,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,  17,   0, 
-      0,   0,  58,   0,  16,   0, 
-     16,   0,   0,   0,  54,   0, 
-      0,   5, 194,   0,  16,   0, 
-     14,   0,   0,   0, 246,   3, 
-     16,   0,  17,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,  17,   0,   0,   0, 
-     42,   0,  16,   0,  16,   0, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   5,  50,   0, 
-     16,   0,  16,   0,   0,   0, 
-    230,  10,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   5, 
-    194,   0,  16,   0,  14,   0, 
-      0,   0, 246,   7,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-     17,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     54,   0,   0,   5,  34,   0, 
-     16,   0,  17,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-     54,   0,   0,   9,  50,  48, 
-     32,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0, 255,   0,   0,   0, 
-    255,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  50,  48, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  70,   0, 
-     16,   0,  16,   0,   0,   0, 
-     54,   0,   0,   6,  50,  48, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0, 230,  10, 
-     16,   0,  14,   0,   0,   0, 
-     54,   0,   0,   6,  50,  48, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  70,   0, 
-     16,   0,  17,   0,   0,   0, 
-     31,   0,   0,   3,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     85,   0,   0,   7,  34,   0, 
-     16,   0,  15,   0,   0,   0, 
-     10,   0,  16,   0,  15,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-     15,   0,   0,   0,   6,   4, 
-     16,   0,  15,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-    114,   0,  16,   0,  18,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0, 166,  10, 
-     16,   0,  15,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  18,   0,   0,   0, 
-     70,   2,  16,   0,  18,   0, 
-      0,   0,   1,  64,   0,   0, 
-      3,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  18,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  60,   0,   0,   7, 
-    210,   0,  16,   0,  18,   0, 
-      0,   0, 166,   4,  16,   0, 
-     18,   0,   0,   0, 166,   4, 
-     16,   0,  19,   0,   0,   0, 
-     30,   0,   0,   7, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0, 246,  15,  16,   0, 
-     15,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     22,   6,  16,   0,  19,   0, 
-      0,   0,  22,   6,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-     18,   0,   0,   0,  42,   0, 
-     16,   0,  19,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,  19,   0,   0,   0, 
-     58,   0,  16,   0,  18,   0, 
-      0,   0,  54,   0,   0,   5, 
-    194,   0,  16,   0,  15,   0, 
-      0,   0, 246,   3,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-     19,   0,   0,   0,  42,   0, 
-     16,   0,  18,   0,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   5,  50,   0,  16,   0, 
-     18,   0,   0,   0, 230,  10, 
-     16,   0,   4,   0,   0,   0, 
-     54,   0,   0,   5, 194,   0, 
-     16,   0,  15,   0,   0,   0, 
-    246,   7,  16,   0,   5,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-     19,   0,   0,   0,  10,   0, 
-     16,   0,   5,   0,   0,   0, 
-     21,   0,   0,   1,  54,   0, 
-      0,   9,  50,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255,   0,   0,   0, 255,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  50,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  70,   0,  16,   0, 
-     18,   0,   0,   0,  54,   0, 
-      0,   6,  50,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0, 230,  10,  16,   0, 
-     15,   0,   0,   0,  54,   0, 
-      0,   6,  50,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  70,   0,  16,   0, 
-     19,   0,   0,   0,  31,   0, 
-      0,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7,  34,   0,  16,   0, 
-     15,   0,   0,   0,  10,   0, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,  16,   0, 
-      0,   0,   6,   4,  16,   0, 
-     15,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0, 166,  10,  16,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     20,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  21,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     60,   0,   0,   7, 210,   0, 
-     16,   0,  20,   0,   0,   0, 
-    166,   4,  16,   0,  20,   0, 
-      0,   0, 166,   4,  16,   0, 
-     21,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-     21,   0,   0,   0,  70,   2, 
-     16,   0,  13,   0,   0,   0, 
-    246,  15,  16,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  21,   0, 
-      0,   0,  70,   2,  16,   0, 
-     21,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,  22,   0,   0,   0, 
-     70,   2,  16,   0,  21,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-     21,   0,   0,   0,  22,   6, 
-     16,   0,  21,   0,   0,   0, 
-     22,   6,  16,   0,  22,   0, 
-      0,   0,  54,   0,   0,   5, 
-     34,   0,  16,   0,  20,   0, 
-      0,   0,  42,   0,  16,   0, 
-     21,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-     21,   0,   0,   0,  58,   0, 
-     16,   0,  20,   0,   0,   0, 
-     54,   0,   0,   5, 194,   0, 
-     16,   0,  16,   0,   0,   0, 
-    246,   3,  16,   0,  21,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,  21,   0, 
-      0,   0,  42,   0,  16,   0, 
-     20,   0,   0,   0,  18,   0, 
-      0,   1,  54,   0,   0,   5, 
-     50,   0,  16,   0,  20,   0, 
-      0,   0, 230,  10,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   5, 194,   0,  16,   0, 
-     16,   0,   0,   0, 246,   7, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,  21,   0,   0,   0, 
-     10,   0,  16,   0,   6,   0, 
-      0,   0,  54,   0,   0,   5, 
-     34,   0,  16,   0,  21,   0, 
-      0,   0,  10,   0,  16,   0, 
-      7,   0,   0,   0,  21,   0, 
-      0,   1,  54,   0,   0,   9, 
-     50,  48,  32,   0,   0,   0, 
-      0,   0,  11,   0,   0,   0, 
-      2,  64,   0,   0, 255,   0, 
-      0,   0, 255,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     50,  48,  32,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-     70,   0,  16,   0,  20,   0, 
-      0,   0,  54,   0,   0,   6, 
-     50,  48,  32,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-    230,  10,  16,   0,  16,   0, 
-      0,   0,  54,   0,   0,   6, 
-     50,  48,  32,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     70,   0,  16,   0,  21,   0, 
-      0,   0,  40,   0,   0,   5, 
-     18,   0,  16,   0,  22,   0, 
-      0,   0,  10,   0,  16,   0, 
-     17,   0,   0,   0,  40,   0, 
-      0,   5,  34,   0,  16,   0, 
-     22,   0,   0,   0,  42,   0, 
-     16,   0,  14,   0,   0,   0, 
-     40,   0,   0,   5,  66,   0, 
-     16,   0,  22,   0,   0,   0, 
-     10,   0,  16,   0,  16,   0, 
-      0,   0,  54,   0,   0,   5, 
-     66,   0,  16,   0,  17,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-     17,   0,   0,   0,  26,   0, 
-     16,   0,  16,   0,   0,   0, 
-     30,   0,   0,   7, 114,   0, 
-     16,   0,  17,   0,   0,   0, 
-    150,   7,  16,   0,  17,   0, 
-      0,   0,  70,   2,  16,   0, 
-     22,   0,   0,   0,  54,   0, 
-      0,   6, 114,  48,  32,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     17,   0,   0,   0,  40,   0, 
-      0,   5,  18,   0,  16,   0, 
-     22,   0,   0,   0,  10,   0, 
-     16,   0,  19,   0,   0,   0, 
-     40,   0,   0,   5,  34,   0, 
-     16,   0,  22,   0,   0,   0, 
-     42,   0,  16,   0,  15,   0, 
-      0,   0,  40,   0,   0,   5, 
-     66,   0,  16,   0,  22,   0, 
-      0,   0,  10,   0,  16,   0, 
-     18,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  15,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,  19,   0,   0,   0, 
-     26,   0,  16,   0,  18,   0, 
-      0,   0,  30,   0,   0,   7, 
-    226,   0,  16,   0,  15,   0, 
-      0,   0,  86,  14,  16,   0, 
-     19,   0,   0,   0,   6,   9, 
-     16,   0,  22,   0,   0,   0, 
-     54,   0,   0,   6, 114,  48, 
-     32,   0,   3,   0,   0,   0, 
-      1,   0,   0,   0, 150,   7, 
-     16,   0,  15,   0,   0,   0, 
-     40,   0,   0,   5,  18,   0, 
-     16,   0,  18,   0,   0,   0, 
-     10,   0,  16,   0,  21,   0, 
-      0,   0,  40,   0,   0,   5, 
-     34,   0,  16,   0,  18,   0, 
-      0,   0,  42,   0,  16,   0, 
-     16,   0,   0,   0,  40,   0, 
-      0,   5,  66,   0,  16,   0, 
-     18,   0,   0,   0,  10,   0, 
-     16,   0,  20,   0,   0,   0, 
-     54,   0,   0,   5,  66,   0, 
-     16,   0,  21,   0,   0,   0, 
-     58,   0,  16,   0,  16,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,  21,   0, 
-      0,   0,  26,   0,  16,   0, 
-     20,   0,   0,   0,  30,   0, 
-      0,   7, 114,   0,  16,   0, 
-     16,   0,   0,   0,  70,   2, 
-     16,   0,  18,   0,   0,   0, 
-    150,   7,  16,   0,  21,   0, 
-      0,   0,  54,   0,   0,   6, 
-    114,  48,  32,   0,   3,   0, 
-      0,   0,   2,   0,   0,   0, 
-     70,   2,  16,   0,  16,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,  48,  32,   0,   3,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,  48,  32,   0,   3,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,  48,  32,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0, 194,   0, 
-     16,   0,  14,   0,   0,   0, 
-      6,   4,  16,   0,  17,   0, 
-      0,   0,   6,   4,  16,   0, 
-     17,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     42,   0,  16,   0,  14,   0, 
-      0,   0,  35,   0,   0,   9, 
-     34,   0,  16,   0,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-     17,   0,   0,   0,  42,   0, 
-     16,   0,  17,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0, 194,   0, 
-     16,   0,  14,   0,   0,   0, 
-     86,   9,  16,   0,  15,   0, 
-      0,   0,  86,   9,  16,   0, 
-     15,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     42,   0,  16,   0,  14,   0, 
-      0,   0,  35,   0,   0,   9, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-     15,   0,   0,   0,  58,   0, 
-     16,   0,  15,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   4,   0, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0, 194,   0, 
-     16,   0,  14,   0,   0,   0, 
-      6,   4,  16,   0,  16,   0, 
-      0,   0,   6,   4,  16,   0, 
-     16,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     42,   0,  16,   0,  14,   0, 
-      0,   0,  35,   0,   0,   9, 
-     34,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-     16,   0,   0,   0,  42,   0, 
-     16,   0,  16,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   4,   0, 
-      0,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   7, 
-     18,  48,  32,   0,   5,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26, 144, 144,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   7,  18,  48, 
-     32,   0,   5,   0,   0,   0, 
-      2,   0,   0,   0,  42, 144, 
-    144,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,  80,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,   3,   0,   4,   3, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  54,   0,   0,   7, 
-    242,   0,  16,   0,  16,   0, 
-      0,   0,  70,  62,  32,   4, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   7, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     10,  48,  32,   4,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-     17,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  54,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  10,  48,  32,   4, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     54,   0,   0,   8, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     10,  48,  32,   6,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  54,   0,   0,   8, 
-    130,   0,  16,   0,  11,   0, 
-      0,   0,  10,  48,  32,   6, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  54,   0, 
-      0,   8, 130,   0,  16,   0, 
-     12,   0,   0,   0,  10,  48, 
-     32,   6,   0,   0,   0,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     40,   0,   0,   5,  18,   0, 
-     16,   0,  18,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  40,   0,   0,   5, 
-     34,   0,  16,   0,  18,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  40,   0, 
-      0,   5,  66,   0,  16,   0, 
-     18,   0,   0,   0,  58,   0, 
-     16,   0,  11,   0,   0,   0, 
-     40,   0,   0,   5, 130,   0, 
-     16,   0,  18,   0,   0,   0, 
-     58,   0,  16,   0,  12,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,  17,   0, 
-      0,   0,  70,  14,  16,   0, 
-     17,   0,   0,   0,  70,  14, 
-     16,   0,  18,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0, 194,   0,  16,   0, 
-     14,   0,   0,   0,   6,   4, 
-     16,   0,  16,   0,   0,   0, 
-      6,   4,  16,   0,  17,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,  13,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,  42,   0, 
-     16,   0,  14,   0,   0,   0, 
-     35,   0,   0,   9, 130,   0, 
-     16,   0,  13,   0,   0,   0, 
-     42,   0,  16,   0,  16,   0, 
-      0,   0,  42,   0,  16,   0, 
-     17,   0,   0,   0,  58,   0, 
-     16,   0,  13,   0,   0,   0, 
-     35,   0,   0,   9, 130,   0, 
-     16,   0,  13,   0,   0,   0, 
-     58,   0,  16,   0,  16,   0, 
-      0,   0,  58,   0,  16,   0, 
-     17,   0,   0,   0,  58,   0, 
-     16,   0,  13,   0,   0,   0, 
-     54,   0,   0,   7,  66,   0, 
-     16,   0,  14,   0,   0,   0, 
-     10,  48,  32,   4,   4,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  34,   0, 
-      0,   7, 130,   0,  16,   0, 
-     14,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,  14,   0, 
-      0,   0,  34,   0,   0,   7, 
-     34,   0,  16,   0,  15,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,  13,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,  14,   0, 
-      0,   0,  26,   0,  16,   0, 
-     15,   0,   0,   0,  43,   0, 
-      0,   5, 130,   0,  16,   0, 
-     13,   0,   0,   0,  58,   0, 
-     16,   0,  13,   0,   0,   0, 
-     56,   0,   0,   7, 130,   0, 
-     16,   0,  13,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  28,   0, 
-      0,   5, 130,   0,  16,   0, 
-     13,   0,   0,   0,  58,   0, 
-     16,   0,  13,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,  14,   0,   0,   0, 
-     42,   0,  16,   0,  14,   0, 
-      0,   0,   1,  64,   0,   0, 
-      5,   0,   0,   0,  79,   0, 
-      0,   7, 130,   0,  16,   0, 
-     13,   0,   0,   0,  42,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,  13,   0, 
-      0,   0,  58,   0,  16,   0, 
-     13,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,  13,   0,   0,   0, 
-     40,   0,   0,   5, 242,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,  14,  16,   0,  16,   0, 
-      0,   0,  54,   0,   0,   7, 
-    242,  48,  32,   4,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,  16,   0,   0,   0, 
-     54,   0,   0,   7, 130,   0, 
-     16,   0,  13,   0,   0,   0, 
-     26,  48,  32,   4,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  54,   0, 
-      0,   8,  66,   0,  16,   0, 
-     14,   0,   0,   0,  26,  48, 
-     32,   6,   0,   0,   0,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     54,   0,   0,   8, 130,   0, 
-     16,   0,  14,   0,   0,   0, 
-     26,  48,  32,   6,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  54,   0,   0,   8, 
-     34,   0,  16,   0,  15,   0, 
-      0,   0,  26,  48,  32,   6, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  54,   0, 
-      0,   7,  18,  48,  32,   4, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0,  54,   0,   0,   8, 
-     18,  48,  32,   6,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-     14,   0,   0,   0,  54,   0, 
-      0,   8,  18,  48,  32,   6, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     54,   0,   0,   8,  18,  48, 
-     32,   6,   0,   0,   0,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     26,   0,  16,   0,  15,   0, 
-      0,   0,  54,   0,   0,   7, 
-     34,  48,  32,   4,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     54,   0,   0,   8,  34,  48, 
-     32,   6,   0,   0,   0,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  54,   0,   0,   8, 
-     34,  48,  32,   6,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-     11,   0,   0,   0,  54,   0, 
-      0,   8,  34,  48,  32,   6, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,  12,   0,   0,   0, 
-     21,   0,   0,   1,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   6,   0,   0,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   6,   0,   0,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6, 242,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,  62,  32,   0,   3,   0, 
-      0,   0,   2,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   7,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   8,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,  11,   0,   0,   0, 
-     40,   0,   0,   5,  18,   0, 
-     16,   0,  17,   0,   0,   0, 
-     42,   0,  16,   0,   7,   0, 
-      0,   0,  40,   0,   0,   5, 
-     34,   0,  16,   0,  17,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  40,   0, 
-      0,   5,  66,   0,  16,   0, 
-     17,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     40,   0,   0,   5, 130,   0, 
-     16,   0,  17,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  33,   0,   0,   7, 
-    130,   0,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   6,   0,   0,   0, 
-     43,   0,   0,   5, 130,   0, 
-     16,   0,  12,   0,   0,   0, 
-     26,   0,  16,   0,   6,   0, 
-      0,   0,  55,   0,   0,  15, 
-    226,   0,  16,   0,  15,   0, 
-      0,   0, 166,  10,  16,   0, 
-      3,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-    128,   0,   0,   0,   3,   0, 
-      0,   0,  32,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,  64,   0,   0,   0, 
-      7,   0,   0,   0,  16,   0, 
-      0,   0,  54,   0,   0,   6, 
-    242,   0,  16,   0,  18,   0, 
-      0,   0,  70,  62,  32,   0, 
-      3,   0,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,  13,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,  14,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,  14,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,  40,   0,   0,   5, 
-     18,   0,  16,   0,  19,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  40,   0, 
-      0,   5,  34,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  13,   0,   0,   0, 
-     40,   0,   0,   5, 194,   0, 
-     16,   0,  19,   0,   0,   0, 
-    166,  14,  16,   0,  14,   0, 
-      0,   0,  33,   0,   0,   7, 
-     18,   0,  16,   0,  20,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     43,   0,   0,   5,  34,   0, 
-     16,   0,  20,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  54,   0,   0,   6, 
-    242,   0,  16,   0,  21,   0, 
-      0,   0,  70,  62,  32,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,  20,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,  20,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,   0,  16,   0,  22,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,  22,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  40,   0,   0,   5, 
-     50,   0,  16,   0,  23,   0, 
-      0,   0, 230,  10,  16,   0, 
-     20,   0,   0,   0,  40,   0, 
-      0,   5, 194,   0,  16,   0, 
-     23,   0,   0,   0,   6,   4, 
-     16,   0,  22,   0,   0,   0, 
-     33,   0,   0,   7,  66,   0, 
-     16,   0,  22,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,  43,   0, 
-      0,   5, 130,   0,  16,   0, 
-     22,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,  24,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  48,   0,   0,   1, 
-     80,   0,   0,   7,  34,   0, 
-     16,   0,  24,   0,   0,   0, 
-     10,   0,  16,   0,  24,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   3,   0, 
-      4,   3,  26,   0,  16,   0, 
-     24,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-     24,   0,   0,   0,  10,   0, 
-     16,   0,  24,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   8, 
-     34,   0,  16,   0,  24,   0, 
-      0,   0,  10, 144, 144,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-     24,   0,   0,   0,   1,   0, 
-      0,   7,  34,   0,  16,   0, 
-     24,   0,   0,   0,  26,   0, 
-     16,   0,  24,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  32,   0,   0,  10, 
-    194,   0,  16,   0,  24,   0, 
-      0,   0,  86,   5,  16,   0, 
-     24,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,  24,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,  25,   0,   0,   0, 
-     10,   0,  16,   0,  24,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,  25,   0,   0,   0, 
-     70,  14,  16,   0,  17,   0, 
-      0,   0,  70,  14,  16,   0, 
-     25,   0,   0,   0,  38,   0, 
-      0,   8,   0, 208,   0,   0, 
-     50,   0,  16,   0,  25,   0, 
-      0,   0,  70,   0,  16,   0, 
-     16,   0,   0,   0,  70,   0, 
-     16,   0,  25,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,  25,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,  10,   0,  16,   0, 
-     25,   0,   0,   0,  35,   0, 
-      0,   9,  18,   0,  16,   0, 
-     25,   0,   0,   0,  42,   0, 
-     16,   0,  16,   0,   0,   0, 
-     42,   0,  16,   0,  25,   0, 
-      0,   0,  10,   0,  16,   0, 
-     25,   0,   0,   0,  35,   0, 
-      0,   9,  18,   0,  16,   0, 
-     25,   0,   0,   0,  58,   0, 
-     16,   0,  16,   0,   0,   0, 
-     58,   0,  16,   0,  25,   0, 
-      0,   0,  10,   0,  16,   0, 
-     25,   0,   0,   0,  33,   0, 
-      0,   7,  34,   0,  16,   0, 
-     25,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,  25,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,  25,   0, 
-      0,   0,  58,   0,  16,   0, 
-     11,   0,   0,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     34,   0,   0,   7,  66,   0, 
-     16,   0,  25,   0,   0,   0, 
-     10,   0,  16,   0,  25,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  43,   0, 
-      0,   5,  18,   0,  16,   0, 
-     25,   0,   0,   0,  10,   0, 
-     16,   0,  25,   0,   0,   0, 
-     56,   0,   0,   7,  18,   0, 
-     16,   0,  25,   0,   0,   0, 
-     10,   0,  16,   0,  25,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  14,   0, 
-      0,   7,  18,   0,  16,   0, 
-     25,   0,   0,   0,  10,   0, 
-     16,   0,  25,   0,   0,   0, 
-     58,   0,  16,   0,  12,   0, 
-      0,   0,  28,   0,   0,   5, 
-     18,   0,  16,   0,  25,   0, 
-      0,   0,  10,   0,  16,   0, 
-     25,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-     25,   0,   0,   0,  26,   0, 
-     16,   0,  15,   0,   0,   0, 
-     10,   0,  16,   0,  25,   0, 
-      0,   0,  55,   0,   0,  10, 
-     18,   0,  16,   0,  25,   0, 
-      0,   0,  42,   0,  16,   0, 
-     25,   0,   0,   0,  58, 144, 
-    144,   0,  10,   0,  16,   0, 
-     25,   0,   0,   0,  42,   0, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9,  18,   0, 
-     16,   0,  25,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,  25,   0,   0,   0, 
-     18,   0,   0,   1,  32,   0, 
-      0,   7,  34,   0,  16,   0, 
-     25,   0,   0,   0,  26,   0, 
-     16,   0,  24,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,  26,   0, 
-      0,   0,  10,   0,  16,   0, 
-     24,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,  26,   0, 
-      0,   0,  70,  14,  16,   0, 
-     19,   0,   0,   0,  70,  14, 
-     16,   0,  26,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0,  98,   0,  16,   0, 
-     25,   0,   0,   0,   6,   1, 
-     16,   0,  18,   0,   0,   0, 
-      6,   1,  16,   0,  26,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,  25,   0, 
-      0,   0,  42,   0,  16,   0, 
-     25,   0,   0,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     35,   0,   0,   9,  34,   0, 
-     16,   0,  25,   0,   0,   0, 
-     42,   0,  16,   0,  18,   0, 
-      0,   0,  42,   0,  16,   0, 
-     26,   0,   0,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     35,   0,   0,   9,  34,   0, 
-     16,   0,  25,   0,   0,   0, 
-     58,   0,  16,   0,  18,   0, 
-      0,   0,  58,   0,  16,   0, 
-     26,   0,   0,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     33,   0,   0,   7,  66,   0, 
-     16,   0,  25,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-     25,   0,   0,   0,  60,   0, 
-      0,   7,  66,   0,  16,   0, 
-     25,   0,   0,   0,  10,   0, 
-     16,   0,  20,   0,   0,   0, 
-     42,   0,  16,   0,  25,   0, 
-      0,   0,  34,   0,   0,   7, 
-    130,   0,  16,   0,  25,   0, 
-      0,   0,  26,   0,  16,   0, 
-     25,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     43,   0,   0,   5,  34,   0, 
-     16,   0,  25,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,  56,   0,   0,   7, 
-     34,   0,  16,   0,  25,   0, 
-      0,   0,  26,   0,  16,   0, 
-     25,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     14,   0,   0,   7,  34,   0, 
-     16,   0,  25,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,  26,   0,  16,   0, 
-     20,   0,   0,   0,  28,   0, 
-      0,   5,  34,   0,  16,   0, 
-     25,   0,   0,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,  25,   0,   0,   0, 
-     26,   0,  16,   0,  15,   0, 
-      0,   0,  26,   0,  16,   0, 
-     25,   0,   0,   0,  55,   0, 
-      0,  10,  34,   0,  16,   0, 
-     25,   0,   0,   0,  58,   0, 
-     16,   0,  25,   0,   0,   0, 
-     58, 144, 144,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     42,   0,  16,   0,  15,   0, 
-      0,   0,  55,   0,   0,   9, 
-     18,   0,  16,   0,  25,   0, 
-      0,   0,  42,   0,  16,   0, 
-     25,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,  18,   0,   0,   1, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,  26,   0,   0,   0, 
-     10,   0,  16,   0,  24,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,  26,   0,   0,   0, 
-     70,  14,  16,   0,  23,   0, 
-      0,   0,  70,  14,  16,   0, 
-     26,   0,   0,   0,  38,   0, 
-      0,   8,   0, 208,   0,   0, 
-     98,   0,  16,   0,  25,   0, 
-      0,   0,   6,   1,  16,   0, 
-     21,   0,   0,   0,   6,   1, 
-     16,   0,  26,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,  25,   0,   0,   0, 
-     42,   0,  16,   0,  25,   0, 
-      0,   0,  26,   0,  16,   0, 
-     25,   0,   0,   0,  35,   0, 
-      0,   9,  34,   0,  16,   0, 
-     25,   0,   0,   0,  42,   0, 
-     16,   0,  21,   0,   0,   0, 
-     42,   0,  16,   0,  26,   0, 
-      0,   0,  26,   0,  16,   0, 
-     25,   0,   0,   0,  35,   0, 
-      0,   9,  34,   0,  16,   0, 
-     25,   0,   0,   0,  58,   0, 
-     16,   0,  21,   0,   0,   0, 
-     58,   0,  16,   0,  26,   0, 
-      0,   0,  26,   0,  16,   0, 
-     25,   0,   0,   0,  33,   0, 
-      0,   7,  66,   0,  16,   0, 
-     25,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,  25,   0, 
-      0,   0,  42,   0,  16,   0, 
-     22,   0,   0,   0,  42,   0, 
-     16,   0,  25,   0,   0,   0, 
-     34,   0,   0,   7, 130,   0, 
-     16,   0,  25,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,  43,   0, 
-      0,   5,  34,   0,  16,   0, 
-     25,   0,   0,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     56,   0,   0,   7,  34,   0, 
-     16,   0,  25,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  14,   0, 
-      0,   7,  34,   0,  16,   0, 
-     25,   0,   0,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     58,   0,  16,   0,  22,   0, 
-      0,   0,  28,   0,   0,   5, 
-     34,   0,  16,   0,  25,   0, 
-      0,   0,  26,   0,  16,   0, 
-     25,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-     25,   0,   0,   0,  26,   0, 
-     16,   0,  15,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,  55,   0,   0,  10, 
-     34,   0,  16,   0,  25,   0, 
-      0,   0,  58,   0,  16,   0, 
-     25,   0,   0,   0,  58, 144, 
-    144,   0,  26,   0,  16,   0, 
-     25,   0,   0,   0,  42,   0, 
-     16,   0,  15,   0,   0,   0, 
-     55,   0,   0,   9,  18,   0, 
-     16,   0,  25,   0,   0,   0, 
-     42,   0,  16,   0,  25,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1,  30,   0,   0,   7, 
-     18,   0,  16,   0,  25,   0, 
-      0,   0,  58,   0,  16,   0, 
-     15,   0,   0,   0,  10,   0, 
-     16,   0,  25,   0,   0,   0, 
-     30,   0,   0,  10,  34,   0, 
-     16,   0,  25,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,  10, 144, 208, 128, 
-     65,   0,   0,   0,  64,   0, 
-      0,   0,  10,   0,  16,   0, 
-     25,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-     24,   0,   0,   0,  26,   0, 
-     16,   0,  24,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  54,   0,   0,   7, 
-     18,   0,  16,   0,  26,   0, 
-      0,   0,  10,  48,  32,   4, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  24,   0,   0,   0, 
-     54,   0,   0,   8,  34,   0, 
-     16,   0,  26,   0,   0,   0, 
-     10,  48,  32,   6,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,  24,   0, 
-      0,   0,  54,   0,   0,   8, 
-     66,   0,  16,   0,  26,   0, 
-      0,   0,  10,  48,  32,   6, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-     24,   0,   0,   0,  54,   0, 
-      0,   7,  18,   0,  16,   0, 
-     27,   0,   0,   0,  26,  48, 
-     32,   4,   0,   0,   0,   0, 
-     26,   0,  16,   0,  24,   0, 
-      0,   0,  54,   0,   0,   8, 
-     34,   0,  16,   0,  27,   0, 
-      0,   0,  26,  48,  32,   6, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-     24,   0,   0,   0,  54,   0, 
-      0,   8,  66,   0,  16,   0, 
-     27,   0,   0,   0,  26,  48, 
-     32,   6,   0,   0,   0,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,  24,   0,   0,   0, 
-     38,   0,   0,  10,   0, 208, 
-      0,   0, 210,   0,  16,   0, 
-     25,   0,   0,   0,   6,   9, 
-     16,   0,  27,   0,   0,   0, 
-      6, 144, 208,   0,  64,   0, 
-      0,   0,  10,   0,  16,   0, 
-     25,   0,   0,   0,  35,   0, 
-      0,   9, 114,   0,  16,   0, 
-     25,   0,   0,   0,  86,   5, 
-     16,   0,  25,   0,   0,   0, 
-     70,   2,  16,   0,  26,   0, 
-      0,   0, 134,   3,  16,   0, 
-     25,   0,   0,   0,  30,   0, 
-      0,  10, 114,   0,  16,   0, 
-     25,   0,   0,   0,  70,   2, 
-     16,   0,  25,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0,  32,   0,   0,   0, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    178,   0,  16,   0,  25,   0, 
-      0,   0,  70,   8,  16,   0, 
-     25,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,  26,   0,   0,   0, 
-     10,   0,  16,   0,  24,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7, 114,   0, 
-     16,   0,  27,   0,   0,   0, 
-     70,   3,  16,   0,  25,   0, 
-      0,   0,  70,   2,  16,   0, 
-     26,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-     25,   0,   0,   0,  10,   0, 
-     16,   0,  26,   0,   0,   0, 
-     55,   0,   0,   9, 146,   0, 
-     16,   0,  27,   0,   0,   0, 
-      6,   0,  16,   0,  27,   0, 
-      0,   0, 166,   2,  16,   0, 
-     25,   0,   0,   0,   6,   8, 
-     16,   0,  25,   0,   0,   0, 
-     54,   0,   0,   5,  82,   0, 
-     16,   0,  25,   0,   0,   0, 
-     86,   6,  16,   0,  26,   0, 
-      0,   0,  55,   0,   0,   9, 
-    242,   0,  16,   0,  25,   0, 
-      0,   0,  86,  10,  16,   0, 
-     27,   0,   0,   0,  70,  14, 
-     16,   0,  25,   0,   0,   0, 
-     22,  11,  16,   0,  25,   0, 
-      0,   0,  79,   0,   0,   7, 
-     34,   0,  16,   0,  24,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255,   0,   0,   0,  58,   0, 
-     16,   0,  26,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,  26,   0, 
-      0,   0,  55,   0,   0,   9, 
-    146,   0,  16,   0,  26,   0, 
-      0,   0,  86,   5,  16,   0, 
-     24,   0,   0,   0,  86,   1, 
-     16,   0,  14,   0,   0,   0, 
-      6,   4,  16,   0,  14,   0, 
-      0,   0,  40,   0,   0,   5, 
-     18,   0,  16,   0,  28,   0, 
-      0,   0,  58,   0,  16,   0, 
-     27,   0,   0,   0,  40,   0, 
-      0,   5,  98,   0,  16,   0, 
-     28,   0,   0,   0,  86,   7, 
-     16,   0,  25,   0,   0,   0, 
-     40,   0,   0,   5, 130,   0, 
-     16,   0,  28,   0,   0,   0, 
-     10,   0,  16,   0,  26,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,  26,   0, 
-      0,   0,  10,   0,  16,   0, 
-     27,   0,   0,   0,  54,   0, 
-      0,   5,  98,   0,  16,   0, 
-     26,   0,   0,   0,   6,   2, 
-     16,   0,  25,   0,   0,   0, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,  25,   0,   0,   0, 
-     70,  14,  16,   0,  28,   0, 
-      0,   0,  70,  14,  16,   0, 
-     26,   0,   0,   0,  38,   0, 
-      0,   8,   0, 208,   0,   0, 
-     50,   0,  16,   0,  25,   0, 
-      0,   0,  70,   0,  16,   0, 
-     25,   0,   0,   0,  70,   0, 
-     16,   0,  25,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,  14,   0,   0,   0, 
-     26,   0,  16,   0,  25,   0, 
-      0,   0,  10,   0,  16,   0, 
-     25,   0,   0,   0,  35,   0, 
-      0,   9,  18,   0,  16,   0, 
-     14,   0,   0,   0,  42,   0, 
-     16,   0,  25,   0,   0,   0, 
-     42,   0,  16,   0,  25,   0, 
-      0,   0,  10,   0,  16,   0, 
-     14,   0,   0,   0,  86,   0, 
-      0,   5,  18,   0,  16,   0, 
-     14,   0,   0,   0,  10,   0, 
-     16,   0,  14,   0,   0,   0, 
-     86,   0,   0,   5,  34,   0, 
-     16,   0,  24,   0,   0,   0, 
-     58,   0,  16,   0,  25,   0, 
-      0,   0,  56,   0,   0,   7, 
-     34,   0,  16,   0,  24,   0, 
-      0,   0,  26,   0,  16,   0, 
-     24,   0,   0,   0,  26,   0, 
-     16,   0,  24,   0,   0,   0, 
-     50,   0,   0,  10,  18,   0, 
-     16,   0,  14,   0,   0,   0, 
-     26,   0,  16,   0,  24,   0, 
-      0,   0,  42, 128,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-     14,   0,   0,   0,  28,   0, 
-      0,   5,  18,   0,  16,   0, 
-     14,   0,   0,   0,  10,   0, 
-     16,   0,  14,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,  24,   0,   0,   0, 
-     10,  48,  32,   0,   6,   0, 
-      0,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,  25,   0,   0,   0, 
-     10,   0,  16,   0,  14,   0, 
-      0,   0,  26,   0,  16,   0, 
-     24,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-     24,   0,   0,   0,  42,   0, 
-     16,   0,  24,   0,   0,   0, 
-     10,   0,  16,   0,  25,   0, 
-      0,   0,  26,   0,  16,   0, 
-     24,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      6,   0,   0,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-     24,   0,   0,   0,  59,   0, 
-      0,   5,  98,   0,  16,   0, 
-     24,   0,   0,   0, 166,  11, 
-     16,   0,  24,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,  24,   0,   0,   0, 
-     58,   0,  16,   0,  24,   0, 
-      0,   0,  26,   0,  16,   0, 
-     24,   0,   0,   0,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-     25,   0,   0,   0,  10,  48, 
-     32,   0,   6,   0,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-     25,   0,   0,   0,  10,   0, 
-     16,   0,  14,   0,   0,   0, 
-     10,   0,  16,   0,  25,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,  24,   0, 
-      0,   0,  58,   0,  16,   0, 
-     24,   0,   0,   0,  26,   0, 
-     16,   0,  25,   0,   0,   0, 
-     10,   0,  16,   0,  25,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   6,   0, 
-      0,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,  24,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,  24,   0, 
-      0,   0,  42,   0,  16,   0, 
-     24,   0,   0,   0,  26,   0, 
-     16,   0,  24,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,  24,   0,   0,   0, 
-     10,  48,  32,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,  14,   0,   0,   0, 
-     10,   0,  16,   0,  14,   0, 
-      0,   0,  42,   0,  16,   0, 
-     24,   0,   0,   0,  55,   0, 
-      0,   9,  18,   0,  16,   0, 
-     14,   0,   0,   0,  26,   0, 
-     16,   0,  24,   0,   0,   0, 
-     10,   0,  16,   0,  14,   0, 
-      0,   0,  42,   0,  16,   0, 
-     24,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     14,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-     24,   0,   0,   0,  10,   0, 
-     16,   0,  24,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,  48,  32,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  48,  32,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,  84,   0, 
-      0,   7,  66,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  10,  48,  32,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  10,   0, 
-     16,   0,  15,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  10,  48,  32,   0, 
-      6,   0,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   4,   0, 
-      0,   0,  10,  48,  32,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0,  79,   0,   0,   7, 
-     66,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     84,   0,   0,   7,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,   9,  66,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   5,   0,   0,   0, 
-     10,   0,  16,   0,  15,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   6,   0,   0,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      4,   0,   0,   0,  10,  48, 
-     32,   0,   2,   0,   0,   0, 
-      2,   0,   0,   0,  79,   0, 
-      0,   7,  66,   0,  16,   0, 
-      5,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  84,   0,   0,   7, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   2,   0,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,  48,  32,   0,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-     55,   0,   0,   9,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  10,   0,  16,   0, 
-     15,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   1,   0,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,  15,   0,   0,   0, 
-     10,   0,  16,   0,  15,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,  54,   0,   0,   6, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,  48,  32,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,  48,  32,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  48,  32,   0,   2,   0, 
-      0,   0,   2,   0,   0,   0, 
-     30,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  48,  32,   0, 
-      1,   0,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  48,  32,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,  48,  32,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  79,   0, 
-      0,   9,  98,   0,  16,   0, 
-      0,   0,   0,   0,   6,  64, 
-      2,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     24,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  26,   0,  16,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  24,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  21,   0, 
-      0,   1, 167,   0,   0,   9, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-      6, 112,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  79,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  24,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   8, 130,   0,  16,   0, 
-      2,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 126,  16,   0, 
-      1,   0,   0,   0,  21,   0, 
-      0,   1, 168,   0,   0,   9, 
-    242, 224,  17,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70,  14,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-     62,   0,   0,   1
-};
diff --git a/thirdparty/directxtex/Shaders/Compiled/BC7Encode_TryMode137CS.inc b/thirdparty/directxtex/Shaders/Compiled/BC7Encode_TryMode137CS.inc
deleted file mode 100644
index 1fab63e..0000000
--- a/thirdparty/directxtex/Shaders/Compiled/BC7Encode_TryMode137CS.inc
+++ /dev/null
@@ -1,4104 +0,0 @@
-#if 0
-//
-// Generated by Microsoft (R) D3D Shader Disassembler
-//
-//
-// Input signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Input
-//
-// Output signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Output
-cs_4_0
-dcl_globalFlags refactoringAllowed
-dcl_immediateConstantBuffer { { 0x0000cccc, 15, 0, 0},
-                              { 0x00008888, 15, 0, 0},
-                              { 0x0000eeee, 15, 0, 0},
-                              { 0x0000ecc8, 15, 0, 1},
-                              { 0x0000c880, 15, 0, 1},
-                              { 0x0000feec, 15, 0, 1},
-                              { 0x0000fec8, 15, 0, 1},
-                              { 0x0000ec80, 15, 0, 2},
-                              { 0x0000c800, 15, 0, 2},
-                              { 0x0000ffec, 15, 0, 2},
-                              { 0x0000fe80, 15, 0, 2},
-                              { 0x0000e800, 15, 0, 2},
-                              { 0x0000ffe8, 15, 0, 3},
-                              { 0x0000ff00, 15, 0, 3},
-                              { 0x0000fff0, 15, 0, 3},
-                              { 0x0000f000, 15, 0, 3},
-                              { 0x0000f710, 15, 0, 4},
-                              { 142, 2, 0, 4},
-                              { 0x00007100, 8, 0, 4},
-                              { 2254, 2, 0, 4},
-                              { 140, 2, 0, 5},
-                              { 0x00007310, 8, 0, 5},
-                              { 0x00003100, 8, 0, 5},
-                              { 0x00008cce, 15, 0, 5},
-                              { 2188, 2, 0, 6},
-                              { 0x00003110, 8, 0, 6},
-                              { 0x00006666, 2, 0, 6},
-                              { 0x0000366c, 2, 0, 6},
-                              { 6120, 8, 0, 6},
-                              { 4080, 8, 0, 7},
-                              { 0x0000718e, 2, 0, 7},
-                              { 0x0000399c, 2, 0, 7},
-                              { 0x0000aaaa, 15, 0, 7},
-                              { 0x0000f0f0, 15, 0, 8},
-                              { 0x00005a5a, 6, 0, 8},
-                              { 0x000033cc, 8, 0, 8},
-                              { 0x00003c3c, 2, 0, 8},
-                              { 0x000055aa, 8, 0, 9},
-                              { 0x00009696, 15, 0, 9},
-                              { 0x0000a55a, 15, 0, 9},
-                              { 0x000073ce, 2, 0, 9},
-                              { 5064, 8, 0, 10},
-                              { 0x0000324c, 2, 0, 10},
-                              { 0x00003bdc, 2, 0, 10},
-                              { 0x00006996, 2, 0, 10},
-                              { 0x0000c33c, 15, 0, 10},
-                              { 0x00009966, 15, 0, 11},
-                              { 1632, 6, 0, 11},
-                              { 626, 6, 0, 11},
-                              { 1252, 2, 0, 11},
-                              { 0x00004e40, 6, 0, 12},
-                              { 0x00002720, 8, 0, 12},
-                              { 0x0000c936, 15, 0, 12},
-                              { 0x0000936c, 15, 0, 12},
-                              { 0x000039c6, 2, 0, 13},
-                              { 0x0000639c, 2, 0, 13},
-                              { 0x00009336, 15, 0, 13},
-                              { 0x00009cc6, 15, 0, 13},
-                              { 0x0000817e, 15, 0, 14},
-                              { 0x0000e718, 15, 0, 14},
-                              { 0x0000ccf0, 15, 0, 14},
-                              { 4044, 2, 0, 14},
-                              { 0x00007744, 2, 0, 15},
-                              { 0x0000ee22, 15, 0, 15},
-                              { 0, 3, 15, 0},
-                              { 4, 3, 8, 0},
-                              { 9, 15, 8, 0},
-                              { 13, 15, 3, 0},
-                              { 17, 8, 15, 0},
-                              { 21, 3, 15, 1},
-                              { 26, 15, 3, 1},
-                              { 30, 15, 8, 1},
-                              { 34, 8, 15, 1},
-                              { 38, 8, 15, 1},
-                              { 43, 6, 15, 1},
-                              { 47, 6, 15, 1},
-                              { 51, 6, 15, 1},
-                              { 55, 5, 15, 1},
-                              { 60, 3, 15, 2},
-                              { 64, 3, 8, 2},
-                              { 0, 3, 15, 2},
-                              { 9, 3, 8, 2},
-                              { 18, 8, 15, 2},
-                              { 27, 15, 3, 2},
-                              { 37, 3, 15, 2},
-                              { 46, 3, 8, 2},
-                              { 55, 6, 15, 2},
-                              { 64, 10, 8, 3},
-                              { 0, 5, 3, 3},
-                              { 0, 8, 15, 3},
-                              { 0, 8, 6, 3},
-                              { 0, 6, 10, 3},
-                              { 0, 8, 15, 3},
-                              { 0, 5, 15, 3},
-                              { 0, 15, 10, 3},
-                              { 0, 15, 8, 3},
-                              { 0, 8, 15, 3},
-                              { 21, 15, 3, 4},
-                              { 43, 3, 15, 4},
-                              { 64, 5, 10, 4},
-                              { 0, 6, 10, 4},
-                              { 0, 10, 8, 4},
-                              { 0, 8, 9, 4},
-                              { 0, 15, 10, 4},
-                              { 0, 15, 6, 4},
-                              { 0, 3, 15, 4},
-                              { 0, 15, 8, 5},
-                              { 0, 5, 15, 5},
-                              { 0, 15, 3, 5},
-                              { 0, 15, 6, 5},
-                              { 0, 15, 6, 5},
-                              { 0, 15, 8, 5},
-                              { 0, 3, 15, 5},
-                              { 0, 15, 3, 5},
-                              { 0, 5, 15, 5},
-                              { 0, 5, 15, 6},
-                              { 0, 5, 15, 6},
-                              { 0, 8, 15, 6},
-                              { 0, 5, 15, 6},
-                              { 0, 10, 15, 6},
-                              { 0, 5, 15, 6},
-                              { 0, 10, 15, 6},
-                              { 0, 8, 15, 6},
-                              { 0, 13, 15, 6},
-                              { 0, 15, 3, 7},
-                              { 0, 12, 15, 7},
-                              { 0, 3, 15, 7},
-                              { 0, 3, 8, 7},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 1},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 2},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3},
-                              { 0, 0, 0, 3} }
-dcl_constantbuffer CB0[2], immediateIndexed
-dcl_resource_texture2d (float,float,float,float) t0
-dcl_resource_structured t1, 16
-dcl_uav_structured u0, 16
-dcl_input vThreadIDInGroupFlattened
-dcl_input vThreadGroupID.x
-dcl_temps 28
-dcl_indexableTemp x0[8], 4
-dcl_indexableTemp x1[2], 4
-dcl_indexableTemp x2[2], 4
-dcl_indexableTemp x3[2], 4
-dcl_tgsm_structured g0, 100, 64
-dcl_thread_group 64, 1, 1
-iadd r0.x, vThreadGroupID.x, cb0[1].x
-ult r1.xyzw, vThreadIDInGroupFlattened.xxxx, l(16, 32, 8, 4)
-if_nz r1.x
-  udiv r0.y, null, r0.x, cb0[0].y
-  imad r0.z, -r0.y, cb0[0].y, r0.x
-  ishl r0.z, r0.z, l(2)
-  ishl r0.y, r0.y, l(2)
-  and r0.w, vThreadIDInGroupFlattened.x, l(3)
-  iadd r2.x, r0.w, r0.z
-  ushr r0.z, vThreadIDInGroupFlattened.x, l(2)
-  iadd r2.y, r0.z, r0.y
-  mov r2.zw, l(0,0,0,0)
-  ld r2.xyzw, r2.xyzw, t0.xyzw
-  mul r2.xyzw, r2.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000)
-  ftou r2.xyzw, r2.xyzw
-  umin r2.xyzw, r2.xyzw, l(255, 255, 255, 255)
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(0), r2.xyzw
-endif 
-sync_g_t
-mov x0[0].x, l(-1)
-mov x0[1].x, l(-1)
-mov x0[2].x, l(-1)
-mov x0[3].x, l(-1)
-mov x0[0].y, l(0)
-mov x0[1].y, l(0)
-mov x0[2].y, l(0)
-mov x0[3].y, l(0)
-mov x0[4].x, l(-1)
-mov x0[5].x, l(-1)
-mov x0[6].x, l(-1)
-mov x0[7].x, l(-1)
-mov x0[4].y, l(0)
-mov x0[5].y, l(0)
-mov x0[6].y, l(0)
-mov x0[7].y, l(0)
-mov r0.y, l(0)
-loop 
-  uge r0.z, r0.y, l(16)
-  breakc_nz r0.z
-  ld_structured r2.xyzw, r0.y, l(0), g0.xyzw
-  mov r0.z, vThreadIDInGroupFlattened.x
-  ushr r0.z, icb[r0.z + 0].x, r0.y
-  and r0.z, r0.z, l(1)
-  ieq r0.z, r0.z, l(1)
-  if_nz r0.z
-    mov r3.x, x0[4].x
-    mov r3.y, x0[5].x
-    mov r3.z, x0[6].x
-    mov r3.w, x0[7].x
-    umin r3.xyzw, r2.xyzw, r3.xyzw
-    mov x0[4].x, r3.x
-    mov x0[5].x, r3.y
-    mov x0[6].x, r3.z
-    mov x0[7].x, r3.w
-    mov r3.x, x0[4].y
-    mov r3.y, x0[5].y
-    mov r3.z, x0[6].y
-    mov r3.w, x0[7].y
-    umax r3.xyzw, r2.xyzw, r3.xyzw
-    mov x0[4].y, r3.x
-    mov x0[5].y, r3.y
-    mov x0[6].y, r3.z
-    mov x0[7].y, r3.w
-  else 
-    mov r3.x, x0[0].x
-    mov r3.y, x0[1].x
-    mov r3.z, x0[2].x
-    mov r3.w, x0[3].x
-    umin r3.xyzw, r2.xyzw, r3.xyzw
-    mov x0[0].x, r3.x
-    mov x0[1].x, r3.y
-    mov x0[2].x, r3.z
-    mov x0[3].x, r3.w
-    mov r3.x, x0[0].y
-    mov r3.y, x0[1].y
-    mov r3.z, x0[2].y
-    mov r3.w, x0[3].y
-    umax r2.xyzw, r2.xyzw, r3.xyzw
-    mov x0[0].y, r2.x
-    mov x0[1].y, r2.y
-    mov x0[2].y, r2.z
-    mov x0[3].y, r2.w
-  endif 
-  iadd r0.y, r0.y, l(1)
-endloop 
-mov r2.x, x0[0].x
-mov r2.y, x0[1].x
-mov r2.z, x0[2].x
-mov r2.w, x0[3].x
-mov r3.x, x0[0].y
-mov r3.y, x0[1].y
-mov r3.z, x0[2].y
-mov r3.w, x0[3].y
-mov r4.x, x0[4].x
-mov r4.y, x0[5].x
-mov r4.z, x0[6].x
-mov r4.w, x0[7].x
-mov r5.x, x0[4].y
-mov r5.y, x0[5].y
-mov r5.z, x0[6].y
-mov r5.w, x0[7].y
-ieq r0.y, cb0[0].w, l(1)
-movc r0.z, r0.y, l(2), l(4)
-mov x1[0].x, l(0)
-mov x1[1].x, l(0)
-mov x2[0].x, l(-1)
-mov x2[1].x, l(-1)
-imad r6.xyz, r2.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-ushr r6.xyz, r6.xyzx, l(16)
-and r6.xyz, r6.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-imad r7.xyz, r3.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-ushr r7.xyz, r7.xyzx, l(16)
-and r7.xyz, r7.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-and r8.xyz, r2.xyzx, l(-2, -2, -2, 0)
-and r9.xyz, r3.xyzx, l(-2, -2, -2, 0)
-imad r10.xyzw, r2.xyzw, l(0x00003f3f, 0x00003f3f, 0x00003f3f, 0x00003f3f), l(0x00008000, 0x00008000, 0x00008000, 0x00008000)
-ushr r10.xyzw, r10.xyzw, l(16)
-and r10.xyzw, r10.xyzw, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0x0000fffe)
-imad r11.xyzw, r3.xyzw, l(0x00003f3f, 0x00003f3f, 0x00003f3f, 0x00003f3f), l(0x00008000, 0x00008000, 0x00008000, 0x00008000)
-ushr r11.xyzw, r11.xyzw, l(16)
-and r11.xyzw, r11.xyzw, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0x0000fffe)
-imad r12.xyz, r4.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-ushr r12.xyz, r12.xyzx, l(16)
-and r12.xyz, r12.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-imad r13.xyz, r5.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-ushr r13.xyz, r13.xyzx, l(16)
-and r13.xyz, r13.xyzx, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0)
-and r14.xyz, r4.xyzx, l(-2, -2, -2, 0)
-and r15.xyz, r5.xyzx, l(-2, -2, -2, 0)
-imad r16.xyzw, r4.xyzw, l(0x00003f3f, 0x00003f3f, 0x00003f3f, 0x00003f3f), l(0x00008000, 0x00008000, 0x00008000, 0x00008000)
-ushr r16.xyzw, r16.xyzw, l(16)
-and r16.xyzw, r16.xyzw, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0x0000fffe)
-imad r17.xyzw, r5.xyzw, l(0x00003f3f, 0x00003f3f, 0x00003f3f, 0x00003f3f), l(0x00008000, 0x00008000, 0x00008000, 0x00008000)
-ushr r17.xyzw, r17.xyzw, l(16)
-and r17.xyzw, r17.xyzw, l(0x0000fffe, 0x0000fffe, 0x0000fffe, 0x0000fffe)
-mov r0.w, cb0[0].w
-mov r18.x, l(0)
-loop 
-  uge r6.w, r18.x, r0.z
-  breakc_nz r6.w
-  mov x0[0].x, r2.x
-  mov x0[1].x, r2.y
-  mov x0[2].x, r2.z
-  mov x0[3].x, r2.w
-  mov x0[0].y, r3.x
-  mov x0[1].y, r3.y
-  mov x0[2].y, r3.z
-  mov x0[3].y, r3.w
-  mov x0[4].x, r4.x
-  mov x0[5].x, r4.y
-  mov x0[6].x, r4.z
-  mov x0[7].x, r4.w
-  mov x0[4].y, r5.x
-  mov x0[5].y, r5.y
-  mov x0[6].y, r5.z
-  mov x0[7].y, r5.w
-  ieq r6.w, r0.w, l(1)
-  if_nz r6.w
-    or r19.xyz, r6.xyzx, r18.xxxx
-    ishl r19.xyz, r19.xyzx, l(1)
-    ushr r20.xyz, r19.xyzx, l(7)
-    or r19.xyz, r19.xyzx, r20.xyzx
-    or r20.xyz, r7.xyzx, r18.xxxx
-    ishl r20.xyz, r20.xyzx, l(1)
-    ushr r21.xyz, r20.xyzx, l(7)
-    or r20.xyz, r20.xyzx, r21.xyzx
-    mov x0[0].x, r19.x
-    mov x0[1].x, r19.y
-    mov x0[2].x, r19.z
-    mov x0[3].x, l(255)
-    mov x0[0].y, r20.x
-    mov x0[1].y, r20.y
-    mov x0[2].y, r20.z
-    mov x0[3].y, l(255)
-    or r19.xyz, r12.xyzx, r18.xxxx
-    ishl r19.xyz, r19.xyzx, l(1)
-    ushr r20.xyz, r19.xyzx, l(7)
-    or r19.xyz, r19.xyzx, r20.xyzx
-    or r20.xyz, r13.xyzx, r18.xxxx
-    ishl r20.xyz, r20.xyzx, l(1)
-    ushr r21.xyz, r20.xyzx, l(7)
-    or r20.xyz, r20.xyzx, r21.xyzx
-    mov x0[4].x, r19.x
-    mov x0[5].x, r19.y
-    mov x0[6].x, r19.z
-    mov x0[7].x, l(255)
-    mov x0[4].y, r20.x
-    mov x0[5].y, r20.y
-    mov x0[6].y, r20.z
-    mov x0[7].y, l(255)
-  else 
-    ieq r6.w, r0.w, l(3)
-    if_nz r6.w
-      ushr r18.y, r18.x, l(1)
-      and r18.zw, r18.xxxy, l(0, 0, 1, 1)
-      iadd r19.xyz, r8.xyzx, r18.zzzz
-      iadd r20.xyz, r9.xyzx, r18.wwww
-      mov x0[0].x, r19.x
-      mov x0[1].x, r19.y
-      mov x0[2].x, r19.z
-      mov x0[3].x, l(255)
-      mov x0[0].y, r20.x
-      mov x0[1].y, r20.y
-      mov x0[2].y, r20.z
-      mov x0[3].y, l(255)
-    else 
-      ieq r7.w, r0.w, l(7)
-      if_nz r7.w
-        ushr r18.y, r18.x, l(1)
-        and r18.zw, r18.xxxy, l(0, 0, 1, 1)
-        iadd r19.xyzw, r10.xyzw, r18.zzzz
-        ishl r19.xyzw, r19.xyzw, l(2)
-        ushr r20.xyzw, r19.xyzw, l(6)
-        or r19.xyzw, r19.xyzw, r20.xyzw
-        iadd r20.xyzw, r11.xyzw, r18.wwww
-        ishl r20.xyzw, r20.xyzw, l(2)
-        ushr r21.xyzw, r20.xyzw, l(6)
-        or r20.xyzw, r20.xyzw, r21.xyzw
-        mov x0[0].x, r19.x
-        mov x0[1].x, r19.y
-        mov x0[2].x, r19.z
-        mov x0[3].x, r19.w
-        mov x0[0].y, r20.x
-        mov x0[1].y, r20.y
-        mov x0[2].y, r20.z
-        mov x0[3].y, r20.w
-      endif 
-    endif 
-    if_nz r6.w
-      ushr r18.y, r18.x, l(1)
-      and r18.zw, r18.xxxy, l(0, 0, 1, 1)
-      iadd r19.xyz, r14.xyzx, r18.zzzz
-      iadd r20.xyz, r15.xyzx, r18.wwww
-      mov x0[4].x, r19.x
-      mov x0[5].x, r19.y
-      mov x0[6].x, r19.z
-      mov x0[7].x, l(255)
-      mov x0[4].y, r20.x
-      mov x0[5].y, r20.y
-      mov x0[6].y, r20.z
-      mov x0[7].y, l(255)
-    else 
-      ieq r6.w, r0.w, l(7)
-      if_nz r6.w
-        ushr r18.y, r18.x, l(1)
-        and r18.yz, r18.xxyx, l(0, 1, 1, 0)
-        iadd r19.xyzw, r16.xyzw, r18.yyyy
-        ishl r19.xyzw, r19.xyzw, l(2)
-        ushr r20.xyzw, r19.xyzw, l(6)
-        or r19.xyzw, r19.xyzw, r20.xyzw
-        iadd r20.xyzw, r17.xyzw, r18.zzzz
-        ishl r20.xyzw, r20.xyzw, l(2)
-        ushr r21.xyzw, r20.xyzw, l(6)
-        or r20.xyzw, r20.xyzw, r21.xyzw
-        mov x0[4].x, r19.x
-        mov x0[5].x, r19.y
-        mov x0[6].x, r19.z
-        mov x0[7].x, r19.w
-        mov x0[4].y, r20.x
-        mov x0[5].y, r20.y
-        mov x0[6].y, r20.z
-        mov x0[7].y, r20.w
-      endif 
-    endif 
-  endif 
-  mov r19.x, x0[0].y
-  mov r19.y, x0[1].y
-  mov r19.z, x0[2].y
-  mov r19.w, x0[3].y
-  mov r6.w, x0[0].x
-  mov r7.w, x0[1].x
-  mov r8.w, x0[2].x
-  mov r9.w, x0[3].x
-  ineg r20.x, r6.w
-  ineg r20.y, r7.w
-  ineg r20.z, r8.w
-  ineg r20.w, r9.w
-  iadd r21.xyzw, r19.xyzw, r20.xyzw
-  mov r22.x, x0[4].y
-  mov r22.y, x0[5].y
-  mov r22.z, x0[6].y
-  mov r22.w, x0[7].y
-  mov r12.w, x0[4].x
-  mov r13.w, x0[5].x
-  mov r14.w, x0[6].x
-  mov r15.w, x0[7].x
-  ineg r23.x, r12.w
-  ineg r23.y, r13.w
-  ineg r23.z, r14.w
-  ineg r23.w, r15.w
-  iadd r22.xyzw, r22.xyzw, r23.xyzw
-  ine r18.yz, r0.wwww, l(0, 7, 1, 0)
-  movc r22.w, r18.y, l(0), r22.w
-  movc r21.w, r18.y, l(0), r21.w
-  imul null, r23.xy, r21.xyxx, r21.xyxx
-  iadd r12.w, r23.y, r23.x
-  imad r12.w, r21.z, r21.z, r12.w
-  imad r12.w, r21.w, r21.w, r12.w
-  imul null, r23.xy, r22.xyxx, r22.xyxx
-  iadd r13.w, r23.y, r23.x
-  imad r13.w, r22.z, r22.z, r13.w
-  imad r13.w, r22.w, r22.w, r13.w
-  ld_structured r23.xyzw, l(0), l(0), g0.xyzw
-  iadd r20.xyzw, r20.xyzw, r23.xyzw
-  imul null, r20.xy, r20.xyxx, r21.xyxx
-  iadd r14.w, r20.y, r20.x
-  imad r14.w, r21.z, r20.z, r14.w
-  imad r14.w, r21.w, r20.w, r14.w
-  ilt r15.w, l(0), r12.w
-  ilt r18.w, l(0), r14.w
-  and r15.w, r15.w, r18.w
-  itof r14.w, r14.w
-  mul r14.w, r14.w, l(63.499989)
-  ftou r14.w, r14.w
-  ishl r18.w, r12.w, l(5)
-  ult r14.w, r18.w, r14.w
-  and r14.w, r14.w, r15.w
-  ineg r20.xyzw, r21.xyzw
-  movc r20.xyzw, r14.wwww, r20.xyzw, r21.xyzw
-  movc r15.w, r14.w, r19.x, r6.w
-  mov x0[0].x, r15.w
-  mov r18.w, x0[1].x
-  movc r18.w, r14.w, r19.y, r18.w
-  mov x0[1].x, r18.w
-  mov r19.x, x0[2].x
-  movc r19.x, r14.w, r19.z, r19.x
-  mov x0[2].x, r19.x
-  mov r19.y, x0[3].x
-  movc r19.y, r14.w, r19.w, r19.y
-  mov x0[3].x, r19.y
-  mov r19.z, x0[0].y
-  movc r6.w, r14.w, r6.w, r19.z
-  mov x0[0].y, r6.w
-  mov r6.w, x0[1].y
-  movc r6.w, r14.w, r7.w, r6.w
-  mov x0[1].y, r6.w
-  mov r6.w, x0[2].y
-  movc r6.w, r14.w, r8.w, r6.w
-  mov x0[2].y, r6.w
-  mov r6.w, x0[3].y
-  movc r6.w, r14.w, r9.w, r6.w
-  mov x0[3].y, r6.w
-  mov r6.w, vThreadIDInGroupFlattened.x
-  mov r7.w, icb[r6.w + 0].y
-  ld_structured r21.xyzw, r7.w, l(0), g0.xyzw
-  mov r7.w, x0[4].x
-  mov r8.w, x0[5].x
-  mov r9.w, x0[6].x
-  mov r14.w, x0[7].x
-  ineg r23.x, r7.w
-  ineg r23.y, r8.w
-  ineg r23.z, r9.w
-  ineg r23.w, r14.w
-  iadd r21.xyzw, r21.xyzw, r23.xyzw
-  imul null, r19.zw, r21.xxxy, r22.xxxy
-  iadd r19.z, r19.w, r19.z
-  imad r19.z, r22.z, r21.z, r19.z
-  imad r19.z, r22.w, r21.w, r19.z
-  ilt r19.w, l(0), r13.w
-  ilt r21.x, l(0), r19.z
-  and r19.w, r19.w, r21.x
-  itof r19.z, r19.z
-  mul r19.z, r19.z, l(63.499989)
-  ftou r19.z, r19.z
-  ishl r21.x, r13.w, l(5)
-  ult r19.z, r21.x, r19.z
-  and r19.z, r19.z, r19.w
-  ineg r21.xyzw, r22.xyzw
-  movc r21.xyzw, r19.zzzz, r21.xyzw, r22.xyzw
-  mov r19.w, x0[4].y
-  mov r22.x, x0[5].y
-  mov r22.y, x0[6].y
-  mov r22.z, x0[7].y
-  movc r19.w, r19.z, r19.w, r7.w
-  mov x0[4].x, r19.w
-  mov r22.w, x0[5].x
-  movc r22.x, r19.z, r22.x, r22.w
-  mov x0[5].x, r22.x
-  mov r22.w, x0[6].x
-  movc r22.y, r19.z, r22.y, r22.w
-  mov x0[6].x, r22.y
-  mov r22.w, x0[7].x
-  movc r22.z, r19.z, r22.z, r22.w
-  mov x0[7].x, r22.z
-  mov r22.w, x0[4].y
-  movc r7.w, r19.z, r7.w, r22.w
-  mov x0[4].y, r7.w
-  mov r7.w, x0[5].y
-  movc r7.w, r19.z, r8.w, r7.w
-  mov x0[5].y, r7.w
-  mov r7.w, x0[6].y
-  movc r7.w, r19.z, r9.w, r7.w
-  mov x0[6].y, r7.w
-  mov r7.w, x0[7].y
-  movc r7.w, r19.z, r14.w, r7.w
-  mov x0[7].y, r7.w
-  mov x3[0].x, l(0)
-  mov x3[1].x, l(0)
-  ineg r23.x, r19.w
-  ineg r23.yzw, r22.xxyz
-  ige r7.w, l(0), r13.w
-  itof r8.w, r13.w
-  movc r22.xyz, r18.zzzz, l(32,128,3,0), l(16,64,7,0)
-  ineg r24.x, r15.w
-  ineg r24.y, r18.w
-  ineg r24.zw, r19.xxxy
-  ige r9.w, l(0), r12.w
-  itof r14.w, r12.w
-  mov r15.w, l(0)
-  loop 
-    uge r18.z, r15.w, l(16)
-    breakc_nz r18.z
-    ushr r18.z, icb[r6.w + 0].x, r15.w
-    and r18.z, r18.z, l(1)
-    ieq r18.w, r18.z, l(1)
-    if_nz r18.w
-      ld_structured r19.xyzw, r15.w, l(0), g0.xyzw
-      iadd r19.xyzw, r23.xyzw, r19.xyzw
-      imul null, r19.xy, r19.xyxx, r21.xyxx
-      iadd r19.x, r19.y, r19.x
-      imad r19.x, r21.z, r19.z, r19.x
-      imad r19.x, r21.w, r19.w, r19.x
-      ige r19.y, l(0), r19.x
-      or r19.y, r7.w, r19.y
-      ilt r19.z, r19.x, r13.w
-      itof r19.x, r19.x
-      mul r19.x, r19.x, l(63.499989)
-      div r19.x, r19.x, r8.w
-      ftou r19.x, r19.x
-      iadd r19.x, r19.x, r22.y
-      movc r19.x, r19.z, icb[r19.x + 0].w, r22.z
-      movc r19.x, r19.y, l(0), r19.x
-    else 
-      ld_structured r25.xyzw, r15.w, l(0), g0.xyzw
-      iadd r25.xyzw, r24.xyzw, r25.xyzw
-      imul null, r19.yz, r20.xxyx, r25.xxyx
-      iadd r19.y, r19.z, r19.y
-      imad r19.y, r20.z, r25.z, r19.y
-      imad r19.y, r20.w, r25.w, r19.y
-      ige r19.z, l(0), r19.y
-      or r19.z, r9.w, r19.z
-      ilt r19.w, r19.y, r12.w
-      itof r19.y, r19.y
-      mul r19.y, r19.y, l(63.499989)
-      div r19.y, r19.y, r14.w
-      ftou r19.y, r19.y
-      iadd r19.y, r19.y, r22.y
-      movc r19.y, r19.w, icb[r19.y + 0].w, r22.z
-      movc r19.x, r19.z, l(0), r19.y
-    endif 
-    iadd r19.x, r19.x, r22.x
-    iadd r19.y, l(64), -icb[r19.x + 64].x
-    ishl r18.z, r18.z, l(2)
-    mov r25.x, x0[r18.z + 0].x
-    mov r25.y, x0[r18.z + 1].x
-    mov r25.z, x0[r18.z + 2].x
-    mov r25.w, x0[r18.z + 3].x
-    mov r26.x, x0[r18.z + 0].y
-    mov r26.y, x0[r18.z + 1].y
-    mov r26.z, x0[r18.z + 2].y
-    mov r26.w, x0[r18.z + 3].y
-    imul null, r26.xyzw, r26.xyzw, icb[r19.x + 64].xxxx
-    imad r19.xyzw, r19.yyyy, r25.xyzw, r26.xyzw
-    iadd r19.xyzw, r19.xyzw, l(32, 32, 32, 32)
-    ushr r19.xyzw, r19.xzyw, l(6)
-    movc r19.w, r18.y, l(255), r19.w
-    ld_structured r25.xyzw, r15.w, l(0), g0.xyzw
-    ult r26.xyz, r19.xzyx, r25.xyzx
-    mov r27.xz, r25.xxyx
-    mov r27.yw, r19.xxxz
-    movc r27.xyzw, r26.xxyy, r27.xyzw, r27.yxwz
-    mov r19.xz, r25.zzwz
-    movc r19.xy, r26.zzzz, r19.xyxx, r19.yxyy
-    ult r18.z, r19.w, r25.w
-    movc r25.xw, r18.zzzz, r19.wwwz, r19.zzzw
-    ineg r26.xy, r27.ywyy
-    ineg r26.z, r19.y
-    ineg r26.w, r25.x
-    mov r25.xy, r27.xzxx
-    mov r25.z, r19.x
-    iadd r19.xyzw, r26.xyzw, r25.xyzw
-    imul null, r19.xy, r19.xyxx, r19.xyxx
-    iadd r18.z, r19.y, r19.x
-    imad r18.z, r19.z, r19.z, r18.z
-    utof r18.z, r18.z
-    utof r19.x, r19.w
-    mul r19.x, r19.x, r19.x
-    mad r18.z, r19.x, cb0[1].z, r18.z
-    ftou r18.z, r18.z
-    mov r19.x, x3[1].x
-    iadd r19.y, r18.z, r19.x
-    movc r19.x, r18.w, r19.y, r19.x
-    mov x3[1].x, r19.x
-    mov r19.x, x3[0].x
-    iadd r18.z, r18.z, r19.x
-    movc r18.z, r18.w, r19.x, r18.z
-    mov x3[0].x, r18.z
-    iadd r15.w, r15.w, l(1)
-  endloop 
-  mov r6.w, x3[0].x
-  mov r7.w, x2[0].x
-  ult r8.w, r6.w, r7.w
-  umin r6.w, r6.w, r7.w
-  mov x2[0].x, r6.w
-  mov r6.w, x1[0].x
-  movc r6.w, r8.w, r18.x, r6.w
-  mov x1[0].x, r6.w
-  mov r6.w, x3[1].x
-  mov r7.w, x2[1].x
-  ult r8.w, r6.w, r7.w
-  umin r6.w, r6.w, r7.w
-  mov x2[1].x, r6.w
-  mov r6.w, x1[1].x
-  movc r6.w, r8.w, r18.x, r6.w
-  mov x1[1].x, r6.w
-  iadd r18.x, r18.x, l(1)
-endloop 
-mov r0.z, x2[0].x
-mov r0.w, x2[1].x
-iadd r2.x, r0.w, r0.z
-mov r2.y, cb0[0].w
-mov r2.z, vThreadIDInGroupFlattened.x
-store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(16), r2.xyzx
-if_nz r0.y
-  mov r0.y, x1[1].x
-  ishl r0.y, r0.y, l(1)
-  mov r0.z, x1[0].x
-  or r0.y, r0.z, r0.y
-else 
-  mov r0.z, x1[1].x
-  ishl r0.z, r0.z, l(2)
-  mov r0.w, x1[0].x
-  or r0.y, r0.w, r0.z
-endif 
-store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r0.y
-sync_g_t
-if_nz r1.y
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(32)
-  ld_structured r3.yzw, r0.y, l(16), g0.xxyz
-  ld_structured r4.x, r0.y, l(32), g0.xxxx
-  ult r0.z, r3.y, r2.x
-  if_nz r0.z
-    ld_structured r3.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(16), r3.xzwx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r4.x
-  endif 
-endif 
-sync_g_t
-if_nz r1.x
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(16)
-  ld_structured r3.yzw, r0.y, l(16), g0.xxyz
-  ld_structured r4.x, r0.y, l(32), g0.xxxx
-  ult r0.z, r3.y, r2.x
-  if_nz r0.z
-    ld_structured r3.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(16), r3.xzwx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r4.x
-  endif 
-endif 
-sync_g_t
-if_nz r1.z
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r3.yzw, r0.y, l(16), g0.xxyz
-  ld_structured r4.x, r0.y, l(32), g0.xxxx
-  ult r0.z, r3.y, r2.x
-  if_nz r0.z
-    ld_structured r3.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(16), r3.xzwx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r4.x
-  endif 
-endif 
-sync_g_t
-if_nz r1.w
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r2.yzw, r0.y, l(16), g0.xxyz
-  ld_structured r3.x, r0.y, l(32), g0.xxxx
-  ult r0.z, r2.y, r1.x
-  if_nz r0.z
-    ld_structured r2.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(16), r2.xzwx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r3.x
-  endif 
-endif 
-sync_g_t
-ult r0.yz, vThreadIDInGroupFlattened.xxxx, l(0, 2, 1, 0)
-if_nz r0.y
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r2.yzw, r0.y, l(16), g0.xxyz
-  ld_structured r3.x, r0.y, l(32), g0.xxxx
-  ult r0.w, r2.y, r1.x
-  if_nz r0.w
-    ld_structured r2.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(16), r2.xzwx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r3.x
-  endif 
-endif 
-sync_g_t
-if_nz r0.z
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r2.yzw, r0.y, l(16), g0.xxyz
-  ld_structured r3.x, r0.y, l(32), g0.xxxx
-  ult r0.z, r2.y, r1.x
-  if_nz r0.z
-    ld_structured r2.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xyz, vThreadIDInGroupFlattened.x, l(16), r2.xzwx
-    store_structured g0.x, vThreadIDInGroupFlattened.x, l(32), r3.x
-  endif 
-  ld_structured r1.x, r0.x, l(0), t1.xxxx
-  ld_structured r2.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  ult r0.y, r2.x, r1.x
-  if_nz r0.y
-    ld_structured r1.xyz, vThreadIDInGroupFlattened.x, l(16), g0.xyzx
-    ld_structured r1.w, vThreadIDInGroupFlattened.x, l(32), g0.xxxx
-  else 
-    ld_structured r1.xyzw, r0.x, l(0), t1.xyzw
-  endif 
-  store_structured u0.xyzw, r0.x, l(0), r1.xyzw
-endif 
-ret 
-// Approximately 0 instruction slots used
-#endif
-
-const BYTE BC7Encode_TryMode137CS[] =
-{
-     68,  88,  66,  67, 237,  85, 
-    208, 125,   4,   8, 223, 249, 
-    164, 254,  64,  15, 135,   5, 
-    113, 116,   1,   0,   0,   0, 
-     48,  76,   0,   0,   3,   0, 
-      0,   0,  44,   0,   0,   0, 
-     60,   0,   0,   0,  76,   0, 
-      0,   0,  73,  83,  71,  78, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     79,  83,  71,  78,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  83,  72, 
-     69,  88, 220,  75,   0,   0, 
-     64,   0,   5,   0, 247,  18, 
-      0,   0, 106,   8,   0,   1, 
-     53,  24,   0,   0,   2,   3, 
-      0,   0, 204, 204,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    136, 136,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 238, 238, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0, 200, 236,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-    128, 200,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0, 236, 254, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0, 200, 254,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-    128, 236,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0, 200, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0, 236, 255,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-    128, 254,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0, 232, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0, 232, 255,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0, 255,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0, 240, 255, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0, 240,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     16, 247,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0, 142,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0, 113,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-    206,   8,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0, 140,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  16, 115,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,  49,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0, 206, 140, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0, 140,   8,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     16,  49,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0, 102, 102, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0, 108,  54,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-    232,  23,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0, 240,  15, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0, 142, 113,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-    156,  57,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0, 170, 170, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0, 240, 240,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     90,  90,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0, 204,  51, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  60,  60,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-    170,  85,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      9,   0,   0,   0, 150, 150, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   9,   0, 
-      0,   0,  90, 165,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-    206, 115,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      9,   0,   0,   0, 200,  19, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,  76,  50,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-    220,  59,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,   0,   0, 150, 105, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,  60, 195,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-    102, 153,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-     11,   0,   0,   0,  96,   6, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,  11,   0, 
-      0,   0, 114,   2,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,  11,   0,   0,   0, 
-    228,   4,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     11,   0,   0,   0,  64,  78, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0,  32,  39,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,  12,   0,   0,   0, 
-     54, 201,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-     12,   0,   0,   0, 108, 147, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0, 198,  57,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  13,   0,   0,   0, 
-    156,  99,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,  54, 147, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,  13,   0, 
-      0,   0, 198, 156,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  13,   0,   0,   0, 
-    126, 129,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,  24, 231, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,  14,   0, 
-      0,   0, 240, 204,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  14,   0,   0,   0, 
-    204,  15,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,  68, 119, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,  34, 238,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   3,   0,   0,   0, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-     15,   0,   0,   0,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,  17,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   0,   0, 
-      0,   0,  21,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   0,  15,   0,   0,   0, 
-      8,   0,   0,   0,   1,   0, 
-      0,   0,  34,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   0, 
-     38,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      1,   0,   0,   0,  43,   0, 
-      0,   0,   6,   0,   0,   0, 
-     15,   0,   0,   0,   1,   0, 
-      0,   0,  47,   0,   0,   0, 
-      6,   0,   0,   0,  15,   0, 
-      0,   0,   1,   0,   0,   0, 
-     51,   0,   0,   0,   6,   0, 
-      0,   0,  15,   0,   0,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   1,   0, 
-      0,   0,  60,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   2,   0,   0,   0, 
-     64,   0,   0,   0,   3,   0, 
-      0,   0,   8,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   2,   0, 
-      0,   0,   9,   0,   0,   0, 
-      3,   0,   0,   0,   8,   0, 
-      0,   0,   2,   0,   0,   0, 
-     18,   0,   0,   0,   8,   0, 
-      0,   0,  15,   0,   0,   0, 
-      2,   0,   0,   0,  27,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   2,   0, 
-      0,   0,  37,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   2,   0,   0,   0, 
-     46,   0,   0,   0,   3,   0, 
-      0,   0,   8,   0,   0,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   0,   6,   0,   0,   0, 
-     15,   0,   0,   0,   2,   0, 
-      0,   0,  64,   0,   0,   0, 
-     10,   0,   0,   0,   8,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   3,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,   6,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  10,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,  10,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      8,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-     21,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      4,   0,   0,   0,  43,   0, 
-      0,   0,   3,   0,   0,   0, 
-     15,   0,   0,   0,   4,   0, 
-      0,   0,  64,   0,   0,   0, 
-      5,   0,   0,   0,  10,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  10,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-      8,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,   9,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,  10,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   8,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   3,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   6,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-     15,   0,   0,   0,   8,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  15,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      3,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     15,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  15,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-     15,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  15,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,  15,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     15,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,  15,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   3,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,  12,   0,   0,   0, 
-     15,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  15,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   8,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  89,   0,   0,   4, 
-     70, 142,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     88,  24,   0,   4,   0, 112, 
-     16,   0,   0,   0,   0,   0, 
-     85,  85,   0,   0, 162,   0, 
-      0,   4,   0, 112,  16,   0, 
-      1,   0,   0,   0,  16,   0, 
-      0,   0, 158,   0,   0,   4, 
-      0, 224,  17,   0,   0,   0, 
-      0,   0,  16,   0,   0,   0, 
-     95,   0,   0,   2,   0,  64, 
-      2,   0,  95,   0,   0,   2, 
-     18,  16,   2,   0, 104,   0, 
-      0,   2,  28,   0,   0,   0, 
-    105,   0,   0,   4,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-      4,   0,   0,   0, 105,   0, 
-      0,   4,   1,   0,   0,   0, 
-      2,   0,   0,   0,   4,   0, 
-      0,   0, 105,   0,   0,   4, 
-      2,   0,   0,   0,   2,   0, 
-      0,   0,   4,   0,   0,   0, 
-    105,   0,   0,   4,   3,   0, 
-      0,   0,   2,   0,   0,   0, 
-      4,   0,   0,   0, 160,   0, 
-      0,   5,   0, 240,  17,   0, 
-      0,   0,   0,   0, 100,   0, 
-      0,   0,  64,   0,   0,   0, 
-    155,   0,   0,   4,  64,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      0,   0,   0,   0,  10,  16, 
-      2,   0,  10, 128,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  79,   0,   0,   9, 
-    242,   0,  16,   0,   1,   0, 
-      0,   0,   6,  64,   2,   0, 
-      2,  64,   0,   0,  16,   0, 
-      0,   0,  32,   0,   0,   0, 
-      8,   0,   0,   0,   4,   0, 
-      0,   0,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  78,   0,   0,   9, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,   0, 208,   0,   0, 
-     10,   0,  16,   0,   0,   0, 
-      0,   0,  26, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  35,   0,   0,  11, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16, 128, 
-     65,   0,   0,   0,   0,   0, 
-      0,   0,  26, 128,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   6, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   6,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  54,   0,   0,   8, 
-    194,   0,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  45,   0, 
-      0,   7, 242,   0,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-     70, 126,  16,   0,   0,   0, 
-      0,   0,  56,   0,   0,  10, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0, 127,  67, 
-      0,   0, 127,  67,   0,   0, 
-    127,  67,   0,   0, 127,  67, 
-     28,   0,   0,   5, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   2,   0, 
-      0,   0,  84,   0,   0,  10, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0, 255,   0,   0,   0, 
-    255,   0,   0,   0, 255,   0, 
-      0,   0, 255,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70,  14,  16,   0,   2,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255, 255, 255, 255,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,  80,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   3,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  54,   0,   0,   4, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-     85,   0,   0,   8,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10, 144, 144,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     32,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,  83,   0,   0,   7, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      3,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  54,   0,   0,   6, 
-     66,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   3,   0, 
-      0,   0,  26,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  83,   0,   0,   7, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     21,   0,   0,   1,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  22,   0,   0,   1, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   5,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-     32,   0,   0,   8,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  55,   0,   0,   9, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  54,   0,   0,   6, 
-     18,  48,  32,   0,   2,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0, 255, 255, 
-    255, 255,  35,   0,   0,  15, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0, 127, 127,   0,   0, 
-    127, 127,   0,   0, 127, 127, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  70,   2,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   6,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-      0,   0,   0,   0,  35,   0, 
-      0,  15, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0, 127, 127, 
-      0,   0, 127, 127,   0,   0, 
-    127, 127,   0,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255, 255, 255, 254, 255, 
-    255, 255, 254, 255, 255, 255, 
-      0,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-      9,   0,   0,   0,  70,   2, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-    255, 255, 254, 255, 255, 255, 
-    254, 255, 255, 255,   0,   0, 
-      0,   0,  35,   0,   0,  15, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,   2,  64, 
-      0,   0,  63,  63,   0,   0, 
-     63,  63,   0,   0,  63,  63, 
-      0,   0,  63,  63,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,  85,   0,   0,   7, 
-    242,   0,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,  10,   0,   0,   0, 
-     70,  14,  16,   0,  10,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0,  35,   0, 
-      0,  15, 242,   0,  16,   0, 
-     11,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-      2,  64,   0,   0,  63,  63, 
-      0,   0,  63,  63,   0,   0, 
-     63,  63,   0,   0,  63,  63, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,  85,   0, 
-      0,   7, 242,   0,  16,   0, 
-     11,   0,   0,   0,  70,  14, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,  11,   0, 
-      0,   0,  70,  14,  16,   0, 
-     11,   0,   0,   0,   2,  64, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-     35,   0,   0,  15, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    127, 127,   0,   0, 127, 127, 
-      0,   0, 127, 127,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,  12,   0,   0,   0, 
-     70,   2,  16,   0,  12,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-     12,   0,   0,   0,  70,   2, 
-     16,   0,  12,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0,   0,   0, 
-      0,   0,  35,   0,   0,  15, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0, 127, 127,   0,   0, 
-    127, 127,   0,   0, 127, 127, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  13,   0, 
-      0,   0,  70,   2,  16,   0, 
-     13,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,  10, 114,   0,  16,   0, 
-     14,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-    255, 255, 254, 255, 255, 255, 
-    254, 255, 255, 255,   0,   0, 
-      0,   0,   1,   0,   0,  10, 
-    114,   0,  16,   0,  15,   0, 
-      0,   0,  70,   2,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0, 254, 255, 255, 255, 
-    254, 255, 255, 255, 254, 255, 
-    255, 255,   0,   0,   0,   0, 
-     35,   0,   0,  15, 242,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-     63,  63,   0,   0,  63,  63, 
-      0,   0,  63,  63,   0,   0, 
-     63,  63,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-     85,   0,   0,   7, 242,   0, 
-     16,   0,  16,   0,   0,   0, 
-     70,  14,  16,   0,  16,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   1,   0, 
-      0,  10, 242,   0,  16,   0, 
-     16,   0,   0,   0,  70,  14, 
-     16,   0,  16,   0,   0,   0, 
-      2,  64,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0,  35,   0,   0,  15, 
-    242,   0,  16,   0,  17,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0,  63,  63,   0,   0, 
-     63,  63,   0,   0,  63,  63, 
-      0,   0,  63,  63,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,  85,   0,   0,   7, 
-    242,   0,  16,   0,  17,   0, 
-      0,   0,  70,  14,  16,   0, 
-     17,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,  17,   0,   0,   0, 
-     70,  14,  16,   0,  17,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255,   0,   0, 254, 255, 
-      0,   0, 254, 255,   0,   0, 
-    254, 255,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58, 128, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-     18,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,  80,   0, 
-      0,   7, 130,   0,  16,   0, 
-      6,   0,   0,   0,  10,   0, 
-     16,   0,  18,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   3,   0,   4,   3, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   5,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     26,   0,  16,   0,   5,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   5,   0, 
-      0,   0,  32,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,   6,   0, 
-      0,   0,   6,   0,  16,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-     20,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      6,   0,  16,   0,  18,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,  21,   0,   0,   0, 
-     70,   2,  16,   0,  20,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-     20,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  21,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,  19,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0, 255,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,  20,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,  20,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,  20,   0, 
-      0,   0,  54,   0,   0,   6, 
-     34,  48,  32,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      1,  64,   0,   0, 255,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,   6,   0, 
-     16,   0,  18,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,  19,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     20,   0,   0,   0,  70,   2, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     19,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,   6,   0,  16,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     20,   0,   0,   0,  70,   2, 
-     16,   0,  20,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  21,   0, 
-      0,   0,  70,   2,  16,   0, 
-     20,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  20,   0, 
-      0,   0,  70,   2,  16,   0, 
-     21,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     85,   0,   0,   7,  34,   0, 
-     16,   0,  18,   0,   0,   0, 
-     10,   0,  16,   0,  18,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-     18,   0,   0,   0,   6,   4, 
-     16,   0,  18,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0, 166,  10, 
-     16,   0,  18,   0,   0,   0, 
-     30,   0,   0,   7, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,   9,   0, 
-      0,   0, 246,  15,  16,   0, 
-     18,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     85,   0,   0,   7,  34,   0, 
-     16,   0,  18,   0,   0,   0, 
-     10,   0,  16,   0,  18,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-     18,   0,   0,   0,   6,   4, 
-     16,   0,  18,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,  19,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0, 166,  10, 
-     16,   0,  18,   0,   0,   0, 
-     41,   0,   0,   7, 242,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,  14,  16,   0,  19,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7, 242,   0,  16,   0, 
-     20,   0,   0,   0,  70,  14, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  60,   0,   0,   7, 
-    242,   0,  16,   0,  19,   0, 
-      0,   0,  70,  14,  16,   0, 
-     19,   0,   0,   0,  70,  14, 
-     16,   0,  20,   0,   0,   0, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,  14,  16,   0,  11,   0, 
-      0,   0, 246,  15,  16,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7, 242,   0,  16,   0, 
-     20,   0,   0,   0,  70,  14, 
-     16,   0,  20,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-    242,   0,  16,   0,  21,   0, 
-      0,   0,  70,  14,  16,   0, 
-     20,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     60,   0,   0,   7, 242,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,  14,  16,   0,  20,   0, 
-      0,   0,  70,  14,  16,   0, 
-     21,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-     20,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     85,   0,   0,   7,  34,   0, 
-     16,   0,  18,   0,   0,   0, 
-     10,   0,  16,   0,  18,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,  10, 194,   0,  16,   0, 
-     18,   0,   0,   0,   6,   4, 
-     16,   0,  18,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-    114,   0,  16,   0,  19,   0, 
-      0,   0,  70,   2,  16,   0, 
-     14,   0,   0,   0, 166,  10, 
-     16,   0,  18,   0,   0,   0, 
-     30,   0,   0,   7, 114,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   2,  16,   0,  15,   0, 
-      0,   0, 246,  15,  16,   0, 
-     18,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-    255,   0,   0,   0,  18,   0, 
-      0,   1,  32,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   7,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     85,   0,   0,   7,  34,   0, 
-     16,   0,  18,   0,   0,   0, 
-     10,   0,  16,   0,  18,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,  10,  98,   0,  16,   0, 
-     18,   0,   0,   0,   6,   1, 
-     16,   0,  18,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,  19,   0, 
-      0,   0,  70,  14,  16,   0, 
-     16,   0,   0,   0,  86,   5, 
-     16,   0,  18,   0,   0,   0, 
-     41,   0,   0,   7, 242,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,  14,  16,   0,  19,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7, 242,   0,  16,   0, 
-     20,   0,   0,   0,  70,  14, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  60,   0,   0,   7, 
-    242,   0,  16,   0,  19,   0, 
-      0,   0,  70,  14,  16,   0, 
-     19,   0,   0,   0,  70,  14, 
-     16,   0,  20,   0,   0,   0, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,  14,  16,   0,  17,   0, 
-      0,   0, 166,  10,  16,   0, 
-     18,   0,   0,   0,  41,   0, 
-      0,   7, 242,   0,  16,   0, 
-     20,   0,   0,   0,  70,  14, 
-     16,   0,  20,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-    242,   0,  16,   0,  21,   0, 
-      0,   0,  70,  14,  16,   0, 
-     20,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     60,   0,   0,   7, 242,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,  14,  16,   0,  20,   0, 
-      0,   0,  70,  14,  16,   0, 
-     21,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  10,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-     20,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-     21,   0,   0,   1,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-     19,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-     19,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-     19,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-     19,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      6,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      7,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      8,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      9,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  40,   0, 
-      0,   5,  18,   0,  16,   0, 
-     20,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     40,   0,   0,   5,  34,   0, 
-     16,   0,  20,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  40,   0,   0,   5, 
-     66,   0,  16,   0,  20,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  40,   0, 
-      0,   5, 130,   0,  16,   0, 
-     20,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,  21,   0,   0,   0, 
-     70,  14,  16,   0,  19,   0, 
-      0,   0,  70,  14,  16,   0, 
-     20,   0,   0,   0,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-     22,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-     22,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-     22,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-     22,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-     12,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-     13,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-     14,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-     15,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,  40,   0, 
-      0,   5,  18,   0,  16,   0, 
-     23,   0,   0,   0,  58,   0, 
-     16,   0,  12,   0,   0,   0, 
-     40,   0,   0,   5,  34,   0, 
-     16,   0,  23,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0,  40,   0,   0,   5, 
-     66,   0,  16,   0,  23,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,  40,   0, 
-      0,   5, 130,   0,  16,   0, 
-     23,   0,   0,   0,  58,   0, 
-     16,   0,  15,   0,   0,   0, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,  22,   0,   0,   0, 
-     70,  14,  16,   0,  22,   0, 
-      0,   0,  70,  14,  16,   0, 
-     23,   0,   0,   0,  39,   0, 
-      0,  10,  98,   0,  16,   0, 
-     18,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,  22,   0, 
-      0,   0,  26,   0,  16,   0, 
-     18,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  22,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,  21,   0, 
-      0,   0,  26,   0,  16,   0, 
-     18,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  21,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0,  50,   0, 
-     16,   0,  23,   0,   0,   0, 
-     70,   0,  16,   0,  21,   0, 
-      0,   0,  70,   0,  16,   0, 
-     21,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-     12,   0,   0,   0,  26,   0, 
-     16,   0,  23,   0,   0,   0, 
-     10,   0,  16,   0,  23,   0, 
-      0,   0,  35,   0,   0,   9, 
-    130,   0,  16,   0,  12,   0, 
-      0,   0,  42,   0,  16,   0, 
-     21,   0,   0,   0,  42,   0, 
-     16,   0,  21,   0,   0,   0, 
-     58,   0,  16,   0,  12,   0, 
-      0,   0,  35,   0,   0,   9, 
-    130,   0,  16,   0,  12,   0, 
-      0,   0,  58,   0,  16,   0, 
-     21,   0,   0,   0,  58,   0, 
-     16,   0,  21,   0,   0,   0, 
-     58,   0,  16,   0,  12,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0,  50,   0, 
-     16,   0,  23,   0,   0,   0, 
-     70,   0,  16,   0,  22,   0, 
-      0,   0,  70,   0,  16,   0, 
-     22,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-     13,   0,   0,   0,  26,   0, 
-     16,   0,  23,   0,   0,   0, 
-     10,   0,  16,   0,  23,   0, 
-      0,   0,  35,   0,   0,   9, 
-    130,   0,  16,   0,  13,   0, 
-      0,   0,  42,   0,  16,   0, 
-     22,   0,   0,   0,  42,   0, 
-     16,   0,  22,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0,  35,   0,   0,   9, 
-    130,   0,  16,   0,  13,   0, 
-      0,   0,  58,   0,  16,   0, 
-     22,   0,   0,   0,  58,   0, 
-     16,   0,  22,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,  23,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,  20,   0, 
-      0,   0,  70,  14,  16,   0, 
-     20,   0,   0,   0,  70,  14, 
-     16,   0,  23,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0,  50,   0,  16,   0, 
-     20,   0,   0,   0,  70,   0, 
-     16,   0,  20,   0,   0,   0, 
-     70,   0,  16,   0,  21,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,  14,   0, 
-      0,   0,  26,   0,  16,   0, 
-     20,   0,   0,   0,  10,   0, 
-     16,   0,  20,   0,   0,   0, 
-     35,   0,   0,   9, 130,   0, 
-     16,   0,  14,   0,   0,   0, 
-     42,   0,  16,   0,  21,   0, 
-      0,   0,  42,   0,  16,   0, 
-     20,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     35,   0,   0,   9, 130,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,  21,   0, 
-      0,   0,  58,   0,  16,   0, 
-     20,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     34,   0,   0,   7, 130,   0, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-     12,   0,   0,   0,  34,   0, 
-      0,   7, 130,   0,  16,   0, 
-     18,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  14,   0, 
-      0,   0,   1,   0,   0,   7, 
-    130,   0,  16,   0,  15,   0, 
-      0,   0,  58,   0,  16,   0, 
-     15,   0,   0,   0,  58,   0, 
-     16,   0,  18,   0,   0,   0, 
-     43,   0,   0,   5, 130,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,  14,   0, 
-      0,   0,  56,   0,   0,   7, 
-    130,   0,  16,   0,  14,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     28,   0,   0,   5, 130,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,  14,   0, 
-      0,   0,  41,   0,   0,   7, 
-    130,   0,  16,   0,  18,   0, 
-      0,   0,  58,   0,  16,   0, 
-     12,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     79,   0,   0,   7, 130,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,  18,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-     14,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,  15,   0, 
-      0,   0,  40,   0,   0,   5, 
-    242,   0,  16,   0,  20,   0, 
-      0,   0,  70,  14,  16,   0, 
-     21,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-     20,   0,   0,   0, 246,  15, 
-     16,   0,  14,   0,   0,   0, 
-     70,  14,  16,   0,  20,   0, 
-      0,   0,  70,  14,  16,   0, 
-     21,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-     15,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-     15,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-     18,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-     18,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     26,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-     18,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-     18,   0,   0,   0,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-     19,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   9,  18,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  34,   0,  16,   0, 
-     19,   0,   0,   0,  10,  48, 
-     32,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9,  34,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,  19,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-     19,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      6,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      6,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      6,   0,   0,   0,  26,  48, 
-     32,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6,  34,  48,  32,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   4, 130,   0,  16,   0, 
-      6,   0,   0,   0,  10,  64, 
-      2,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  26, 144, 144,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,  21,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,  14,   0, 
-      0,   0,  10,  48,  32,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,  40,   0,   0,   5, 
-     18,   0,  16,   0,  23,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  40,   0, 
-      0,   5,  34,   0,  16,   0, 
-     23,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     40,   0,   0,   5,  66,   0, 
-     16,   0,  23,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  40,   0,   0,   5, 
-    130,   0,  16,   0,  23,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,  30,   0, 
-      0,   7, 242,   0,  16,   0, 
-     21,   0,   0,   0,  70,  14, 
-     16,   0,  21,   0,   0,   0, 
-     70,  14,  16,   0,  23,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0, 194,   0, 
-     16,   0,  19,   0,   0,   0, 
-      6,   4,  16,   0,  21,   0, 
-      0,   0,   6,   4,  16,   0, 
-     22,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  19,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  35,   0,   0,   9, 
-     66,   0,  16,   0,  19,   0, 
-      0,   0,  42,   0,  16,   0, 
-     22,   0,   0,   0,  42,   0, 
-     16,   0,  21,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  35,   0,   0,   9, 
-     66,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-     22,   0,   0,   0,  58,   0, 
-     16,   0,  21,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  34,   0,   0,   7, 
-    130,   0,  16,   0,  19,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,  13,   0,   0,   0, 
-     34,   0,   0,   7,  18,   0, 
-     16,   0,  21,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  19,   0,   0,   0, 
-     10,   0,  16,   0,  21,   0, 
-      0,   0,  43,   0,   0,   5, 
-     66,   0,  16,   0,  19,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  56,   0, 
-      0,   7,  66,   0,  16,   0, 
-     19,   0,   0,   0,  42,   0, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0, 253, 255, 
-    125,  66,  28,   0,   0,   5, 
-     66,   0,  16,   0,  19,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7,  18,   0,  16,   0, 
-     21,   0,   0,   0,  58,   0, 
-     16,   0,  13,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  79,   0,   0,   7, 
-     66,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-     21,   0,   0,   0,  42,   0, 
-     16,   0,  19,   0,   0,   0, 
-      1,   0,   0,   7,  66,   0, 
-     16,   0,  19,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-     19,   0,   0,   0,  40,   0, 
-      0,   5, 242,   0,  16,   0, 
-     21,   0,   0,   0,  70,  14, 
-     16,   0,  22,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,  21,   0,   0,   0, 
-    166,  10,  16,   0,  19,   0, 
-      0,   0,  70,  14,  16,   0, 
-     21,   0,   0,   0,  70,  14, 
-     16,   0,  22,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,  19,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     54,   0,   0,   6,  18,   0, 
-     16,   0,  22,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,  22,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,  22,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-     55,   0,   0,   9, 130,   0, 
-     16,   0,  19,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,  19,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,  22,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9,  18,   0, 
-     16,   0,  22,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-     22,   0,   0,   0,  58,   0, 
-     16,   0,  22,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  10,   0, 
-     16,   0,  22,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,  22,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     55,   0,   0,   9,  34,   0, 
-     16,   0,  22,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  26,   0,  16,   0, 
-     22,   0,   0,   0,  58,   0, 
-     16,   0,  22,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  26,   0, 
-     16,   0,  22,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,  22,   0,   0,   0, 
-     10,  48,  32,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-     55,   0,   0,   9,  66,   0, 
-     16,   0,  22,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  42,   0,  16,   0, 
-     22,   0,   0,   0,  58,   0, 
-     16,   0,  22,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,  42,   0, 
-     16,   0,  22,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,  22,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     55,   0,   0,   9, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,  22,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     55,   0,   0,   9, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,  48,  32,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-     55,   0,   0,   9, 130,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6,  34,  48, 
-     32,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   3,   0,   0,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     40,   0,   0,   5,  18,   0, 
-     16,   0,  23,   0,   0,   0, 
-     58,   0,  16,   0,  19,   0, 
-      0,   0,  40,   0,   0,   5, 
-    226,   0,  16,   0,  23,   0, 
-      0,   0,   6,   9,  16,   0, 
-     22,   0,   0,   0,  33,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0,  43,   0,   0,   5, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-     13,   0,   0,   0,  55,   0, 
-      0,  15, 114,   0,  16,   0, 
-     22,   0,   0,   0, 166,  10, 
-     16,   0,  18,   0,   0,   0, 
-      2,  64,   0,   0,  32,   0, 
-      0,   0, 128,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-     16,   0,   0,   0,  64,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,  40,   0, 
-      0,   5,  18,   0,  16,   0, 
-     24,   0,   0,   0,  58,   0, 
-     16,   0,  15,   0,   0,   0, 
-     40,   0,   0,   5,  34,   0, 
-     16,   0,  24,   0,   0,   0, 
-     58,   0,  16,   0,  18,   0, 
-      0,   0,  40,   0,   0,   5, 
-    194,   0,  16,   0,  24,   0, 
-      0,   0,   6,   4,  16,   0, 
-     19,   0,   0,   0,  33,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  12,   0, 
-      0,   0,  43,   0,   0,   5, 
-    130,   0,  16,   0,  14,   0, 
-      0,   0,  58,   0,  16,   0, 
-     12,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-     15,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     48,   0,   0,   1,  80,   0, 
-      0,   7,  66,   0,  16,   0, 
-     18,   0,   0,   0,  58,   0, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   3,   0,   4,   3, 
-     42,   0,  16,   0,  18,   0, 
-      0,   0,  85,   0,   0,   8, 
-     66,   0,  16,   0,  18,   0, 
-      0,   0,  10, 144, 144,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-     15,   0,   0,   0,   1,   0, 
-      0,   7,  66,   0,  16,   0, 
-     18,   0,   0,   0,  42,   0, 
-     16,   0,  18,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  32,   0,   0,   7, 
-    130,   0,  16,   0,  18,   0, 
-      0,   0,  42,   0,  16,   0, 
-     18,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,  18,   0,   0,   0, 
-    167,   0,   0,   9, 242,   0, 
-     16,   0,  19,   0,   0,   0, 
-     58,   0,  16,   0,  15,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,  14,  16,   0,  23,   0, 
-      0,   0,  70,  14,  16,   0, 
-     19,   0,   0,   0,  38,   0, 
-      0,   8,   0, 208,   0,   0, 
-     50,   0,  16,   0,  19,   0, 
-      0,   0,  70,   0,  16,   0, 
-     19,   0,   0,   0,  70,   0, 
-     16,   0,  21,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,  19,   0,   0,   0, 
-     26,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  35,   0, 
-      0,   9,  18,   0,  16,   0, 
-     19,   0,   0,   0,  42,   0, 
-     16,   0,  21,   0,   0,   0, 
-     42,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  35,   0, 
-      0,   9,  18,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  21,   0,   0,   0, 
-     58,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  33,   0, 
-      0,   7,  34,   0,  16,   0, 
-     19,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  26,   0, 
-     16,   0,  19,   0,   0,   0, 
-     34,   0,   0,   7,  66,   0, 
-     16,   0,  19,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-     13,   0,   0,   0,  43,   0, 
-      0,   5,  18,   0,  16,   0, 
-     19,   0,   0,   0,  10,   0, 
-     16,   0,  19,   0,   0,   0, 
-     56,   0,   0,   7,  18,   0, 
-     16,   0,  19,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  14,   0, 
-      0,   7,  18,   0,  16,   0, 
-     19,   0,   0,   0,  10,   0, 
-     16,   0,  19,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  28,   0,   0,   5, 
-     18,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-     19,   0,   0,   0,  10,   0, 
-     16,   0,  19,   0,   0,   0, 
-     26,   0,  16,   0,  22,   0, 
-      0,   0,  55,   0,   0,  10, 
-     18,   0,  16,   0,  19,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  58, 144, 
-    144,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  42,   0, 
-     16,   0,  22,   0,   0,   0, 
-     55,   0,   0,   9,  18,   0, 
-     16,   0,  19,   0,   0,   0, 
-     26,   0,  16,   0,  19,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,  19,   0,   0,   0, 
-     18,   0,   0,   1, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-     25,   0,   0,   0,  58,   0, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   7, 242,   0,  16,   0, 
-     25,   0,   0,   0,  70,  14, 
-     16,   0,  24,   0,   0,   0, 
-     70,  14,  16,   0,  25,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0,  98,   0, 
-     16,   0,  19,   0,   0,   0, 
-      6,   1,  16,   0,  20,   0, 
-      0,   0,   6,   1,  16,   0, 
-     25,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-     19,   0,   0,   0,  42,   0, 
-     16,   0,  19,   0,   0,   0, 
-     26,   0,  16,   0,  19,   0, 
-      0,   0,  35,   0,   0,   9, 
-     34,   0,  16,   0,  19,   0, 
-      0,   0,  42,   0,  16,   0, 
-     20,   0,   0,   0,  42,   0, 
-     16,   0,  25,   0,   0,   0, 
-     26,   0,  16,   0,  19,   0, 
-      0,   0,  35,   0,   0,   9, 
-     34,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-     20,   0,   0,   0,  58,   0, 
-     16,   0,  25,   0,   0,   0, 
-     26,   0,  16,   0,  19,   0, 
-      0,   0,  33,   0,   0,   7, 
-     66,   0,  16,   0,  19,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,  19,   0,   0,   0, 
-     60,   0,   0,   7,  66,   0, 
-     16,   0,  19,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  34,   0, 
-      0,   7, 130,   0,  16,   0, 
-     19,   0,   0,   0,  26,   0, 
-     16,   0,  19,   0,   0,   0, 
-     58,   0,  16,   0,  12,   0, 
-      0,   0,  43,   0,   0,   5, 
-     34,   0,  16,   0,  19,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  56,   0, 
-      0,   7,  34,   0,  16,   0, 
-     19,   0,   0,   0,  26,   0, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0, 253, 255, 
-    125,  66,  14,   0,   0,   7, 
-     34,   0,  16,   0,  19,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     28,   0,   0,   5,  34,   0, 
-     16,   0,  19,   0,   0,   0, 
-     26,   0,  16,   0,  19,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,  19,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  26,   0, 
-     16,   0,  22,   0,   0,   0, 
-     55,   0,   0,  10,  34,   0, 
-     16,   0,  19,   0,   0,   0, 
-     58,   0,  16,   0,  19,   0, 
-      0,   0,  58, 144, 144,   0, 
-     26,   0,  16,   0,  19,   0, 
-      0,   0,  42,   0,  16,   0, 
-     22,   0,   0,   0,  55,   0, 
-      0,   9,  18,   0,  16,   0, 
-     19,   0,   0,   0,  42,   0, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  21,   0, 
-      0,   1,  30,   0,   0,   7, 
-     18,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  10,   0, 
-     16,   0,  22,   0,   0,   0, 
-     30,   0,   0,  10,  34,   0, 
-     16,   0,  19,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,  10, 144, 208, 128, 
-     65,   0,   0,   0,  64,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  41,   0, 
-      0,   7,  66,   0,  16,   0, 
-     18,   0,   0,   0,  42,   0, 
-     16,   0,  18,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  54,   0,   0,   7, 
-     18,   0,  16,   0,  25,   0, 
-      0,   0,  10,  48,  32,   4, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,  18,   0,   0,   0, 
-     54,   0,   0,   8,  34,   0, 
-     16,   0,  25,   0,   0,   0, 
-     10,  48,  32,   6,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,  18,   0, 
-      0,   0,  54,   0,   0,   8, 
-     66,   0,  16,   0,  25,   0, 
-      0,   0,  10,  48,  32,   6, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-     18,   0,   0,   0,  54,   0, 
-      0,   8, 130,   0,  16,   0, 
-     25,   0,   0,   0,  10,  48, 
-     32,   6,   0,   0,   0,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,  18,   0,   0,   0, 
-     54,   0,   0,   7,  18,   0, 
-     16,   0,  26,   0,   0,   0, 
-     26,  48,  32,   4,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-     18,   0,   0,   0,  54,   0, 
-      0,   8,  34,   0,  16,   0, 
-     26,   0,   0,   0,  26,  48, 
-     32,   6,   0,   0,   0,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,  18,   0,   0,   0, 
-     54,   0,   0,   8,  66,   0, 
-     16,   0,  26,   0,   0,   0, 
-     26,  48,  32,   6,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,  18,   0, 
-      0,   0,  54,   0,   0,   8, 
-    130,   0,  16,   0,  26,   0, 
-      0,   0,  26,  48,  32,   6, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  42,   0,  16,   0, 
-     18,   0,   0,   0,  38,   0, 
-      0,  10,   0, 208,   0,   0, 
-    242,   0,  16,   0,  26,   0, 
-      0,   0,  70,  14,  16,   0, 
-     26,   0,   0,   0,   6, 144, 
-    208,   0,  64,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  35,   0,   0,   9, 
-    242,   0,  16,   0,  19,   0, 
-      0,   0,  86,   5,  16,   0, 
-     19,   0,   0,   0,  70,  14, 
-     16,   0,  25,   0,   0,   0, 
-     70,  14,  16,   0,  26,   0, 
-      0,   0,  30,   0,   0,  10, 
-    242,   0,  16,   0,  19,   0, 
-      0,   0,  70,  14,  16,   0, 
-     19,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-     32,   0,   0,   0,  32,   0, 
-      0,   0,  32,   0,   0,   0, 
-     85,   0,   0,   7, 242,   0, 
-     16,   0,  19,   0,   0,   0, 
-    134,  13,  16,   0,  19,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-     19,   0,   0,   0,  26,   0, 
-     16,   0,  18,   0,   0,   0, 
-      1,  64,   0,   0, 255,   0, 
-      0,   0,  58,   0,  16,   0, 
-     19,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-     25,   0,   0,   0,  58,   0, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  79,   0, 
-      0,   7, 114,   0,  16,   0, 
-     26,   0,   0,   0, 134,   1, 
-     16,   0,  19,   0,   0,   0, 
-     70,   2,  16,   0,  25,   0, 
-      0,   0,  54,   0,   0,   5, 
-     82,   0,  16,   0,  27,   0, 
-      0,   0,   6,   1,  16,   0, 
-     25,   0,   0,   0,  54,   0, 
-      0,   5, 162,   0,  16,   0, 
-     27,   0,   0,   0,   6,   8, 
-     16,   0,  19,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,  27,   0,   0,   0, 
-      6,   5,  16,   0,  26,   0, 
-      0,   0,  70,  14,  16,   0, 
-     27,   0,   0,   0,  22,  11, 
-     16,   0,  27,   0,   0,   0, 
-     54,   0,   0,   5,  82,   0, 
-     16,   0,  19,   0,   0,   0, 
-    166,  11,  16,   0,  25,   0, 
-      0,   0,  55,   0,   0,   9, 
-     50,   0,  16,   0,  19,   0, 
-      0,   0, 166,  10,  16,   0, 
-     26,   0,   0,   0,  70,   0, 
-     16,   0,  19,   0,   0,   0, 
-     22,   5,  16,   0,  19,   0, 
-      0,   0,  79,   0,   0,   7, 
-     66,   0,  16,   0,  18,   0, 
-      0,   0,  58,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  25,   0,   0,   0, 
-     55,   0,   0,   9, 146,   0, 
-     16,   0,  25,   0,   0,   0, 
-    166,  10,  16,   0,  18,   0, 
-      0,   0, 246,  11,  16,   0, 
-     19,   0,   0,   0, 166,  14, 
-     16,   0,  19,   0,   0,   0, 
-     40,   0,   0,   5,  50,   0, 
-     16,   0,  26,   0,   0,   0, 
-    214,   5,  16,   0,  27,   0, 
-      0,   0,  40,   0,   0,   5, 
-     66,   0,  16,   0,  26,   0, 
-      0,   0,  26,   0,  16,   0, 
-     19,   0,   0,   0,  40,   0, 
-      0,   5, 130,   0,  16,   0, 
-     26,   0,   0,   0,  10,   0, 
-     16,   0,  25,   0,   0,   0, 
-     54,   0,   0,   5,  50,   0, 
-     16,   0,  25,   0,   0,   0, 
-    134,   0,  16,   0,  27,   0, 
-      0,   0,  54,   0,   0,   5, 
-     66,   0,  16,   0,  25,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  30,   0, 
-      0,   7, 242,   0,  16,   0, 
-     19,   0,   0,   0,  70,  14, 
-     16,   0,  26,   0,   0,   0, 
-     70,  14,  16,   0,  25,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0,  50,   0, 
-     16,   0,  19,   0,   0,   0, 
-     70,   0,  16,   0,  19,   0, 
-      0,   0,  70,   0,  16,   0, 
-     19,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-     18,   0,   0,   0,  26,   0, 
-     16,   0,  19,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  35,   0,   0,   9, 
-     66,   0,  16,   0,  18,   0, 
-      0,   0,  42,   0,  16,   0, 
-     19,   0,   0,   0,  42,   0, 
-     16,   0,  19,   0,   0,   0, 
-     42,   0,  16,   0,  18,   0, 
-      0,   0,  86,   0,   0,   5, 
-     66,   0,  16,   0,  18,   0, 
-      0,   0,  42,   0,  16,   0, 
-     18,   0,   0,   0,  86,   0, 
-      0,   5,  18,   0,  16,   0, 
-     19,   0,   0,   0,  58,   0, 
-     16,   0,  19,   0,   0,   0, 
-     56,   0,   0,   7,  18,   0, 
-     16,   0,  19,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  50,   0, 
-      0,  10,  66,   0,  16,   0, 
-     18,   0,   0,   0,  10,   0, 
-     16,   0,  19,   0,   0,   0, 
-     42, 128,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     42,   0,  16,   0,  18,   0, 
-      0,   0,  28,   0,   0,   5, 
-     66,   0,  16,   0,  18,   0, 
-      0,   0,  42,   0,  16,   0, 
-     18,   0,   0,   0,  54,   0, 
-      0,   6,  18,   0,  16,   0, 
-     19,   0,   0,   0,  10,  48, 
-     32,   0,   3,   0,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-     19,   0,   0,   0,  42,   0, 
-     16,   0,  18,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  55,   0,   0,   9, 
-     18,   0,  16,   0,  19,   0, 
-      0,   0,  58,   0,  16,   0, 
-     18,   0,   0,   0,  26,   0, 
-     16,   0,  19,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,  48,  32,   0,   3,   0, 
-      0,   0,   1,   0,   0,   0, 
-     10,   0,  16,   0,  19,   0, 
-      0,   0,  54,   0,   0,   6, 
-     18,   0,  16,   0,  19,   0, 
-      0,   0,  10,  48,  32,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,  18,   0, 
-      0,   0,  42,   0,  16,   0, 
-     18,   0,   0,   0,  10,   0, 
-     16,   0,  19,   0,   0,   0, 
-     55,   0,   0,   9,  66,   0, 
-     16,   0,  18,   0,   0,   0, 
-     58,   0,  16,   0,  18,   0, 
-      0,   0,  10,   0,  16,   0, 
-     19,   0,   0,   0,  42,   0, 
-     16,   0,  18,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,  18,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,  15,   0,   0,   0, 
-     58,   0,  16,   0,  15,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,  54,   0,   0,   6, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  10,  48,  32,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  10,  48,  32,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  79,   0,   0,   7, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     84,   0,   0,   7, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      7,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      6,   0,   0,   0,  10,  48, 
-     32,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,  55,   0, 
-      0,   9, 130,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   8,   0,   0,   0, 
-     10,   0,  16,   0,  18,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6,  18,  48,  32,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      6,   0,   0,   0,  10,  48, 
-     32,   0,   3,   0,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      7,   0,   0,   0,  10,  48, 
-     32,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,  79,   0, 
-      0,   7, 130,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   7,   0, 
-      0,   0,  84,   0,   0,   7, 
-    130,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     54,   0,   0,   6, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     10,  48,  32,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-     55,   0,   0,   9, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  10,   0,  16,   0, 
-     18,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     54,   0,   0,   6,  18,  48, 
-     32,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,  58,   0, 
-     16,   0,   6,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,  18,   0,   0,   0, 
-     10,   0,  16,   0,  18,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,  54,   0,   0,   6, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  10,  48,  32,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  54,   0,   0,   6, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,  48,  32,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58, 128,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   4,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  64,   2,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70,   2, 
-     16,   0,   2,   0,   0,   0, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  48,  32,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  54,   0, 
-      0,   6,  66,   0,  16,   0, 
-      0,   0,   0,   0,  10,  48, 
-     32,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,  18,   0,   0,   1, 
-     54,   0,   0,   6,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  48,  32,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-     41,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,  48, 
-     32,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,  60,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,  21,   0,   0,   1, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0, 190,  24,   0,   1, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-    167,   0,   0,   9, 226,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 249, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0, 134,   3, 
-     16,   0,   3,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-     10,   0,  16,   0,   4,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0, 167,   0, 
-      0,   9, 226,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 249,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  79,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   3,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0, 168,   0,   0,   8, 
-    114, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0, 134,   3,  16,   0, 
-      3,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   8,   0, 
-      0,   0, 167,   0,   0,   9, 
-    226,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 249,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  79,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-    134,   3,  16,   0,   3,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  10,   0,  16,   0, 
-      4,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  58,   0,  16,   0, 
-      1,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-    167,   0,   0,   9, 226,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 249, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8, 114, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0, 134,   3, 
-     16,   0,   2,   0,   0,   0, 
-    168,   0,   0,   8,  18, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  79,   0,   0,   9, 
-     98,   0,  16,   0,   0,   0, 
-      0,   0,   6,  64,   2,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9, 226,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 249,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  79,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0, 168,   0,   0,   8, 
-    114, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0, 134,   3,  16,   0, 
-      2,   0,   0,   0, 168,   0, 
-      0,   8,  18, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    226,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 249,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  32,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  79,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8, 114, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-    134,   3,  16,   0,   2,   0, 
-      0,   0, 168,   0,   0,   8, 
-     18, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  32,   0, 
-      0,   0,  10,   0,  16,   0, 
-      3,   0,   0,   0,  21,   0, 
-      0,   1, 167,   0,   0,   9, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-      6, 112,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   2,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  79,   0, 
-      0,   7,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    114,   0,  16,   0,   1,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  70, 242,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   8, 130,   0,  16,   0, 
-      1,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     18,   0,   0,   1, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 126,  16,   0, 
-      1,   0,   0,   0,  21,   0, 
-      0,   1, 168,   0,   0,   9, 
-    242, 224,  17,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70,  14,  16,   0,   1,   0, 
-      0,   0,  21,   0,   0,   1, 
-     62,   0,   0,   1
-};
diff --git a/thirdparty/directxtex/Shaders/Compiled/BC7Encode_TryMode456CS.inc b/thirdparty/directxtex/Shaders/Compiled/BC7Encode_TryMode456CS.inc
deleted file mode 100644
index ee016f1..0000000
--- a/thirdparty/directxtex/Shaders/Compiled/BC7Encode_TryMode456CS.inc
+++ /dev/null
@@ -1,3025 +0,0 @@
-#if 0
-//
-// Generated by Microsoft (R) D3D Shader Disassembler
-//
-//
-// Input signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Input
-//
-// Output signature:
-//
-// Name                 Index   Mask Register SysValue  Format   Used
-// -------------------- ----- ------ -------- -------- ------- ------
-// no Output
-cs_4_0
-dcl_globalFlags refactoringAllowed
-dcl_immediateConstantBuffer { { 0, 0, 0, 0},
-                              { 0, 4, 0, 0},
-                              { 0, 9, 0, 0},
-                              { 1, 13, 0, 0},
-                              { 1, 17, 0, 0},
-                              { 1, 21, 0, 0},
-                              { 1, 26, 0, 0},
-                              { 2, 30, 0, 0},
-                              { 2, 34, 0, 0},
-                              { 2, 38, 0, 0},
-                              { 2, 43, 0, 0},
-                              { 2, 47, 0, 0},
-                              { 3, 51, 0, 0},
-                              { 3, 55, 0, 0},
-                              { 3, 60, 0, 0},
-                              { 3, 64, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 9, 0, 0},
-                              { 4, 18, 0, 0},
-                              { 4, 27, 0, 0},
-                              { 5, 37, 0, 0},
-                              { 5, 46, 0, 0},
-                              { 5, 55, 0, 0},
-                              { 5, 64, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 8, 21, 0, 0},
-                              { 8, 43, 0, 0},
-                              { 8, 64, 0, 0},
-                              { 8, 0, 0, 0},
-                              { 9, 0, 0, 0},
-                              { 9, 0, 0, 0},
-                              { 9, 0, 0, 0},
-                              { 9, 0, 0, 0},
-                              { 10, 0, 0, 0},
-                              { 10, 0, 0, 0},
-                              { 10, 0, 0, 0},
-                              { 10, 0, 0, 0},
-                              { 10, 0, 0, 0},
-                              { 11, 0, 0, 0},
-                              { 11, 0, 0, 0},
-                              { 11, 0, 0, 0},
-                              { 11, 0, 0, 0},
-                              { 12, 0, 0, 0},
-                              { 12, 0, 0, 0},
-                              { 12, 0, 0, 0},
-                              { 12, 0, 0, 0},
-                              { 13, 0, 0, 0},
-                              { 13, 0, 0, 0},
-                              { 13, 0, 0, 0},
-                              { 13, 0, 0, 0},
-                              { 14, 0, 0, 0},
-                              { 14, 0, 0, 0},
-                              { 14, 0, 0, 0},
-                              { 14, 0, 0, 0},
-                              { 15, 0, 0, 0},
-                              { 15, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 4, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 5, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 6, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 7, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 0, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 1, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 2, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0},
-                              { 3, 0, 0, 0} }
-dcl_constantbuffer CB0[2], immediateIndexed
-dcl_resource_texture2d (float,float,float,float) t0
-dcl_uav_structured u0, 16
-dcl_input vThreadIDInGroupFlattened
-dcl_input vThreadGroupID.x
-dcl_temps 19
-dcl_tgsm_structured g0, 100, 64
-dcl_thread_group 64, 1, 1
-ushr r0.x, vThreadIDInGroupFlattened.x, l(4)
-ishl r0.y, vThreadGroupID.x, l(2)
-iadd r0.y, r0.y, cb0[1].x
-iadd r0.x, r0.x, r0.y
-and r0.y, vThreadIDInGroupFlattened.x, l(48)
-iadd r0.z, -r0.y, vThreadIDInGroupFlattened.x
-ult r1.xyzw, r0.zzzz, l(16, 8, 4, 2)
-if_nz r1.x
-  udiv r0.w, null, r0.x, cb0[0].y
-  imad r2.x, -r0.w, cb0[0].y, r0.x
-  ishl r2.x, r2.x, l(2)
-  ishl r0.w, r0.w, l(2)
-  and r2.y, r0.z, l(3)
-  iadd r2.x, r2.y, r2.x
-  ushr r3.x, r0.z, l(2)
-  iadd r2.y, r0.w, r3.x
-  mov r2.zw, l(0,0,0,0)
-  ld r2.xyzw, r2.xyzw, t0.xyzw
-  mul r2.xyzw, r2.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000)
-  ftou r2.xyzw, r2.xyzw
-  umin r2.xyzw, r2.xyzw, l(255, 255, 255, 255)
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(0), r2.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r2.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r2.xyzw
-endif 
-sync_g_t
-if_nz r1.y
-  ld_structured r2.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r3.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r4.xyzw, r0.w, l(36), g0.xyzw
-  ld_structured r5.xyzw, r0.w, l(52), g0.xyzw
-  umin r2.xyzw, r2.xyzw, r4.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r2.xyzw
-  umax r2.xyzw, r3.xyzw, r5.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r2.xyzw
-endif 
-sync_g_t
-if_nz r1.z
-  ld_structured r2.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r3.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r4.xyzw, r0.w, l(36), g0.xyzw
-  ld_structured r5.xyzw, r0.w, l(52), g0.xyzw
-  umin r2.xyzw, r2.xyzw, r4.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r2.xyzw
-  umax r2.xyzw, r3.xyzw, r5.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r2.xyzw
-endif 
-sync_g_t
-if_nz r1.w
-  ld_structured r2.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r3.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r4.xyzw, r0.w, l(36), g0.xyzw
-  ld_structured r5.xyzw, r0.w, l(52), g0.xyzw
-  umin r2.xyzw, r2.xyzw, r4.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r2.xyzw
-  umax r2.xyzw, r3.xyzw, r5.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r2.xyzw
-endif 
-sync_g_t
-ult r2.xy, r0.zzzz, l(1, 12, 0, 0)
-if_nz r2.x
-  ld_structured r3.xyzw, vThreadIDInGroupFlattened.x, l(36), g0.xyzw
-  ld_structured r4.xyzw, vThreadIDInGroupFlattened.x, l(52), g0.xyzw
-  iadd r0.w, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r5.xyzw, r0.w, l(36), g0.xyzw
-  ld_structured r6.xyzw, r0.w, l(52), g0.xyzw
-  umin r3.xyzw, r3.xyzw, r5.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(36), r3.xyzw
-  umax r3.xyzw, r4.xyzw, r6.xyzw
-  store_structured g0.xyzw, vThreadIDInGroupFlattened.x, l(52), r3.xyzw
-endif 
-sync_g_t
-ld_structured r3.xyzw, r0.y, l(0), g0.xyzw
-ld_structured r4.xyzw, r0.y, l(36), g0.xyzw
-ld_structured r5.xyzw, r0.y, l(52), g0.xyzw
-and r0.w, r0.z, l(1)
-movc r6.xyz, r0.wwww, l(1,1,2,0), l(0,2,1,0)
-movc r6.xyz, r1.yyyy, r6.xyzx, l(0,2,2,0)
-if_nz r2.y
-  ieq r7.xyzw, r0.zzzz, l(8, 9, 10, 11)
-  ult r0.w, r0.z, l(6)
-  or r0.w, r7.z, r0.w
-  or r2.yzw, r1.wwzy, r7.xxyw
-  mov r7.y, r4.z
-  mov r7.w, r5.z
-  mov r7.x, l(3)
-  mov r8.x, r4.w
-  mov r8.y, r5.w
-  mov r8.z, l(0)
-  movc r9.xyz, r2.wwww, r7.ywxy, r8.xyzx
-  movc r10.yw, r2.wwww, r8.xxxy, r7.yyyw
-  mov r11.x, r4.y
-  mov r11.y, r5.y
-  mov r11.z, l(2)
-  movc r9.xyz, r0.wwww, r11.xyzx, r9.xyzx
-  mov r7.xz, r8.xxyx
-  mov r10.xz, r11.xxyx
-  movc r7.xyzw, r0.wwww, r7.xzwy, r10.xzwy
-  mov r10.x, r4.x
-  mov r10.yz, r7.xxwx
-  movc r11.xyz, r2.zzzz, r4.wyzw, r10.xyzx
-  mov r10.y, r5.x
-  mov r10.z, l(1)
-  movc r9.xyz, r2.zzzz, r10.xyzx, r9.xyzx
-  mov r7.x, r10.y
-  movc r7.xyz, r2.zzzz, r5.wyzw, r7.xyzx
-  movc r10.xyz, r2.yyyy, r4.xyzx, r11.xyzx
-  movc r7.xyz, r2.yyyy, r5.xyzx, r7.xyzx
-  movc r2.yzw, r2.yyyy, r8.xxyz, r9.xxyz
-  if_nz r1.y
-    imad r8.xyz, r10.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-    ushr r8.xyz, r8.xyzx, l(16)
-    imad r9.xy, r2.yzyy, l(0x00003f3f, 0x00003f3f, 0, 0), l(0x00008000, 0x00008000, 0, 0)
-    ushr r9.xy, r9.xyxx, l(16)
-    ishl r8.xyz, r8.xyzx, l(3)
-    ushr r11.xyz, r8.xyzx, l(5)
-    or r8.xyz, r8.xyzx, r11.xyzx
-    ishl r9.xy, r9.xyxx, l(2)
-    ushr r9.zw, r9.xxxy, l(6)
-    imad r11.xyz, r7.xyzx, l(7967, 7967, 7967, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-    ushr r11.xyz, r11.xyzx, l(16)
-    ishl r11.xyz, r11.xyzx, l(3)
-    ushr r12.xyz, r11.xyzx, l(5)
-    or r11.xyz, r11.xyzx, r12.xyzx
-    or r9.xy, r9.zwzz, r9.xyxx
-    mov r11.w, r9.y
-    mov r12.y, l(4)
-  else 
-    imad r10.xyz, r10.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-    ushr r10.xyz, r10.xyzx, l(16)
-    ishl r10.xyz, r10.xyzx, l(1)
-    ushr r13.xyz, r10.xyzx, l(7)
-    or r8.xyz, r10.xyzx, r13.xyzx
-    imad r7.xyz, r7.xyzx, l(0x00007f7f, 0x00007f7f, 0x00007f7f, 0), l(0x00008000, 0x00008000, 0x00008000, 0)
-    ushr r7.xyz, r7.xyzx, l(16)
-    ishl r7.xyz, r7.xyzx, l(1)
-    ushr r10.xyz, r7.xyzx, l(7)
-    or r11.xyz, r7.xyzx, r10.xyzx
-    mov r9.x, r2.y
-    mov r11.w, r2.z
-    mov r12.y, l(5)
-  endif 
-  ieq r7.xyz, r2.wwww, l(1, 2, 3, 0)
-  movc r10.zw, r7.zzzz, r3.wwwz, r3.zzzw
-  mov r10.xy, r3.xyxx
-  movc r10.yzw, r7.yyyy, r3.wwzy, r10.yyzw
-  movc r10.xyzw, r7.xxxx, r3.wyzx, r10.xyzw
-  ineg r13.xyz, r8.xyzx
-  ineg r13.w, r9.x
-  iadd r14.xyzw, r11.xyzw, r13.xyzw
-  imul null, r15.xyz, r14.xywx, r14.xywx
-  iadd r0.w, r15.y, r15.x
-  imad r0.w, r14.z, r14.z, r0.w
-  iadd r13.xyzw, r10.xyzw, r13.xyzw
-  imul null, r13.xyw, r13.xyxw, r13.xyxw
-  iadd r2.y, r13.y, r13.x
-  imad r2.y, r13.z, r13.z, r2.y
-  iadd r10.xyzw, -r11.xyzw, r10.xyzw
-  imul null, r10.xyw, r10.xyxw, r10.xyxw
-  iadd r2.z, r10.y, r10.x
-  imad r2.z, r10.z, r10.z, r2.z
-  ilt r2.y, r2.z, r2.y
-  ineg r16.xyzw, r14.xyzw
-  movc r10.xyz, r2.yyyy, r11.xyzx, r8.xyzx
-  movc r8.xyz, r2.yyyy, r8.xyzx, r11.xyzx
-  movc r11.xyz, r2.yyyy, r16.xyzx, r14.xyzx
-  ilt r2.y, r10.w, r13.w
-  mov r9.y, r11.w
-  mov r9.z, r16.w
-  mov r9.w, r14.w
-  movc r9.xyz, r2.yyyy, r9.yxzy, r9.xywx
-  ige r2.y, l(0), r0.w
-  itof r2.z, r0.w
-  ishl r12.zw, r6.yyyz, l(6)
-  ishl r6.yz, r6.yyzy, l(4)
-  iadd r13.xy, r12.zwzz, l(11, 11, 0, 0)
-  ige r7.w, l(0), r15.z
-  itof r8.w, r15.z
-  udiv null, r13.xy, r13.xyxx, l(68, 68, 0, 0)
-  mov r13.zw, l(0,0,0,0)
-  loop 
-    uge r9.w, r13.w, l(16)
-    breakc_nz r9.w
-    iadd r9.w, r0.y, r13.w
-    ld_structured r14.xyzw, r9.w, l(0), g0.xyzw
-    movc r16.zw, r7.zzzz, r14.wwwz, r14.zzzw
-    mov r16.xy, r14.xyxx
-    movc r16.yzw, r7.yyyy, r14.wwzy, r16.yyzw
-    movc r14.xyzw, r7.xxxx, r14.wyzx, r16.xyzw
-    iadd r15.xyw, -r10.xyxz, r14.xyxz
-    imul null, r15.xy, r11.xyxx, r15.xyxx
-    iadd r9.w, r15.y, r15.x
-    imad r9.w, r11.z, r15.w, r9.w
-    ige r10.w, l(0), r9.w
-    or r10.w, r2.y, r10.w
-    ilt r11.w, r9.w, r0.w
-    itof r9.w, r9.w
-    mul r9.w, r9.w, l(63.499989)
-    div r9.w, r9.w, r2.z
-    ftou r9.w, r9.w
-    iadd r9.w, r9.w, r12.z
-    movc r9.w, r11.w, icb[r9.w + 0].x, r13.x
-    movc r9.w, r10.w, l(0), r9.w
-    iadd r10.w, -r9.x, r14.w
-    imul null, r10.w, r9.z, r10.w
-    ige r11.w, l(0), r10.w
-    or r11.w, r7.w, r11.w
-    ilt r15.x, r10.w, r15.z
-    itof r10.w, r10.w
-    mul r10.w, r10.w, l(63.499989)
-    div r10.w, r10.w, r8.w
-    ftou r10.w, r10.w
-    iadd r10.w, r10.w, r12.w
-    movc r10.w, r15.x, icb[r10.w + 0].x, r13.y
-    movc r10.w, r11.w, l(0), r10.w
-    iadd r9.w, r6.y, r9.w
-    iadd r11.w, l(64), -icb[r9.w + 0].y
-    imul null, r15.xyw, r8.xyxz, icb[r9.w + 0].yyyy
-    imad r15.xyw, r11.wwww, r10.xyxz, r15.xyxw
-    iadd r15.xyw, r15.xyxw, l(32, 32, 0, 32)
-    ushr r16.xyw, r15.xyxw, l(6)
-    iadd r9.w, r6.z, r10.w
-    iadd r10.w, l(64), -icb[r9.w + 0].y
-    imul null, r9.w, r9.y, icb[r9.w + 0].y
-    imad r9.w, r10.w, r9.x, r9.w
-    iadd r9.w, r9.w, l(32)
-    ushr r15.y, r9.w, l(6)
-    ult r17.xyz, r16.xywx, r14.xyzx
-    mov r16.z, r14.x
-    movc r17.xw, r17.xxxx, r16.zzzx, r16.xxxz
-    mov r16.xz, r14.yyzy
-    movc r16.xyzw, r17.yyzz, r16.xyzw, r16.yxwz
-    ult r9.w, r15.y, r14.w
-    mov r15.x, r14.w
-    movc r14.xy, r9.wwww, r15.xyxx, r15.yxyy
-    ineg r18.w, r17.w
-    ineg r18.yz, r16.yywy
-    ineg r18.x, r14.y
-    mov r14.w, r17.x
-    mov r14.yz, r16.xxzx
-    iadd r14.xyzw, r18.xyzw, r14.xyzw
-    movc r16.zw, r7.zzzz, r14.xxxz, r14.zzzx
-    mov r16.xy, r14.wyww
-    movc r16.yzw, r7.yyyy, r14.xxzy, r16.yyzw
-    movc r14.xyzw, r7.xxxx, r14.xyzw, r16.xyzw
-    imul null, r14.xy, r14.xyxx, r14.xyxx
-    iadd r9.w, r14.y, r14.x
-    imad r9.w, r14.z, r14.z, r9.w
-    utof r9.w, r9.w
-    utof r10.w, r14.w
-    mul r10.w, r10.w, r10.w
-    mad r9.w, r10.w, cb0[1].z, r9.w
-    ftou r9.w, r9.w
-    iadd r13.z, r9.w, r13.z
-    iadd r13.w, r13.w, l(1)
-  endloop 
-  mov r12.x, r13.z
-  mov r6.w, r2.w
-else 
-  if_nz r1.x
-    iadd r7.x, r0.z, l(-12)
-    ushr r7.y, r7.x, l(1)
-    and r0.zw, r7.xxxy, l(0, 0, 1, 1)
-    and r4.xyzw, r4.xyzw, l(-2, -2, -2, -2)
-    iadd r4.xyzw, r0.zzzz, r4.xyzw
-    and r5.xyzw, r5.xyzw, l(-2, -2, -2, -2)
-    iadd r5.xyzw, r0.wwww, r5.xyzw
-    iadd r8.xyzw, -r4.xyzw, r5.xyzw
-    imul null, r0.zw, r8.xxxy, r8.xxxy
-    iadd r0.z, r0.w, r0.z
-    imad r0.z, r8.z, r8.z, r0.z
-    imad r0.z, r8.w, r8.w, r0.z
-    iadd r3.xyzw, r3.xyzw, -r4.xyzw
-    imul null, r2.yz, r3.xxyx, r8.xxyx
-    iadd r0.w, r2.z, r2.y
-    imad r0.w, r8.z, r3.z, r0.w
-    imad r0.w, r8.w, r3.w, r0.w
-    ilt r1.x, l(0), r0.z
-    ige r2.y, r0.w, l(0)
-    and r1.x, r1.x, r2.y
-    itof r0.w, r0.w
-    mul r0.w, r0.w, l(63.499989)
-    ftou r0.w, r0.w
-    ishl r2.y, r0.z, l(5)
-    ult r0.w, r2.y, r0.w
-    and r0.w, r0.w, r1.x
-    ineg r3.xyzw, r8.xyzw
-    movc r9.xyzw, r0.wwww, r5.xyzw, r4.xyzw
-    movc r4.xyzw, r0.wwww, r4.xyzw, r5.xyzw
-    movc r3.xyzw, r0.wwww, r3.xyzw, r8.xyzw
-    ige r0.w, l(0), r0.z
-    itof r1.x, r0.z
-    mov r12.xy, l(0,0,0,0)
-    loop 
-      uge r2.y, r12.y, l(16)
-      breakc_nz r2.y
-      iadd r2.y, r0.y, r12.y
-      ld_structured r5.xyzw, r2.y, l(0), g0.xyzw
-      iadd r8.xyzw, -r9.xyzw, r5.xyzw
-      imul null, r2.yz, r3.xxyx, r8.xxyx
-      iadd r2.y, r2.z, r2.y
-      imad r2.y, r3.z, r8.z, r2.y
-      imad r2.y, r3.w, r8.w, r2.y
-      ige r2.z, l(0), r2.y
-      or r2.z, r0.w, r2.z
-      ilt r2.w, r2.y, r0.z
-      itof r2.y, r2.y
-      mul r2.y, r2.y, l(63.499989)
-      div r2.y, r2.y, r1.x
-      ftou r2.y, r2.y
-      movc r2.y, r2.w, icb[r2.y + 0].x, l(15)
-      movc r2.y, r2.z, l(0), r2.y
-      iadd r2.z, l(64), -icb[r2.y + 0].y
-      imul null, r8.xyzw, r4.xyzw, icb[r2.y + 0].yyyy
-      imad r8.xyzw, r2.zzzz, r9.xyzw, r8.xyzw
-      iadd r8.xyzw, r8.xyzw, l(32, 32, 32, 32)
-      ushr r8.xyzw, r8.xzyw, l(6)
-      ult r10.xyzw, r8.xzyw, r5.xyzw
-      mov r11.xz, r5.xxyx
-      mov r11.yw, r8.xxxz
-      movc r11.xyzw, r10.xxyy, r11.xyzw, r11.yxwz
-      mov r8.xz, r5.zzwz
-      movc r5.xyzw, r10.zwzw, r8.ywxz, r8.xzyw
-      ineg r8.xy, r11.ywyy
-      ineg r8.zw, r5.xxxy
-      mov r5.xy, r11.xzxx
-      iadd r5.xyzw, r8.xyzw, r5.xyzw
-      imul null, r2.yz, r5.xxyx, r5.xxyx
-      iadd r2.y, r2.z, r2.y
-      imad r2.y, r5.z, r5.z, r2.y
-      utof r2.y, r2.y
-      utof r2.z, r5.w
-      mul r2.z, r2.z, r2.z
-      mad r2.y, r2.z, cb0[1].z, r2.y
-      ftou r2.y, r2.y
-      iadd r12.x, r2.y, r12.x
-      iadd r12.y, r12.y, l(1)
-    endloop 
-    mov r12.y, l(6)
-    mov r6.w, r7.x
-  else 
-    mov r12.xy, l(-1,0,0,0)
-    mov r6.w, l(0)
-  endif 
-endif 
-store_structured g0.xy, vThreadIDInGroupFlattened.x, l(16), r12.xyxx
-store_structured g0.xy, vThreadIDInGroupFlattened.x, l(28), r6.xwxx
-sync_g_t
-if_nz r1.y
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(8)
-  ld_structured r3.yz, r0.y, l(16), g0.xxyx
-  ld_structured r4.xy, r0.y, l(28), g0.xyxx
-  ult r0.z, r3.y, r12.x
-  if_nz r0.z
-    ld_structured r3.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(16), r3.xzxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(28), r4.xyxx
-  endif 
-endif 
-sync_g_t
-if_nz r1.z
-  ld_structured r3.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(4)
-  ld_structured r4.yz, r0.y, l(16), g0.xxyx
-  ld_structured r5.xy, r0.y, l(28), g0.xyxx
-  ult r0.z, r4.y, r3.x
-  if_nz r0.z
-    ld_structured r4.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(16), r4.xzxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(28), r5.xyxx
-  endif 
-endif 
-sync_g_t
-if_nz r1.w
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(2)
-  ld_structured r3.yz, r0.y, l(16), g0.xxyx
-  ld_structured r4.xy, r0.y, l(28), g0.xyxx
-  ult r0.z, r3.y, r1.x
-  if_nz r0.z
-    ld_structured r3.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(16), r3.xzxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(28), r4.xyxx
-  endif 
-endif 
-sync_g_t
-if_nz r2.x
-  ld_structured r1.x, vThreadIDInGroupFlattened.x, l(16), g0.xxxx
-  iadd r0.y, vThreadIDInGroupFlattened.x, l(1)
-  ld_structured r2.yz, r0.y, l(16), g0.xxyx
-  ld_structured r3.xy, r0.y, l(28), g0.xyxx
-  ult r0.z, r2.y, r1.x
-  if_nz r0.z
-    ld_structured r2.x, r0.y, l(16), g0.xxxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(16), r2.xzxx
-    store_structured g0.xy, vThreadIDInGroupFlattened.x, l(28), r3.xyxx
-  endif 
-  ld_structured r1.xw, vThreadIDInGroupFlattened.x, l(28), g0.xxxy
-  ishl r0.y, r1.x, l(31)
-  ld_structured r1.xy, vThreadIDInGroupFlattened.x, l(16), g0.xyxx
-  or r1.y, r0.y, r1.y
-  mov r1.z, l(0)
-  store_structured u0.xyzw, r0.x, l(0), r1.xyzw
-endif 
-ret 
-// Approximately 0 instruction slots used
-#endif
-
-const BYTE BC7Encode_TryMode456CS[] =
-{
-     68,  88,  66,  67, 147, 174, 
-    199, 189,  42,   5, 183, 145, 
-    202, 210, 163, 191, 100,  29, 
-      3, 141,   1,   0,   0,   0, 
-     20,  56,   0,   0,   3,   0, 
-      0,   0,  44,   0,   0,   0, 
-     60,   0,   0,   0,  76,   0, 
-      0,   0,  73,  83,  71,  78, 
-      8,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     79,  83,  71,  78,   8,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  83,  72, 
-     69,  88, 192,  55,   0,   0, 
-     64,   0,   5,   0, 240,  13, 
-      0,   0, 106,   8,   0,   1, 
-     53,  24,   0,   0,   2,   3, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     13,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  17,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,  21,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     26,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  34,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     38,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,  43,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,  47,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     51,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,  60,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-     64,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   9,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     18,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  27,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  37,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     46,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  55,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,  64,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-     21,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      8,   0,   0,   0,  43,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   8,   0, 
-      0,   0,  64,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      9,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   9,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   9,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      9,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     10,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  10,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     11,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  11,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  11,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     11,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  12,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     12,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  13,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  13,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  13,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  14,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  14,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     14,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  15,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  15,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   5,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  89,   0,   0,   4, 
-     70, 142,  32,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-     88,  24,   0,   4,   0, 112, 
-     16,   0,   0,   0,   0,   0, 
-     85,  85,   0,   0, 158,   0, 
-      0,   4,   0, 224,  17,   0, 
-      0,   0,   0,   0,  16,   0, 
-      0,   0,  95,   0,   0,   2, 
-      0,  64,   2,   0,  95,   0, 
-      0,   2,  18,  16,   2,   0, 
-    104,   0,   0,   2,  19,   0, 
-      0,   0, 160,   0,   0,   5, 
-      0, 240,  17,   0,   0,   0, 
-      0,   0, 100,   0,   0,   0, 
-     64,   0,   0,   0, 155,   0, 
-      0,   4,  64,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   6, 
-     18,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   4,   0, 
-      0,   0,  41,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  16,   2,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  30,   0,   0,   8, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  10, 128, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  30,   0, 
-      0,   7,  18,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  48,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16, 128, 
-     65,   0,   0,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-     79,   0,   0,  10, 242,   0, 
-     16,   0,   1,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-     16,   0,   0,   0,   8,   0, 
-      0,   0,   4,   0,   0,   0, 
-      2,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      1,   0,   0,   0,  78,   0, 
-      0,   9, 130,   0,  16,   0, 
-      0,   0,   0,   0,   0, 208, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,  26, 128, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  35,   0, 
-      0,  11,  18,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16, 128,  65,   0,   0,   0, 
-      0,   0,   0,   0,  26, 128, 
-     32,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   0,   0,   0,   0, 
-     41,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0,  41,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      2,   0,   0,   0,  85,   0, 
-      0,   7,  18,   0,  16,   0, 
-      3,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  10,   0, 
-     16,   0,   3,   0,   0,   0, 
-     54,   0,   0,   8, 194,   0, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  45,   0,   0,   7, 
-    242,   0,  16,   0,   2,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  70, 126, 
-     16,   0,   0,   0,   0,   0, 
-     56,   0,   0,  10, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0,   0, 127,  67,   0,   0, 
-    127,  67,   0,   0, 127,  67, 
-      0,   0, 127,  67,  28,   0, 
-      0,   5, 242,   0,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-     84,   0,   0,  10, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-    255,   0,   0,   0, 255,   0, 
-      0,   0, 255,   0,   0,   0, 
-    255,   0,   0,   0, 168,   0, 
-      0,   8, 242, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70,  14,  16,   0,   2,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      8,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  83,   0, 
-      0,   7, 242,   0,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  83,   0, 
-      0,   7, 242,   0,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   8, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6, 130,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      4,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      5,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,  84,   0, 
-      0,   7, 242,   0,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   2,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  83,   0, 
-      0,   7, 242,   0,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0, 168,   0,   0,   8, 
-    242, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70,  14,  16,   0, 
-      2,   0,   0,   0,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     79,   0,   0,  10,  50,   0, 
-     16,   0,   2,   0,   0,   0, 
-    166,  10,  16,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      1,   0,   0,   0,  12,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   8, 242,   0,  16,   0, 
-      3,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     36,   0,   0,   0,  70, 254, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   8, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   6,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  84,   0,   0,   7, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  36,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,  83,   0,   0,   7, 
-    242,   0,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0,  70,  14, 
-     16,   0,   6,   0,   0,   0, 
-    168,   0,   0,   8, 242, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  52,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-    190,  24,   0,   1, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  36,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9, 242,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  52,   0, 
-      0,   0,  70, 254,  17,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,  55,   0,   0,  15, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0, 246,  15,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,  12, 
-    114,   0,  16,   0,   6,   0, 
-      0,   0,  86,   5,  16,   0, 
-      1,   0,   0,   0,  70,   2, 
-     16,   0,   6,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  32,   0,   0,  10, 
-    242,   0,  16,   0,   7,   0, 
-      0,   0, 166,  10,  16,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   8,   0,   0,   0, 
-      9,   0,   0,   0,  10,   0, 
-      0,   0,  11,   0,   0,   0, 
-     79,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-    226,   0,  16,   0,   2,   0, 
-      0,   0, 246,   6,  16,   0, 
-      1,   0,   0,   0,   6,  13, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   5,  34,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   7,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   3,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,   8,   0,   0,   0, 
-     58,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   5, 
-     34,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-    246,  15,  16,   0,   2,   0, 
-      0,   0, 214,   4,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     55,   0,   0,   9, 162,   0, 
-     16,   0,  10,   0,   0,   0, 
-    246,  15,  16,   0,   2,   0, 
-      0,   0,   6,   4,  16,   0, 
-      8,   0,   0,   0,  86,  13, 
-     16,   0,   7,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,  11,   0,   0,   0, 
-     26,   0,  16,   0,   4,   0, 
-      0,   0,  54,   0,   0,   5, 
-     34,   0,  16,   0,  11,   0, 
-      0,   0,  26,   0,  16,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,   2,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     54,   0,   0,   5,  82,   0, 
-     16,   0,   7,   0,   0,   0, 
-      6,   1,  16,   0,   8,   0, 
-      0,   0,  54,   0,   0,   5, 
-     82,   0,  16,   0,  10,   0, 
-      0,   0,   6,   1,  16,   0, 
-     11,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-      7,   0,   0,   0, 246,  15, 
-     16,   0,   0,   0,   0,   0, 
-    134,   7,  16,   0,   7,   0, 
-      0,   0, 134,   7,  16,   0, 
-     10,   0,   0,   0,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-     10,   0,   0,   0,  10,   0, 
-     16,   0,   4,   0,   0,   0, 
-     54,   0,   0,   5,  98,   0, 
-     16,   0,  10,   0,   0,   0, 
-      6,   3,  16,   0,   7,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0, 166,  10,  16,   0, 
-      2,   0,   0,   0, 118,  14, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,  10,   0, 
-      0,   0,  54,   0,   0,   5, 
-     34,   0,  16,   0,  10,   0, 
-      0,   0,  10,   0,  16,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   5,  66,   0,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   9,   0,   0,   0, 
-    166,  10,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,   9,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     26,   0,  16,   0,  10,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0, 166,  10,  16,   0, 
-      2,   0,   0,   0, 118,  14, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0,  86,   5,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   4,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  55,   0,   0,   9, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  86,   5,  16,   0, 
-      2,   0,   0,   0,  70,   2, 
-     16,   0,   5,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,  55,   0,   0,   9, 
-    226,   0,  16,   0,   2,   0, 
-      0,   0,  86,   5,  16,   0, 
-      2,   0,   0,   0,   6,   9, 
-     16,   0,   8,   0,   0,   0, 
-      6,   9,  16,   0,   9,   0, 
-      0,   0,  31,   0,   4,   3, 
-     26,   0,  16,   0,   1,   0, 
-      0,   0,  35,   0,   0,  15, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,   2,  64, 
-      0,   0,  31,  31,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     35,   0,   0,  15,  50,   0, 
-     16,   0,   9,   0,   0,   0, 
-    150,   5,  16,   0,   2,   0, 
-      0,   0,   2,  64,   0,   0, 
-     63,  63,   0,   0,  63,  63, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7,  50,   0, 
-     16,   0,   9,   0,   0,   0, 
-     70,   0,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,   2,  16,   0,   8,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  41,   0, 
-      0,   7,  50,   0,  16,   0, 
-      9,   0,   0,   0,  70,   0, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0,  85,   0,   0,   7, 
-    194,   0,  16,   0,   9,   0, 
-      0,   0,   6,   4,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   6,   0,   0,   0, 
-     35,   0,   0,  15, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,   2,  64,   0,   0, 
-     31,  31,   0,   0,  31,  31, 
-      0,   0,  31,  31,   0,   0, 
-      0,   0,   0,   0,   2,  64, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  41,   0, 
-      0,   7, 114,   0,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,   3,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,  12,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     60,   0,   0,   7, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   2,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-     12,   0,   0,   0,  60,   0, 
-      0,   7,  50,   0,  16,   0, 
-      9,   0,   0,   0, 230,  10, 
-     16,   0,   9,   0,   0,   0, 
-     70,   0,  16,   0,   9,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,  11,   0, 
-      0,   0,  26,   0,  16,   0, 
-      9,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-     12,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     18,   0,   0,   1,  35,   0, 
-      0,  15, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-      2,  64,   0,   0, 127, 127, 
-      0,   0, 127, 127,   0,   0, 
-    127, 127,   0,   0,   0,   0, 
-      0,   0,   2,  64,   0,   0, 
-      0, 128,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,  41,   0,   0,   7, 
-    114,   0,  16,   0,  10,   0, 
-      0,   0,  70,   2,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   7, 114,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,   2,  16,   0,  10,   0, 
-      0,   0,   1,  64,   0,   0, 
-      7,   0,   0,   0,  60,   0, 
-      0,   7, 114,   0,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-     70,   2,  16,   0,  13,   0, 
-      0,   0,  35,   0,   0,  15, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0, 127, 127,   0,   0, 
-    127, 127,   0,   0, 127, 127, 
-      0,   0,   0,   0,   0,   0, 
-      2,  64,   0,   0,   0, 128, 
-      0,   0,   0, 128,   0,   0, 
-      0, 128,   0,   0,   0,   0, 
-      0,   0,  85,   0,   0,   7, 
-    114,   0,  16,   0,   7,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     41,   0,   0,   7, 114,   0, 
-     16,   0,   7,   0,   0,   0, 
-     70,   2,  16,   0,   7,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  85,   0, 
-      0,   7, 114,   0,  16,   0, 
-     10,   0,   0,   0,  70,   2, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   7,   0, 
-      0,   0,  60,   0,   0,   7, 
-    114,   0,  16,   0,  11,   0, 
-      0,   0,  70,   2,  16,   0, 
-      7,   0,   0,   0,  70,   2, 
-     16,   0,  10,   0,   0,   0, 
-     54,   0,   0,   5,  18,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,  11,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-     12,   0,   0,   0,   1,  64, 
-      0,   0,   5,   0,   0,   0, 
-     21,   0,   0,   1,  32,   0, 
-      0,  10, 114,   0,  16,   0, 
-      7,   0,   0,   0, 246,  15, 
-     16,   0,   2,   0,   0,   0, 
-      2,  64,   0,   0,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-      3,   0,   0,   0,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-    194,   0,  16,   0,  10,   0, 
-      0,   0, 166,  10,  16,   0, 
-      7,   0,   0,   0, 246,  11, 
-     16,   0,   3,   0,   0,   0, 
-    166,  14,  16,   0,   3,   0, 
-      0,   0,  54,   0,   0,   5, 
-     50,   0,  16,   0,  10,   0, 
-      0,   0,  70,   0,  16,   0, 
-      3,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-     10,   0,   0,   0,  86,   5, 
-     16,   0,   7,   0,   0,   0, 
-    246,   6,  16,   0,   3,   0, 
-      0,   0,  86,  14,  16,   0, 
-     10,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-     10,   0,   0,   0,   6,   0, 
-     16,   0,   7,   0,   0,   0, 
-    118,   2,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16,   0, 
-     10,   0,   0,   0,  40,   0, 
-      0,   5, 114,   0,  16,   0, 
-     13,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     40,   0,   0,   5, 130,   0, 
-     16,   0,  13,   0,   0,   0, 
-     10,   0,  16,   0,   9,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,  14,   0, 
-      0,   0,  70,  14,  16,   0, 
-     11,   0,   0,   0,  70,  14, 
-     16,   0,  13,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0, 114,   0,  16,   0, 
-     15,   0,   0,   0,  70,   3, 
-     16,   0,  14,   0,   0,   0, 
-     70,   3,  16,   0,  14,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-     15,   0,   0,   0,  10,   0, 
-     16,   0,  15,   0,   0,   0, 
-     35,   0,   0,   9, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,  14,   0, 
-      0,   0,  42,   0,  16,   0, 
-     14,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,  13,   0,   0,   0, 
-     70,  14,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     13,   0,   0,   0,  38,   0, 
-      0,   8,   0, 208,   0,   0, 
-    178,   0,  16,   0,  13,   0, 
-      0,   0,  70,  12,  16,   0, 
-     13,   0,   0,   0,  70,  12, 
-     16,   0,  13,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,  13,   0, 
-      0,   0,  10,   0,  16,   0, 
-     13,   0,   0,   0,  35,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,  13,   0,   0,   0, 
-     42,   0,  16,   0,  13,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   8, 242,   0,  16,   0, 
-     10,   0,   0,   0,  70,  14, 
-     16, 128,  65,   0,   0,   0, 
-     11,   0,   0,   0,  70,  14, 
-     16,   0,  10,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0, 178,   0,  16,   0, 
-     10,   0,   0,   0,  70,  12, 
-     16,   0,  10,   0,   0,   0, 
-     70,  12,  16,   0,  10,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-     10,   0,   0,   0,  10,   0, 
-     16,   0,  10,   0,   0,   0, 
-     35,   0,   0,   9,  66,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     34,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  40,   0, 
-      0,   5, 242,   0,  16,   0, 
-     16,   0,   0,   0,  70,  14, 
-     16,   0,  14,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  10,   0,   0,   0, 
-     86,   5,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-     11,   0,   0,   0,  70,   2, 
-     16,   0,   8,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,   8,   0,   0,   0, 
-     86,   5,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-      8,   0,   0,   0,  70,   2, 
-     16,   0,  11,   0,   0,   0, 
-     55,   0,   0,   9, 114,   0, 
-     16,   0,  11,   0,   0,   0, 
-     86,   5,  16,   0,   2,   0, 
-      0,   0,  70,   2,  16,   0, 
-     16,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     34,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-     13,   0,   0,   0,  54,   0, 
-      0,   5,  34,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,  11,   0,   0,   0, 
-     54,   0,   0,   5,  66,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,  16,   0, 
-      0,   0,  54,   0,   0,   5, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 114,   0,  16,   0, 
-      9,   0,   0,   0,  86,   5, 
-     16,   0,   2,   0,   0,   0, 
-     22,   6,  16,   0,   9,   0, 
-      0,   0,  70,   3,  16,   0, 
-      9,   0,   0,   0,  33,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  43,   0,   0,   5, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7, 194,   0,  16,   0, 
-     12,   0,   0,   0,  86,   9, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  41,   0,   0,   7, 
-     98,   0,  16,   0,   6,   0, 
-      0,   0,  86,   6,  16,   0, 
-      6,   0,   0,   0,   1,  64, 
-      0,   0,   4,   0,   0,   0, 
-     30,   0,   0,  10,  50,   0, 
-     16,   0,  13,   0,   0,   0, 
-    230,  10,  16,   0,  12,   0, 
-      0,   0,   2,  64,   0,   0, 
-     11,   0,   0,   0,  11,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  33,   0, 
-      0,   7, 130,   0,  16,   0, 
-      7,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,  15,   0, 
-      0,   0,  43,   0,   0,   5, 
-    130,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-     15,   0,   0,   0,  78,   0, 
-      0,  11,   0, 208,   0,   0, 
-     50,   0,  16,   0,  13,   0, 
-      0,   0,  70,   0,  16,   0, 
-     13,   0,   0,   0,   2,  64, 
-      0,   0,  68,   0,   0,   0, 
-     68,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   8, 194,   0, 
-     16,   0,  13,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  48,   0,   0,   1, 
-     80,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   3,   0, 
-      4,   3,  58,   0,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  13,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,  14,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  55,   0,   0,   9, 
-    194,   0,  16,   0,  16,   0, 
-      0,   0, 166,  10,  16,   0, 
-      7,   0,   0,   0, 246,  11, 
-     16,   0,  14,   0,   0,   0, 
-    166,  14,  16,   0,  14,   0, 
-      0,   0,  54,   0,   0,   5, 
-     50,   0,  16,   0,  16,   0, 
-      0,   0,  70,   0,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 226,   0,  16,   0, 
-     16,   0,   0,   0,  86,   5, 
-     16,   0,   7,   0,   0,   0, 
-    246,   6,  16,   0,  14,   0, 
-      0,   0,  86,  14,  16,   0, 
-     16,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-     14,   0,   0,   0,   6,   0, 
-     16,   0,   7,   0,   0,   0, 
-    118,   2,  16,   0,  14,   0, 
-      0,   0,  70,  14,  16,   0, 
-     16,   0,   0,   0,  30,   0, 
-      0,   8, 178,   0,  16,   0, 
-     15,   0,   0,   0,  70,   8, 
-     16, 128,  65,   0,   0,   0, 
-     10,   0,   0,   0,  70,   8, 
-     16,   0,  14,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0,  50,   0,  16,   0, 
-     15,   0,   0,   0,  70,   0, 
-     16,   0,  11,   0,   0,   0, 
-     70,   0,  16,   0,  15,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-     15,   0,   0,   0,  10,   0, 
-     16,   0,  15,   0,   0,   0, 
-     35,   0,   0,   9, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,  11,   0, 
-      0,   0,  58,   0,  16,   0, 
-     15,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     33,   0,   0,   7, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-     10,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  34,   0,   0,   7, 
-    130,   0,  16,   0,  11,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-     43,   0,   0,   5, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  56,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     14,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  28,   0, 
-      0,   5, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-     12,   0,   0,   0,  55,   0, 
-      0,  10, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,  11,   0,   0,   0, 
-     10, 144, 144,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     10,   0,  16,   0,  13,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  30,   0,   0,   8, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  10,   0,  16, 128, 
-     65,   0,   0,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,  38,   0, 
-      0,   8,   0, 208,   0,   0, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  42,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     33,   0,   0,   7, 130,   0, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  60,   0, 
-      0,   7, 130,   0,  16,   0, 
-     11,   0,   0,   0,  58,   0, 
-     16,   0,   7,   0,   0,   0, 
-     58,   0,  16,   0,  11,   0, 
-      0,   0,  34,   0,   0,   7, 
-     18,   0,  16,   0,  15,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  42,   0, 
-     16,   0,  15,   0,   0,   0, 
-     43,   0,   0,   5, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  56,   0,   0,   7, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,   1,  64, 
-      0,   0, 253, 255, 125,  66, 
-     14,   0,   0,   7, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  28,   0, 
-      0,   5, 130,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-     12,   0,   0,   0,  55,   0, 
-      0,  10, 130,   0,  16,   0, 
-     10,   0,   0,   0,  10,   0, 
-     16,   0,  15,   0,   0,   0, 
-     10, 144, 144,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     26,   0,  16,   0,  13,   0, 
-      0,   0,  55,   0,   0,   9, 
-    130,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-     11,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  26,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   9, 130,   0, 
-     16,   0,  11,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,  26, 144, 144, 128, 
-     65,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     38,   0,   0,   9,   0, 208, 
-      0,   0, 178,   0,  16,   0, 
-     15,   0,   0,   0,  70,   8, 
-     16,   0,   8,   0,   0,   0, 
-     86, 149, 144,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     35,   0,   0,   9, 178,   0, 
-     16,   0,  15,   0,   0,   0, 
-    246,  15,  16,   0,  11,   0, 
-      0,   0,  70,   8,  16,   0, 
-     10,   0,   0,   0,  70,  12, 
-     16,   0,  15,   0,   0,   0, 
-     30,   0,   0,  10, 178,   0, 
-     16,   0,  15,   0,   0,   0, 
-     70,  12,  16,   0,  15,   0, 
-      0,   0,   2,  64,   0,   0, 
-     32,   0,   0,   0,  32,   0, 
-      0,   0,   0,   0,   0,   0, 
-     32,   0,   0,   0,  85,   0, 
-      0,   7, 178,   0,  16,   0, 
-     16,   0,   0,   0,  70,  12, 
-     16,   0,  15,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-      6,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     30,   0,   0,   9, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-      1,  64,   0,   0,  64,   0, 
-      0,   0,  26, 144, 144, 128, 
-     65,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     38,   0,   0,   9,   0, 208, 
-      0,   0, 130,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,   9,   0,   0,   0, 
-     26, 144, 144,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     35,   0,   0,   9, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  10,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     30,   0,   0,   7, 130,   0, 
-     16,   0,   9,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,   1,  64,   0,   0, 
-     32,   0,   0,   0,  85,   0, 
-      0,   7,  34,   0,  16,   0, 
-     15,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-      1,  64,   0,   0,   6,   0, 
-      0,   0,  79,   0,   0,   7, 
-    114,   0,  16,   0,  17,   0, 
-      0,   0,  70,   3,  16,   0, 
-     16,   0,   0,   0,  70,   2, 
-     16,   0,  14,   0,   0,   0, 
-     54,   0,   0,   5,  66,   0, 
-     16,   0,  16,   0,   0,   0, 
-     10,   0,  16,   0,  14,   0, 
-      0,   0,  55,   0,   0,   9, 
-    146,   0,  16,   0,  17,   0, 
-      0,   0,   6,   0,  16,   0, 
-     17,   0,   0,   0, 166,   2, 
-     16,   0,  16,   0,   0,   0, 
-      6,   8,  16,   0,  16,   0, 
-      0,   0,  54,   0,   0,   5, 
-     82,   0,  16,   0,  16,   0, 
-      0,   0,  86,   6,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9, 242,   0,  16,   0, 
-     16,   0,   0,   0,  86,  10, 
-     16,   0,  17,   0,   0,   0, 
-     70,  14,  16,   0,  16,   0, 
-      0,   0,  22,  11,  16,   0, 
-     16,   0,   0,   0,  79,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,  15,   0,   0,   0, 
-     58,   0,  16,   0,  14,   0, 
-      0,   0,  54,   0,   0,   5, 
-     18,   0,  16,   0,  15,   0, 
-      0,   0,  58,   0,  16,   0, 
-     14,   0,   0,   0,  55,   0, 
-      0,   9,  50,   0,  16,   0, 
-     14,   0,   0,   0, 246,  15, 
-     16,   0,   9,   0,   0,   0, 
-     70,   0,  16,   0,  15,   0, 
-      0,   0,  22,   5,  16,   0, 
-     15,   0,   0,   0,  40,   0, 
-      0,   5, 130,   0,  16,   0, 
-     18,   0,   0,   0,  58,   0, 
-     16,   0,  17,   0,   0,   0, 
-     40,   0,   0,   5,  98,   0, 
-     16,   0,  18,   0,   0,   0, 
-     86,   7,  16,   0,  16,   0, 
-      0,   0,  40,   0,   0,   5, 
-     18,   0,  16,   0,  18,   0, 
-      0,   0,  26,   0,  16,   0, 
-     14,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-     14,   0,   0,   0,  10,   0, 
-     16,   0,  17,   0,   0,   0, 
-     54,   0,   0,   5,  98,   0, 
-     16,   0,  14,   0,   0,   0, 
-      6,   2,  16,   0,  16,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,  14,   0, 
-      0,   0,  70,  14,  16,   0, 
-     18,   0,   0,   0,  70,  14, 
-     16,   0,  14,   0,   0,   0, 
-     55,   0,   0,   9, 194,   0, 
-     16,   0,  16,   0,   0,   0, 
-    166,  10,  16,   0,   7,   0, 
-      0,   0,   6,   8,  16,   0, 
-     14,   0,   0,   0, 166,   2, 
-     16,   0,  14,   0,   0,   0, 
-     54,   0,   0,   5,  50,   0, 
-     16,   0,  16,   0,   0,   0, 
-    118,  15,  16,   0,  14,   0, 
-      0,   0,  55,   0,   0,   9, 
-    226,   0,  16,   0,  16,   0, 
-      0,   0,  86,   5,  16,   0, 
-      7,   0,   0,   0,   6,   6, 
-     16,   0,  14,   0,   0,   0, 
-     86,  14,  16,   0,  16,   0, 
-      0,   0,  55,   0,   0,   9, 
-    242,   0,  16,   0,  14,   0, 
-      0,   0,   6,   0,  16,   0, 
-      7,   0,   0,   0,  70,  14, 
-     16,   0,  14,   0,   0,   0, 
-     70,  14,  16,   0,  16,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0,  50,   0, 
-     16,   0,  14,   0,   0,   0, 
-     70,   0,  16,   0,  14,   0, 
-      0,   0,  70,   0,  16,   0, 
-     14,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      9,   0,   0,   0,  26,   0, 
-     16,   0,  14,   0,   0,   0, 
-     10,   0,  16,   0,  14,   0, 
-      0,   0,  35,   0,   0,   9, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  42,   0,  16,   0, 
-     14,   0,   0,   0,  42,   0, 
-     16,   0,  14,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  86,   0,   0,   5, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  86,   0, 
-      0,   5, 130,   0,  16,   0, 
-     10,   0,   0,   0,  58,   0, 
-     16,   0,  14,   0,   0,   0, 
-     56,   0,   0,   7, 130,   0, 
-     16,   0,  10,   0,   0,   0, 
-     58,   0,  16,   0,  10,   0, 
-      0,   0,  58,   0,  16,   0, 
-     10,   0,   0,   0,  50,   0, 
-      0,  10, 130,   0,  16,   0, 
-      9,   0,   0,   0,  58,   0, 
-     16,   0,  10,   0,   0,   0, 
-     42, 128,  32,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-     58,   0,  16,   0,   9,   0, 
-      0,   0,  28,   0,   0,   5, 
-    130,   0,  16,   0,   9,   0, 
-      0,   0,  58,   0,  16,   0, 
-      9,   0,   0,   0,  30,   0, 
-      0,   7,  66,   0,  16,   0, 
-     13,   0,   0,   0,  58,   0, 
-     16,   0,   9,   0,   0,   0, 
-     42,   0,  16,   0,  13,   0, 
-      0,   0,  30,   0,   0,   7, 
-    130,   0,  16,   0,  13,   0, 
-      0,   0,  58,   0,  16,   0, 
-     13,   0,   0,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-     22,   0,   0,   1,  54,   0, 
-      0,   5,  18,   0,  16,   0, 
-     12,   0,   0,   0,  42,   0, 
-     16,   0,  13,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-     58,   0,  16,   0,   2,   0, 
-      0,   0,  18,   0,   0,   1, 
-     31,   0,   4,   3,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   7,  18,   0, 
-     16,   0,   7,   0,   0,   0, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-    244, 255, 255, 255,  85,   0, 
-      0,   7,  34,   0,  16,   0, 
-      7,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-      1,  64,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,  10, 
-    194,   0,  16,   0,   0,   0, 
-      0,   0,   6,   4,  16,   0, 
-      7,   0,   0,   0,   2,  64, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,  10, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,   2,  64,   0,   0, 
-    254, 255, 255, 255, 254, 255, 
-    255, 255, 254, 255, 255, 255, 
-    254, 255, 255, 255,  30,   0, 
-      0,   7, 242,   0,  16,   0, 
-      4,   0,   0,   0, 166,  10, 
-     16,   0,   0,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,   1,   0,   0,  10, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,   2,  64, 
-      0,   0, 254, 255, 255, 255, 
-    254, 255, 255, 255, 254, 255, 
-    255, 255, 254, 255, 255, 255, 
-     30,   0,   0,   7, 242,   0, 
-     16,   0,   5,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,  30,   0, 
-      0,   8, 242,   0,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16, 128,  65,   0,   0,   0, 
-      4,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0, 194,   0,  16,   0, 
-      0,   0,   0,   0,   6,   4, 
-     16,   0,   8,   0,   0,   0, 
-      6,   4,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     35,   0,   0,   9,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     35,   0,   0,   9,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     30,   0,   0,   8, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-     70,  14,  16,   0,   3,   0, 
-      0,   0,  70,  14,  16, 128, 
-     65,   0,   0,   0,   4,   0, 
-      0,   0,  38,   0,   0,   8, 
-      0, 208,   0,   0,  98,   0, 
-     16,   0,   2,   0,   0,   0, 
-      6,   1,  16,   0,   3,   0, 
-      0,   0,   6,   1,  16,   0, 
-      8,   0,   0,   0,  30,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  35,   0,   0,   9, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      8,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  35,   0,   0,   9, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      8,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  34,   0,   0,   7, 
-     18,   0,  16,   0,   1,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     33,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   7,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  43,   0,   0,   5, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  56,   0, 
-      0,   7, 130,   0,  16,   0, 
-      0,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0, 253, 255, 
-    125,  66,  28,   0,   0,   5, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  41,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   5,   0, 
-      0,   0,  79,   0,   0,   7, 
-    130,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-     58,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  40,   0, 
-      0,   5, 242,   0,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,   9,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,  70,  14, 
-     16,   0,   4,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,   4,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  70,  14,  16,   0, 
-      4,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,   3,   0,   0,   0, 
-    246,  15,  16,   0,   0,   0, 
-      0,   0,  70,  14,  16,   0, 
-      3,   0,   0,   0,  70,  14, 
-     16,   0,   8,   0,   0,   0, 
-     33,   0,   0,   7, 130,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  43,   0, 
-      0,   5,  18,   0,  16,   0, 
-      1,   0,   0,   0,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-     54,   0,   0,   8,  50,   0, 
-     16,   0,  12,   0,   0,   0, 
-      2,  64,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  48,   0,   0,   1, 
-     80,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,  12,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   3,   0, 
-      4,   3,  26,   0,  16,   0, 
-      2,   0,   0,   0,  30,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,  12,   0, 
-      0,   0, 167,   0,   0,   9, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70, 254,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   8, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16, 128, 
-     65,   0,   0,   0,   9,   0, 
-      0,   0,  70,  14,  16,   0, 
-      5,   0,   0,   0,  38,   0, 
-      0,   8,   0, 208,   0,   0, 
-     98,   0,  16,   0,   2,   0, 
-      0,   0,   6,   1,  16,   0, 
-      3,   0,   0,   0,   6,   1, 
-     16,   0,   8,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  35,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   3,   0,   0,   0, 
-     42,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  35,   0, 
-      0,   9,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   3,   0,   0,   0, 
-     58,   0,  16,   0,   8,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  33,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  60,   0,   0,   7, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     34,   0,   0,   7, 130,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      0,   0,   0,   0,  43,   0, 
-      0,   5,  34,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     56,   0,   0,   7,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-    253, 255, 125,  66,  14,   0, 
-      0,   7,  34,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10,   0,  16,   0,   1,   0, 
-      0,   0,  28,   0,   0,   5, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  55,   0, 
-      0,  10,  34,   0,  16,   0, 
-      2,   0,   0,   0,  58,   0, 
-     16,   0,   2,   0,   0,   0, 
-     10, 144, 144,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-      1,  64,   0,   0,  15,   0, 
-      0,   0,  55,   0,   0,   9, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   9, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,   1,  64,   0,   0, 
-     64,   0,   0,   0,  26, 144, 
-    144, 128,  65,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  38,   0,   0,   9, 
-      0, 208,   0,   0, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   4,   0, 
-      0,   0,  86, 149, 144,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  35,   0,   0,   9, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0, 166,  10,  16,   0, 
-      2,   0,   0,   0,  70,  14, 
-     16,   0,   9,   0,   0,   0, 
-     70,  14,  16,   0,   8,   0, 
-      0,   0,  30,   0,   0,  10, 
-    242,   0,  16,   0,   8,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,   2,  64, 
-      0,   0,  32,   0,   0,   0, 
-     32,   0,   0,   0,  32,   0, 
-      0,   0,  32,   0,   0,   0, 
-     85,   0,   0,   7, 242,   0, 
-     16,   0,   8,   0,   0,   0, 
-    134,  13,  16,   0,   8,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  79,   0, 
-      0,   7, 242,   0,  16,   0, 
-     10,   0,   0,   0, 134,  13, 
-     16,   0,   8,   0,   0,   0, 
-     70,  14,  16,   0,   5,   0, 
-      0,   0,  54,   0,   0,   5, 
-     82,   0,  16,   0,  11,   0, 
-      0,   0,   6,   1,  16,   0, 
-      5,   0,   0,   0,  54,   0, 
-      0,   5, 162,   0,  16,   0, 
-     11,   0,   0,   0,   6,   8, 
-     16,   0,   8,   0,   0,   0, 
-     55,   0,   0,   9, 242,   0, 
-     16,   0,  11,   0,   0,   0, 
-      6,   5,  16,   0,  10,   0, 
-      0,   0,  70,  14,  16,   0, 
-     11,   0,   0,   0,  22,  11, 
-     16,   0,  11,   0,   0,   0, 
-     54,   0,   0,   5,  82,   0, 
-     16,   0,   8,   0,   0,   0, 
-    166,  11,  16,   0,   5,   0, 
-      0,   0,  55,   0,   0,   9, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0, 230,  14,  16,   0, 
-     10,   0,   0,   0, 214,   8, 
-     16,   0,   8,   0,   0,   0, 
-    134,  13,  16,   0,   8,   0, 
-      0,   0,  40,   0,   0,   5, 
-     50,   0,  16,   0,   8,   0, 
-      0,   0, 214,   5,  16,   0, 
-     11,   0,   0,   0,  40,   0, 
-      0,   5, 194,   0,  16,   0, 
-      8,   0,   0,   0,   6,   4, 
-     16,   0,   5,   0,   0,   0, 
-     54,   0,   0,   5,  50,   0, 
-     16,   0,   5,   0,   0,   0, 
-    134,   0,  16,   0,  11,   0, 
-      0,   0,  30,   0,   0,   7, 
-    242,   0,  16,   0,   5,   0, 
-      0,   0,  70,  14,  16,   0, 
-      8,   0,   0,   0,  70,  14, 
-     16,   0,   5,   0,   0,   0, 
-     38,   0,   0,   8,   0, 208, 
-      0,   0,  98,   0,  16,   0, 
-      2,   0,   0,   0,   6,   1, 
-     16,   0,   5,   0,   0,   0, 
-      6,   1,  16,   0,   5,   0, 
-      0,   0,  30,   0,   0,   7, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     35,   0,   0,   9,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   5,   0, 
-      0,   0,  42,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     86,   0,   0,   5,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  86,   0,   0,   5, 
-     66,   0,  16,   0,   2,   0, 
-      0,   0,  58,   0,  16,   0, 
-      5,   0,   0,   0,  56,   0, 
-      0,   7,  66,   0,  16,   0, 
-      2,   0,   0,   0,  42,   0, 
-     16,   0,   2,   0,   0,   0, 
-     42,   0,  16,   0,   2,   0, 
-      0,   0,  50,   0,   0,  10, 
-     34,   0,  16,   0,   2,   0, 
-      0,   0,  42,   0,  16,   0, 
-      2,   0,   0,   0,  42, 128, 
-     32,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,  26,   0, 
-     16,   0,   2,   0,   0,   0, 
-     28,   0,   0,   5,  34,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  30,   0,   0,   7, 
-     18,   0,  16,   0,  12,   0, 
-      0,   0,  26,   0,  16,   0, 
-      2,   0,   0,   0,  10,   0, 
-     16,   0,  12,   0,   0,   0, 
-     30,   0,   0,   7,  34,   0, 
-     16,   0,  12,   0,   0,   0, 
-     26,   0,  16,   0,  12,   0, 
-      0,   0,   1,  64,   0,   0, 
-      1,   0,   0,   0,  22,   0, 
-      0,   1,  54,   0,   0,   5, 
-     34,   0,  16,   0,  12,   0, 
-      0,   0,   1,  64,   0,   0, 
-      6,   0,   0,   0,  54,   0, 
-      0,   5, 130,   0,  16,   0, 
-      6,   0,   0,   0,  10,   0, 
-     16,   0,   7,   0,   0,   0, 
-     18,   0,   0,   1,  54,   0, 
-      0,   8,  50,   0,  16,   0, 
-     12,   0,   0,   0,   2,  64, 
-      0,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     54,   0,   0,   5, 130,   0, 
-     16,   0,   6,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 168,   0, 
-      0,   8,  50, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,  70,   0, 
-     16,   0,  12,   0,   0,   0, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-    198,   0,  16,   0,   6,   0, 
-      0,   0, 190,  24,   0,   1, 
-     31,   0,   4,   3,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   8,   0,   0,   0, 
-    167,   0,   0,   9,  98,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 241, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   4,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   3,   0, 
-      0,   0,  10,   0,  16,   0, 
-     12,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      3,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  50, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0, 134,   0, 
-     16,   0,   3,   0,   0,   0, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     70,   0,  16,   0,   4,   0, 
-      0,   0,  21,   0,   0,   1, 
-     21,   0,   0,   1, 190,  24, 
-      0,   1,  31,   0,   4,   3, 
-     42,   0,  16,   0,   1,   0, 
-      0,   0, 167,   0,   0,   8, 
-     18,   0,  16,   0,   3,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0,  30,   0, 
-      0,   6,  34,   0,  16,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-      4,   0,   0,   0, 167,   0, 
-      0,   9,  98,   0,  16,   0, 
-      4,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 241,  17,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  50,   0,  16,   0, 
-      5,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  70, 240,  17,   0, 
-      0,   0,   0,   0,  79,   0, 
-      0,   7,  66,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   4,   0,   0,   0, 
-     10,   0,  16,   0,   3,   0, 
-      0,   0,  31,   0,   4,   3, 
-     42,   0,  16,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     18,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0, 168,   0,   0,   8, 
-     50, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0, 134,   0,  16,   0, 
-      4,   0,   0,   0, 168,   0, 
-      0,   8,  50, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  70,   0, 
-     16,   0,   5,   0,   0,   0, 
-     21,   0,   0,   1,  21,   0, 
-      0,   1, 190,  24,   0,   1, 
-     31,   0,   4,   3,  58,   0, 
-     16,   0,   1,   0,   0,   0, 
-    167,   0,   0,   8,  18,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 240,  17,   0,   0,   0, 
-      0,   0,  30,   0,   0,   6, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,   2,   0, 
-      0,   0, 167,   0,   0,   9, 
-     98,   0,  16,   0,   3,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-      6, 241,  17,   0,   0,   0, 
-      0,   0, 167,   0,   0,   9, 
-     50,   0,  16,   0,   4,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  79,   0,   0,   7, 
-     66,   0,  16,   0,   0,   0, 
-      0,   0,  26,   0,  16,   0, 
-      3,   0,   0,   0,  10,   0, 
-     16,   0,   1,   0,   0,   0, 
-     31,   0,   4,   3,  42,   0, 
-     16,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  18,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-    134,   0,  16,   0,   3,   0, 
-      0,   0, 168,   0,   0,   8, 
-     50, 240,  17,   0,   0,   0, 
-      0,   0,  10,  64,   2,   0, 
-      1,  64,   0,   0,  28,   0, 
-      0,   0,  70,   0,  16,   0, 
-      4,   0,   0,   0,  21,   0, 
-      0,   1,  21,   0,   0,   1, 
-    190,  24,   0,   1,  31,   0, 
-      4,   3,  10,   0,  16,   0, 
-      2,   0,   0,   0, 167,   0, 
-      0,   8,  18,   0,  16,   0, 
-      1,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 240, 
-     17,   0,   0,   0,   0,   0, 
-     30,   0,   0,   6,  34,   0, 
-     16,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,   1,   0,   0,   0, 
-    167,   0,   0,   9,  98,   0, 
-     16,   0,   2,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0,   6, 241, 
-     17,   0,   0,   0,   0,   0, 
-    167,   0,   0,   9,  50,   0, 
-     16,   0,   3,   0,   0,   0, 
-     26,   0,  16,   0,   0,   0, 
-      0,   0,   1,  64,   0,   0, 
-     28,   0,   0,   0,  70, 240, 
-     17,   0,   0,   0,   0,   0, 
-     79,   0,   0,   7,  66,   0, 
-     16,   0,   0,   0,   0,   0, 
-     26,   0,  16,   0,   2,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,  31,   0, 
-      4,   3,  42,   0,  16,   0, 
-      0,   0,   0,   0, 167,   0, 
-      0,   9,  18,   0,  16,   0, 
-      2,   0,   0,   0,  26,   0, 
-     16,   0,   0,   0,   0,   0, 
-      1,  64,   0,   0,  16,   0, 
-      0,   0,   6, 240,  17,   0, 
-      0,   0,   0,   0, 168,   0, 
-      0,   8,  50, 240,  17,   0, 
-      0,   0,   0,   0,  10,  64, 
-      2,   0,   1,  64,   0,   0, 
-     16,   0,   0,   0, 134,   0, 
-     16,   0,   2,   0,   0,   0, 
-    168,   0,   0,   8,  50, 240, 
-     17,   0,   0,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-     70,   0,  16,   0,   3,   0, 
-      0,   0,  21,   0,   0,   1, 
-    167,   0,   0,   8, 146,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  28,   0,   0,   0, 
-      6, 244,  17,   0,   0,   0, 
-      0,   0,  41,   0,   0,   7, 
-     34,   0,  16,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      1,   0,   0,   0,   1,  64, 
-      0,   0,  31,   0,   0,   0, 
-    167,   0,   0,   8,  50,   0, 
-     16,   0,   1,   0,   0,   0, 
-     10,  64,   2,   0,   1,  64, 
-      0,   0,  16,   0,   0,   0, 
-     70, 240,  17,   0,   0,   0, 
-      0,   0,  60,   0,   0,   7, 
-     34,   0,  16,   0,   1,   0, 
-      0,   0,  26,   0,  16,   0, 
-      0,   0,   0,   0,  26,   0, 
-     16,   0,   1,   0,   0,   0, 
-     54,   0,   0,   5,  66,   0, 
-     16,   0,   1,   0,   0,   0, 
-      1,  64,   0,   0,   0,   0, 
-      0,   0, 168,   0,   0,   9, 
-    242, 224,  17,   0,   0,   0, 
-      0,   0,  10,   0,  16,   0, 
-      0,   0,   0,   0,   1,  64, 
-      0,   0,   0,   0,   0,   0, 
-     70,  14,  16,   0,   1,   0, 
-      0,   0,  21,   0,   0,   1, 
-     62,   0,   0,   1
-};
diff --git a/thirdparty/directxtex/d3dx12.h b/thirdparty/directxtex/d3dx12.h
deleted file mode 100644
index e873d96..0000000
--- a/thirdparty/directxtex/d3dx12.h
+++ /dev/null
@@ -1,5158 +0,0 @@
-//*********************************************************
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License (MIT).
-//
-//*********************************************************
-
-#ifndef __D3DX12_H__
-#define __D3DX12_H__
-
-#include "d3d12.h"
-
-#if defined( __cplusplus )
-
-struct CD3DX12_DEFAULT {};
-extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT;
-
-//------------------------------------------------------------------------------------------------
-inline bool operator==( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) noexcept
-{
-    return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width &&
-        l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth;
-}
-
-//------------------------------------------------------------------------------------------------
-inline bool operator!=( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) noexcept
-{ return !( l == r ); }
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_RECT : public D3D12_RECT
-{
-    CD3DX12_RECT() = default;
-    explicit CD3DX12_RECT( const D3D12_RECT& o ) noexcept :
-        D3D12_RECT( o )
-    {}
-    explicit CD3DX12_RECT(
-        LONG Left,
-        LONG Top,
-        LONG Right,
-        LONG Bottom ) noexcept
-    {
-        left = Left;
-        top = Top;
-        right = Right;
-        bottom = Bottom;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_VIEWPORT : public D3D12_VIEWPORT
-{
-    CD3DX12_VIEWPORT() = default;
-    explicit CD3DX12_VIEWPORT( const D3D12_VIEWPORT& o ) noexcept :
-        D3D12_VIEWPORT( o )
-    {}
-    explicit CD3DX12_VIEWPORT(
-        FLOAT topLeftX,
-        FLOAT topLeftY,
-        FLOAT width,
-        FLOAT height,
-        FLOAT minDepth = D3D12_MIN_DEPTH,
-        FLOAT maxDepth = D3D12_MAX_DEPTH ) noexcept
-    {
-        TopLeftX = topLeftX;
-        TopLeftY = topLeftY;
-        Width = width;
-        Height = height;
-        MinDepth = minDepth;
-        MaxDepth = maxDepth;
-    }
-    explicit CD3DX12_VIEWPORT(
-        _In_ ID3D12Resource* pResource,
-        UINT mipSlice = 0,
-        FLOAT topLeftX = 0.0f,
-        FLOAT topLeftY = 0.0f,
-        FLOAT minDepth = D3D12_MIN_DEPTH,
-        FLOAT maxDepth = D3D12_MAX_DEPTH ) noexcept
-    {
-#if defined(_MSC_VER) || !defined(_WIN32)
-        const auto Desc = pResource->GetDesc();
-#else
-        D3D12_RESOURCE_DESC tmpDesc;
-        const auto& Desc = *pResource->GetDesc(&tmpDesc);
-#endif
-        const UINT64 SubresourceWidth = Desc.Width >> mipSlice;
-        const UINT64 SubresourceHeight = Desc.Height >> mipSlice;
-        switch (Desc.Dimension)
-        {
-        case D3D12_RESOURCE_DIMENSION_BUFFER:
-            TopLeftX = topLeftX;
-            TopLeftY = 0.0f;
-            Width = float(Desc.Width) - topLeftX;
-            Height = 1.0f;
-            break;
-        case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
-            TopLeftX = topLeftX;
-            TopLeftY = 0.0f;
-            Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f) - topLeftX;
-            Height = 1.0f;
-            break;
-        case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
-        case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
-            TopLeftX = topLeftX;
-            TopLeftY = topLeftY;
-            Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f) - topLeftX;
-            Height = (SubresourceHeight ? float(SubresourceHeight) : 1.0f) - topLeftY;
-            break;
-        default: break;
-        }
-
-        MinDepth = minDepth;
-        MaxDepth = maxDepth;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_BOX : public D3D12_BOX
-{
-    CD3DX12_BOX() = default;
-    explicit CD3DX12_BOX( const D3D12_BOX& o ) noexcept :
-        D3D12_BOX( o )
-    {}
-    explicit CD3DX12_BOX(
-        LONG Left,
-        LONG Right ) noexcept
-    {
-        left = static_cast<UINT>(Left);
-        top = 0;
-        front = 0;
-        right = static_cast<UINT>(Right);
-        bottom = 1;
-        back = 1;
-    }
-    explicit CD3DX12_BOX(
-        LONG Left,
-        LONG Top,
-        LONG Right,
-        LONG Bottom ) noexcept
-    {
-        left = static_cast<UINT>(Left);
-        top = static_cast<UINT>(Top);
-        front = 0;
-        right = static_cast<UINT>(Right);
-        bottom = static_cast<UINT>(Bottom);
-        back = 1;
-    }
-    explicit CD3DX12_BOX(
-        LONG Left,
-        LONG Top,
-        LONG Front,
-        LONG Right,
-        LONG Bottom,
-        LONG Back ) noexcept
-    {
-        left = static_cast<UINT>(Left);
-        top = static_cast<UINT>(Top);
-        front = static_cast<UINT>(Front);
-        right = static_cast<UINT>(Right);
-        bottom = static_cast<UINT>(Bottom);
-        back = static_cast<UINT>(Back);
-    }
-};
-inline bool operator==( const D3D12_BOX& l, const D3D12_BOX& r ) noexcept
-{
-    return l.left == r.left && l.top == r.top && l.front == r.front &&
-        l.right == r.right && l.bottom == r.bottom && l.back == r.back;
-}
-inline bool operator!=( const D3D12_BOX& l, const D3D12_BOX& r ) noexcept
-{ return !( l == r ); }
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC
-{
-    CD3DX12_DEPTH_STENCIL_DESC() = default;
-    explicit CD3DX12_DEPTH_STENCIL_DESC( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept :
-        D3D12_DEPTH_STENCIL_DESC( o )
-    {}
-    explicit CD3DX12_DEPTH_STENCIL_DESC( CD3DX12_DEFAULT ) noexcept
-    {
-        DepthEnable = TRUE;
-        DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
-        DepthFunc = D3D12_COMPARISON_FUNC_LESS;
-        StencilEnable = FALSE;
-        StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
-        StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
-        const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
-        { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
-        FrontFace = defaultStencilOp;
-        BackFace = defaultStencilOp;
-    }
-    explicit CD3DX12_DEPTH_STENCIL_DESC(
-        BOOL depthEnable,
-        D3D12_DEPTH_WRITE_MASK depthWriteMask,
-        D3D12_COMPARISON_FUNC depthFunc,
-        BOOL stencilEnable,
-        UINT8 stencilReadMask,
-        UINT8 stencilWriteMask,
-        D3D12_STENCIL_OP frontStencilFailOp,
-        D3D12_STENCIL_OP frontStencilDepthFailOp,
-        D3D12_STENCIL_OP frontStencilPassOp,
-        D3D12_COMPARISON_FUNC frontStencilFunc,
-        D3D12_STENCIL_OP backStencilFailOp,
-        D3D12_STENCIL_OP backStencilDepthFailOp,
-        D3D12_STENCIL_OP backStencilPassOp,
-        D3D12_COMPARISON_FUNC backStencilFunc ) noexcept
-    {
-        DepthEnable = depthEnable;
-        DepthWriteMask = depthWriteMask;
-        DepthFunc = depthFunc;
-        StencilEnable = stencilEnable;
-        StencilReadMask = stencilReadMask;
-        StencilWriteMask = stencilWriteMask;
-        FrontFace.StencilFailOp = frontStencilFailOp;
-        FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
-        FrontFace.StencilPassOp = frontStencilPassOp;
-        FrontFace.StencilFunc = frontStencilFunc;
-        BackFace.StencilFailOp = backStencilFailOp;
-        BackFace.StencilDepthFailOp = backStencilDepthFailOp;
-        BackFace.StencilPassOp = backStencilPassOp;
-        BackFace.StencilFunc = backStencilFunc;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_DEPTH_STENCIL_DESC1 : public D3D12_DEPTH_STENCIL_DESC1
-{
-    CD3DX12_DEPTH_STENCIL_DESC1() = default;
-    explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC1& o ) noexcept :
-        D3D12_DEPTH_STENCIL_DESC1( o )
-    {}
-    explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept
-    {
-        DepthEnable                  = o.DepthEnable;
-        DepthWriteMask               = o.DepthWriteMask;
-        DepthFunc                    = o.DepthFunc;
-        StencilEnable                = o.StencilEnable;
-        StencilReadMask              = o.StencilReadMask;
-        StencilWriteMask             = o.StencilWriteMask;
-        FrontFace.StencilFailOp      = o.FrontFace.StencilFailOp;
-        FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp;
-        FrontFace.StencilPassOp      = o.FrontFace.StencilPassOp;
-        FrontFace.StencilFunc        = o.FrontFace.StencilFunc;
-        BackFace.StencilFailOp       = o.BackFace.StencilFailOp;
-        BackFace.StencilDepthFailOp  = o.BackFace.StencilDepthFailOp;
-        BackFace.StencilPassOp       = o.BackFace.StencilPassOp;
-        BackFace.StencilFunc         = o.BackFace.StencilFunc;
-        DepthBoundsTestEnable        = FALSE;
-    }
-    explicit CD3DX12_DEPTH_STENCIL_DESC1( CD3DX12_DEFAULT ) noexcept
-    {
-        DepthEnable = TRUE;
-        DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
-        DepthFunc = D3D12_COMPARISON_FUNC_LESS;
-        StencilEnable = FALSE;
-        StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
-        StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
-        const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
-        { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
-        FrontFace = defaultStencilOp;
-        BackFace = defaultStencilOp;
-        DepthBoundsTestEnable = FALSE;
-    }
-    explicit CD3DX12_DEPTH_STENCIL_DESC1(
-        BOOL depthEnable,
-        D3D12_DEPTH_WRITE_MASK depthWriteMask,
-        D3D12_COMPARISON_FUNC depthFunc,
-        BOOL stencilEnable,
-        UINT8 stencilReadMask,
-        UINT8 stencilWriteMask,
-        D3D12_STENCIL_OP frontStencilFailOp,
-        D3D12_STENCIL_OP frontStencilDepthFailOp,
-        D3D12_STENCIL_OP frontStencilPassOp,
-        D3D12_COMPARISON_FUNC frontStencilFunc,
-        D3D12_STENCIL_OP backStencilFailOp,
-        D3D12_STENCIL_OP backStencilDepthFailOp,
-        D3D12_STENCIL_OP backStencilPassOp,
-        D3D12_COMPARISON_FUNC backStencilFunc,
-        BOOL depthBoundsTestEnable ) noexcept
-    {
-        DepthEnable = depthEnable;
-        DepthWriteMask = depthWriteMask;
-        DepthFunc = depthFunc;
-        StencilEnable = stencilEnable;
-        StencilReadMask = stencilReadMask;
-        StencilWriteMask = stencilWriteMask;
-        FrontFace.StencilFailOp = frontStencilFailOp;
-        FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
-        FrontFace.StencilPassOp = frontStencilPassOp;
-        FrontFace.StencilFunc = frontStencilFunc;
-        BackFace.StencilFailOp = backStencilFailOp;
-        BackFace.StencilDepthFailOp = backStencilDepthFailOp;
-        BackFace.StencilPassOp = backStencilPassOp;
-        BackFace.StencilFunc = backStencilFunc;
-        DepthBoundsTestEnable = depthBoundsTestEnable;
-    }
-    operator D3D12_DEPTH_STENCIL_DESC() const noexcept
-    {
-        D3D12_DEPTH_STENCIL_DESC D;
-        D.DepthEnable                  = DepthEnable;
-        D.DepthWriteMask               = DepthWriteMask;
-        D.DepthFunc                    = DepthFunc;
-        D.StencilEnable                = StencilEnable;
-        D.StencilReadMask              = StencilReadMask;
-        D.StencilWriteMask             = StencilWriteMask;
-        D.FrontFace.StencilFailOp      = FrontFace.StencilFailOp;
-        D.FrontFace.StencilDepthFailOp = FrontFace.StencilDepthFailOp;
-        D.FrontFace.StencilPassOp      = FrontFace.StencilPassOp;
-        D.FrontFace.StencilFunc        = FrontFace.StencilFunc;
-        D.BackFace.StencilFailOp       = BackFace.StencilFailOp;
-        D.BackFace.StencilDepthFailOp  = BackFace.StencilDepthFailOp;
-        D.BackFace.StencilPassOp       = BackFace.StencilPassOp;
-        D.BackFace.StencilFunc         = BackFace.StencilFunc;
-        return D;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC
-{
-    CD3DX12_BLEND_DESC() = default;
-    explicit CD3DX12_BLEND_DESC( const D3D12_BLEND_DESC& o ) noexcept :
-        D3D12_BLEND_DESC( o )
-    {}
-    explicit CD3DX12_BLEND_DESC( CD3DX12_DEFAULT ) noexcept
-    {
-        AlphaToCoverageEnable = FALSE;
-        IndependentBlendEnable = FALSE;
-        const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc =
-        {
-            FALSE,FALSE,
-            D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
-            D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
-            D3D12_LOGIC_OP_NOOP,
-            D3D12_COLOR_WRITE_ENABLE_ALL,
-        };
-        for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
-            RenderTarget[ i ] = defaultRenderTargetBlendDesc;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC
-{
-    CD3DX12_RASTERIZER_DESC() = default;
-    explicit CD3DX12_RASTERIZER_DESC( const D3D12_RASTERIZER_DESC& o ) noexcept :
-        D3D12_RASTERIZER_DESC( o )
-    {}
-    explicit CD3DX12_RASTERIZER_DESC( CD3DX12_DEFAULT ) noexcept
-    {
-        FillMode = D3D12_FILL_MODE_SOLID;
-        CullMode = D3D12_CULL_MODE_BACK;
-        FrontCounterClockwise = FALSE;
-        DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
-        DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
-        SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
-        DepthClipEnable = TRUE;
-        MultisampleEnable = FALSE;
-        AntialiasedLineEnable = FALSE;
-        ForcedSampleCount = 0;
-        ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
-    }
-    explicit CD3DX12_RASTERIZER_DESC(
-        D3D12_FILL_MODE fillMode,
-        D3D12_CULL_MODE cullMode,
-        BOOL frontCounterClockwise,
-        INT depthBias,
-        FLOAT depthBiasClamp,
-        FLOAT slopeScaledDepthBias,
-        BOOL depthClipEnable,
-        BOOL multisampleEnable,
-        BOOL antialiasedLineEnable,
-        UINT forcedSampleCount,
-        D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster) noexcept
-    {
-        FillMode = fillMode;
-        CullMode = cullMode;
-        FrontCounterClockwise = frontCounterClockwise;
-        DepthBias = depthBias;
-        DepthBiasClamp = depthBiasClamp;
-        SlopeScaledDepthBias = slopeScaledDepthBias;
-        DepthClipEnable = depthClipEnable;
-        MultisampleEnable = multisampleEnable;
-        AntialiasedLineEnable = antialiasedLineEnable;
-        ForcedSampleCount = forcedSampleCount;
-        ConservativeRaster = conservativeRaster;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_RESOURCE_ALLOCATION_INFO : public D3D12_RESOURCE_ALLOCATION_INFO
-{
-    CD3DX12_RESOURCE_ALLOCATION_INFO() = default;
-    explicit CD3DX12_RESOURCE_ALLOCATION_INFO( const D3D12_RESOURCE_ALLOCATION_INFO& o ) noexcept :
-        D3D12_RESOURCE_ALLOCATION_INFO( o )
-    {}
-    CD3DX12_RESOURCE_ALLOCATION_INFO(
-        UINT64 size,
-        UINT64 alignment ) noexcept
-    {
-        SizeInBytes = size;
-        Alignment = alignment;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES
-{
-    CD3DX12_HEAP_PROPERTIES() = default;
-    explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES &o) noexcept :
-        D3D12_HEAP_PROPERTIES(o)
-    {}
-    CD3DX12_HEAP_PROPERTIES(
-        D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
-        D3D12_MEMORY_POOL memoryPoolPreference,
-        UINT creationNodeMask = 1,
-        UINT nodeMask = 1 ) noexcept
-    {
-        Type = D3D12_HEAP_TYPE_CUSTOM;
-        CPUPageProperty = cpuPageProperty;
-        MemoryPoolPreference = memoryPoolPreference;
-        CreationNodeMask = creationNodeMask;
-        VisibleNodeMask = nodeMask;
-    }
-    explicit CD3DX12_HEAP_PROPERTIES(
-        D3D12_HEAP_TYPE type,
-        UINT creationNodeMask = 1,
-        UINT nodeMask = 1 ) noexcept
-    {
-        Type = type;
-        CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
-        MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
-        CreationNodeMask = creationNodeMask;
-        VisibleNodeMask = nodeMask;
-    }
-    bool IsCPUAccessible() const noexcept
-    {
-        return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK || (Type == D3D12_HEAP_TYPE_CUSTOM &&
-            (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE || CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK));
-    }
-};
-inline bool operator==( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) noexcept
-{
-    return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty &&
-        l.MemoryPoolPreference == r.MemoryPoolPreference &&
-        l.CreationNodeMask == r.CreationNodeMask &&
-        l.VisibleNodeMask == r.VisibleNodeMask;
-}
-inline bool operator!=( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) noexcept
-{ return !( l == r ); }
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC
-{
-    CD3DX12_HEAP_DESC() = default;
-    explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC &o) noexcept :
-        D3D12_HEAP_DESC(o)
-    {}
-    CD3DX12_HEAP_DESC(
-        UINT64 size,
-        D3D12_HEAP_PROPERTIES properties,
-        UINT64 alignment = 0,
-        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
-    {
-        SizeInBytes = size;
-        Properties = properties;
-        Alignment = alignment;
-        Flags = flags;
-    }
-    CD3DX12_HEAP_DESC(
-        UINT64 size,
-        D3D12_HEAP_TYPE type,
-        UINT64 alignment = 0,
-        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
-    {
-        SizeInBytes = size;
-        Properties = CD3DX12_HEAP_PROPERTIES( type );
-        Alignment = alignment;
-        Flags = flags;
-    }
-    CD3DX12_HEAP_DESC(
-        UINT64 size,
-        D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
-        D3D12_MEMORY_POOL memoryPoolPreference,
-        UINT64 alignment = 0,
-        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
-    {
-        SizeInBytes = size;
-        Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
-        Alignment = alignment;
-        Flags = flags;
-    }
-    CD3DX12_HEAP_DESC(
-        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
-        D3D12_HEAP_PROPERTIES properties,
-        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
-    {
-        SizeInBytes = resAllocInfo.SizeInBytes;
-        Properties = properties;
-        Alignment = resAllocInfo.Alignment;
-        Flags = flags;
-    }
-    CD3DX12_HEAP_DESC(
-        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
-        D3D12_HEAP_TYPE type,
-        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
-    {
-        SizeInBytes = resAllocInfo.SizeInBytes;
-        Properties = CD3DX12_HEAP_PROPERTIES( type );
-        Alignment = resAllocInfo.Alignment;
-        Flags = flags;
-    }
-    CD3DX12_HEAP_DESC(
-        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
-        D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
-        D3D12_MEMORY_POOL memoryPoolPreference,
-        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
-    {
-        SizeInBytes = resAllocInfo.SizeInBytes;
-        Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
-        Alignment = resAllocInfo.Alignment;
-        Flags = flags;
-    }
-    bool IsCPUAccessible() const noexcept
-    { return static_cast< const CD3DX12_HEAP_PROPERTIES* >( &Properties )->IsCPUAccessible(); }
-};
-inline bool operator==( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) noexcept
-{
-    return l.SizeInBytes == r.SizeInBytes &&
-        l.Properties == r.Properties &&
-        l.Alignment == r.Alignment &&
-        l.Flags == r.Flags;
-}
-inline bool operator!=( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) noexcept
-{ return !( l == r ); }
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE
-{
-    CD3DX12_CLEAR_VALUE() = default;
-    explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE &o) noexcept :
-        D3D12_CLEAR_VALUE(o)
-    {}
-    CD3DX12_CLEAR_VALUE(
-        DXGI_FORMAT format,
-        const FLOAT color[4] ) noexcept
-    {
-        Format = format;
-        memcpy( Color, color, sizeof( Color ) );
-    }
-    CD3DX12_CLEAR_VALUE(
-        DXGI_FORMAT format,
-        FLOAT depth,
-        UINT8 stencil ) noexcept
-    {
-        Format = format;
-        memset( &Color, 0, sizeof( Color ) );
-        /* Use memcpy to preserve NAN values */
-        memcpy( &DepthStencil.Depth, &depth, sizeof( depth ) );
-        DepthStencil.Stencil = stencil;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_RANGE : public D3D12_RANGE
-{
-    CD3DX12_RANGE() = default;
-    explicit CD3DX12_RANGE(const D3D12_RANGE &o) noexcept :
-        D3D12_RANGE(o)
-    {}
-    CD3DX12_RANGE(
-        SIZE_T begin,
-        SIZE_T end ) noexcept
-    {
-        Begin = begin;
-        End = end;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_RANGE_UINT64 : public D3D12_RANGE_UINT64
-{
-    CD3DX12_RANGE_UINT64() = default;
-    explicit CD3DX12_RANGE_UINT64(const D3D12_RANGE_UINT64 &o) noexcept :
-        D3D12_RANGE_UINT64(o)
-    {}
-    CD3DX12_RANGE_UINT64(
-        UINT64 begin,
-        UINT64 end ) noexcept
-    {
-        Begin = begin;
-        End = end;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_SUBRESOURCE_RANGE_UINT64 : public D3D12_SUBRESOURCE_RANGE_UINT64
-{
-    CD3DX12_SUBRESOURCE_RANGE_UINT64() = default;
-    explicit CD3DX12_SUBRESOURCE_RANGE_UINT64(const D3D12_SUBRESOURCE_RANGE_UINT64 &o) noexcept :
-        D3D12_SUBRESOURCE_RANGE_UINT64(o)
-    {}
-    CD3DX12_SUBRESOURCE_RANGE_UINT64(
-        UINT subresource,
-        const D3D12_RANGE_UINT64& range ) noexcept
-    {
-        Subresource = subresource;
-        Range = range;
-    }
-    CD3DX12_SUBRESOURCE_RANGE_UINT64(
-        UINT subresource,
-        UINT64 begin,
-        UINT64 end ) noexcept
-    {
-        Subresource = subresource;
-        Range.Begin = begin;
-        Range.End = end;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_SHADER_BYTECODE : public D3D12_SHADER_BYTECODE
-{
-    CD3DX12_SHADER_BYTECODE() = default;
-    explicit CD3DX12_SHADER_BYTECODE(const D3D12_SHADER_BYTECODE &o) noexcept :
-        D3D12_SHADER_BYTECODE(o)
-    {}
-    CD3DX12_SHADER_BYTECODE(
-        _In_ ID3DBlob* pShaderBlob ) noexcept
-    {
-        pShaderBytecode = pShaderBlob->GetBufferPointer();
-        BytecodeLength = pShaderBlob->GetBufferSize();
-    }
-    CD3DX12_SHADER_BYTECODE(
-        const void* _pShaderBytecode,
-        SIZE_T bytecodeLength ) noexcept
-    {
-        pShaderBytecode = _pShaderBytecode;
-        BytecodeLength = bytecodeLength;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_TILED_RESOURCE_COORDINATE : public D3D12_TILED_RESOURCE_COORDINATE
-{
-    CD3DX12_TILED_RESOURCE_COORDINATE() = default;
-    explicit CD3DX12_TILED_RESOURCE_COORDINATE(const D3D12_TILED_RESOURCE_COORDINATE &o) noexcept :
-        D3D12_TILED_RESOURCE_COORDINATE(o)
-    {}
-    CD3DX12_TILED_RESOURCE_COORDINATE(
-        UINT x,
-        UINT y,
-        UINT z,
-        UINT subresource ) noexcept
-    {
-        X = x;
-        Y = y;
-        Z = z;
-        Subresource = subresource;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE
-{
-    CD3DX12_TILE_REGION_SIZE() = default;
-    explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE &o) noexcept :
-        D3D12_TILE_REGION_SIZE(o)
-    {}
-    CD3DX12_TILE_REGION_SIZE(
-        UINT numTiles,
-        BOOL useBox,
-        UINT width,
-        UINT16 height,
-        UINT16 depth ) noexcept
-    {
-        NumTiles = numTiles;
-        UseBox = useBox;
-        Width = width;
-        Height = height;
-        Depth = depth;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING
-{
-    CD3DX12_SUBRESOURCE_TILING() = default;
-    explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING &o) noexcept :
-        D3D12_SUBRESOURCE_TILING(o)
-    {}
-    CD3DX12_SUBRESOURCE_TILING(
-        UINT widthInTiles,
-        UINT16 heightInTiles,
-        UINT16 depthInTiles,
-        UINT startTileIndexInOverallResource ) noexcept
-    {
-        WidthInTiles = widthInTiles;
-        HeightInTiles = heightInTiles;
-        DepthInTiles = depthInTiles;
-        StartTileIndexInOverallResource = startTileIndexInOverallResource;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE
-{
-    CD3DX12_TILE_SHAPE() = default;
-    explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE &o) noexcept :
-        D3D12_TILE_SHAPE(o)
-    {}
-    CD3DX12_TILE_SHAPE(
-        UINT widthInTexels,
-        UINT heightInTexels,
-        UINT depthInTexels ) noexcept
-    {
-        WidthInTexels = widthInTexels;
-        HeightInTexels = heightInTexels;
-        DepthInTexels = depthInTexels;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_RESOURCE_BARRIER : public D3D12_RESOURCE_BARRIER
-{
-    CD3DX12_RESOURCE_BARRIER() = default;
-    explicit CD3DX12_RESOURCE_BARRIER(const D3D12_RESOURCE_BARRIER &o) noexcept :
-        D3D12_RESOURCE_BARRIER(o)
-    {}
-    static inline CD3DX12_RESOURCE_BARRIER Transition(
-        _In_ ID3D12Resource* pResource,
-        D3D12_RESOURCE_STATES stateBefore,
-        D3D12_RESOURCE_STATES stateAfter,
-        UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
-        D3D12_RESOURCE_BARRIER_FLAGS flags = D3D12_RESOURCE_BARRIER_FLAG_NONE) noexcept
-    {
-        CD3DX12_RESOURCE_BARRIER result = {};
-        D3D12_RESOURCE_BARRIER &barrier = result;
-        result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
-        result.Flags = flags;
-        barrier.Transition.pResource = pResource;
-        barrier.Transition.StateBefore = stateBefore;
-        barrier.Transition.StateAfter = stateAfter;
-        barrier.Transition.Subresource = subresource;
-        return result;
-    }
-    static inline CD3DX12_RESOURCE_BARRIER Aliasing(
-        _In_ ID3D12Resource* pResourceBefore,
-        _In_ ID3D12Resource* pResourceAfter) noexcept
-    {
-        CD3DX12_RESOURCE_BARRIER result = {};
-        D3D12_RESOURCE_BARRIER &barrier = result;
-        result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING;
-        barrier.Aliasing.pResourceBefore = pResourceBefore;
-        barrier.Aliasing.pResourceAfter = pResourceAfter;
-        return result;
-    }
-    static inline CD3DX12_RESOURCE_BARRIER UAV(
-        _In_ ID3D12Resource* pResource) noexcept
-    {
-        CD3DX12_RESOURCE_BARRIER result = {};
-        D3D12_RESOURCE_BARRIER &barrier = result;
-        result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
-        barrier.UAV.pResource = pResource;
-        return result;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO
-{
-    CD3DX12_PACKED_MIP_INFO() = default;
-    explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO &o) noexcept :
-        D3D12_PACKED_MIP_INFO(o)
-    {}
-    CD3DX12_PACKED_MIP_INFO(
-        UINT8 numStandardMips,
-        UINT8 numPackedMips,
-        UINT numTilesForPackedMips,
-        UINT startTileIndexInOverallResource ) noexcept
-    {
-        NumStandardMips = numStandardMips;
-        NumPackedMips = numPackedMips;
-        NumTilesForPackedMips = numTilesForPackedMips;
-        StartTileIndexInOverallResource = startTileIndexInOverallResource;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT
-{
-    CD3DX12_SUBRESOURCE_FOOTPRINT() = default;
-    explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT &o) noexcept :
-        D3D12_SUBRESOURCE_FOOTPRINT(o)
-    {}
-    CD3DX12_SUBRESOURCE_FOOTPRINT(
-        DXGI_FORMAT format,
-        UINT width,
-        UINT height,
-        UINT depth,
-        UINT rowPitch ) noexcept
-    {
-        Format = format;
-        Width = width;
-        Height = height;
-        Depth = depth;
-        RowPitch = rowPitch;
-    }
-    explicit CD3DX12_SUBRESOURCE_FOOTPRINT(
-        const D3D12_RESOURCE_DESC& resDesc,
-        UINT rowPitch ) noexcept
-    {
-        Format = resDesc.Format;
-        Width = UINT( resDesc.Width );
-        Height = resDesc.Height;
-        Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? resDesc.DepthOrArraySize : 1u);
-        RowPitch = rowPitch;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION
-{
-    CD3DX12_TEXTURE_COPY_LOCATION() = default;
-    explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION &o) noexcept :
-        D3D12_TEXTURE_COPY_LOCATION(o)
-    {}
-    CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes) noexcept
-    {
-        pResource = pRes;
-        Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
-        PlacedFootprint = {};
-    }
-    CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint) noexcept
-    {
-        pResource = pRes;
-        Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
-        PlacedFootprint = Footprint;
-    }
-    CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, UINT Sub) noexcept
-    {
-        pResource = pRes;
-        Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
-        PlacedFootprint = {};
-        SubresourceIndex = Sub;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE
-{
-    CD3DX12_DESCRIPTOR_RANGE() = default;
-    explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o) noexcept :
-        D3D12_DESCRIPTOR_RANGE(o)
-    {}
-    CD3DX12_DESCRIPTOR_RANGE(
-        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
-        UINT numDescriptors,
-        UINT baseShaderRegister,
-        UINT registerSpace = 0,
-        UINT offsetInDescriptorsFromTableStart =
-        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
-    {
-        Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
-    }
-
-    inline void Init(
-        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
-        UINT numDescriptors,
-        UINT baseShaderRegister,
-        UINT registerSpace = 0,
-        UINT offsetInDescriptorsFromTableStart =
-        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
-    {
-        Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
-    }
-
-    static inline void Init(
-        _Out_ D3D12_DESCRIPTOR_RANGE &range,
-        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
-        UINT numDescriptors,
-        UINT baseShaderRegister,
-        UINT registerSpace = 0,
-        UINT offsetInDescriptorsFromTableStart =
-        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
-    {
-        range.RangeType = rangeType;
-        range.NumDescriptors = numDescriptors;
-        range.BaseShaderRegister = baseShaderRegister;
-        range.RegisterSpace = registerSpace;
-        range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_ROOT_DESCRIPTOR_TABLE : public D3D12_ROOT_DESCRIPTOR_TABLE
-{
-    CD3DX12_ROOT_DESCRIPTOR_TABLE() = default;
-    explicit CD3DX12_ROOT_DESCRIPTOR_TABLE(const D3D12_ROOT_DESCRIPTOR_TABLE &o) noexcept :
-        D3D12_ROOT_DESCRIPTOR_TABLE(o)
-    {}
-    CD3DX12_ROOT_DESCRIPTOR_TABLE(
-        UINT numDescriptorRanges,
-        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
-    {
-        Init(numDescriptorRanges, _pDescriptorRanges);
-    }
-
-    inline void Init(
-        UINT numDescriptorRanges,
-        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
-    {
-        Init(*this, numDescriptorRanges, _pDescriptorRanges);
-    }
-
-    static inline void Init(
-        _Out_ D3D12_ROOT_DESCRIPTOR_TABLE &rootDescriptorTable,
-        UINT numDescriptorRanges,
-        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
-    {
-        rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
-        rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS
-{
-    CD3DX12_ROOT_CONSTANTS() = default;
-    explicit CD3DX12_ROOT_CONSTANTS(const D3D12_ROOT_CONSTANTS &o) noexcept :
-        D3D12_ROOT_CONSTANTS(o)
-    {}
-    CD3DX12_ROOT_CONSTANTS(
-        UINT num32BitValues,
-        UINT shaderRegister,
-        UINT registerSpace = 0) noexcept
-    {
-        Init(num32BitValues, shaderRegister, registerSpace);
-    }
-
-    inline void Init(
-        UINT num32BitValues,
-        UINT shaderRegister,
-        UINT registerSpace = 0) noexcept
-    {
-        Init(*this, num32BitValues, shaderRegister, registerSpace);
-    }
-
-    static inline void Init(
-        _Out_ D3D12_ROOT_CONSTANTS &rootConstants,
-        UINT num32BitValues,
-        UINT shaderRegister,
-        UINT registerSpace = 0) noexcept
-    {
-        rootConstants.Num32BitValues = num32BitValues;
-        rootConstants.ShaderRegister = shaderRegister;
-        rootConstants.RegisterSpace = registerSpace;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_ROOT_DESCRIPTOR : public D3D12_ROOT_DESCRIPTOR
-{
-    CD3DX12_ROOT_DESCRIPTOR() = default;
-    explicit CD3DX12_ROOT_DESCRIPTOR(const D3D12_ROOT_DESCRIPTOR &o) noexcept :
-        D3D12_ROOT_DESCRIPTOR(o)
-    {}
-    CD3DX12_ROOT_DESCRIPTOR(
-        UINT shaderRegister,
-        UINT registerSpace = 0) noexcept
-    {
-        Init(shaderRegister, registerSpace);
-    }
-
-    inline void Init(
-        UINT shaderRegister,
-        UINT registerSpace = 0) noexcept
-    {
-        Init(*this, shaderRegister, registerSpace);
-    }
-
-    static inline void Init(_Out_ D3D12_ROOT_DESCRIPTOR &table, UINT shaderRegister, UINT registerSpace = 0) noexcept
-    {
-        table.ShaderRegister = shaderRegister;
-        table.RegisterSpace = registerSpace;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_ROOT_PARAMETER : public D3D12_ROOT_PARAMETER
-{
-    CD3DX12_ROOT_PARAMETER() = default;
-    explicit CD3DX12_ROOT_PARAMETER(const D3D12_ROOT_PARAMETER &o) noexcept :
-        D3D12_ROOT_PARAMETER(o)
-    {}
-
-    static inline void InitAsDescriptorTable(
-        _Out_ D3D12_ROOT_PARAMETER &rootParam,
-        UINT numDescriptorRanges,
-        _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
-    }
-
-    static inline void InitAsConstants(
-        _Out_ D3D12_ROOT_PARAMETER &rootParam,
-        UINT num32BitValues,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
-    }
-
-    static inline void InitAsConstantBufferView(
-        _Out_ D3D12_ROOT_PARAMETER &rootParam,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
-    }
-
-    static inline void InitAsShaderResourceView(
-        _Out_ D3D12_ROOT_PARAMETER &rootParam,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
-    }
-
-    static inline void InitAsUnorderedAccessView(
-        _Out_ D3D12_ROOT_PARAMETER &rootParam,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
-    }
-
-    inline void InitAsDescriptorTable(
-        UINT numDescriptorRanges,
-        _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
-    }
-
-    inline void InitAsConstants(
-        UINT num32BitValues,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
-    }
-
-    inline void InitAsConstantBufferView(
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsConstantBufferView(*this, shaderRegister, registerSpace, visibility);
-    }
-
-    inline void InitAsShaderResourceView(
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsShaderResourceView(*this, shaderRegister, registerSpace, visibility);
-    }
-
-    inline void InitAsUnorderedAccessView(
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, visibility);
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_STATIC_SAMPLER_DESC : public D3D12_STATIC_SAMPLER_DESC
-{
-    CD3DX12_STATIC_SAMPLER_DESC() = default;
-    explicit CD3DX12_STATIC_SAMPLER_DESC(const D3D12_STATIC_SAMPLER_DESC &o) noexcept :
-        D3D12_STATIC_SAMPLER_DESC(o)
-    {}
-    CD3DX12_STATIC_SAMPLER_DESC(
-         UINT shaderRegister,
-         D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
-         D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
-         D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
-         D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
-         FLOAT mipLODBias = 0,
-         UINT maxAnisotropy = 16,
-         D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
-         D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
-         FLOAT minLOD = 0.f,
-         FLOAT maxLOD = D3D12_FLOAT32_MAX,
-         D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
-         UINT registerSpace = 0) noexcept
-    {
-        Init(
-            shaderRegister,
-            filter,
-            addressU,
-            addressV,
-            addressW,
-            mipLODBias,
-            maxAnisotropy,
-            comparisonFunc,
-            borderColor,
-            minLOD,
-            maxLOD,
-            shaderVisibility,
-            registerSpace);
-    }
-
-    static inline void Init(
-        _Out_ D3D12_STATIC_SAMPLER_DESC &samplerDesc,
-         UINT shaderRegister,
-         D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
-         D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
-         D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
-         D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
-         FLOAT mipLODBias = 0,
-         UINT maxAnisotropy = 16,
-         D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
-         D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
-         FLOAT minLOD = 0.f,
-         FLOAT maxLOD = D3D12_FLOAT32_MAX,
-         D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
-         UINT registerSpace = 0) noexcept
-    {
-        samplerDesc.ShaderRegister = shaderRegister;
-        samplerDesc.Filter = filter;
-        samplerDesc.AddressU = addressU;
-        samplerDesc.AddressV = addressV;
-        samplerDesc.AddressW = addressW;
-        samplerDesc.MipLODBias = mipLODBias;
-        samplerDesc.MaxAnisotropy = maxAnisotropy;
-        samplerDesc.ComparisonFunc = comparisonFunc;
-        samplerDesc.BorderColor = borderColor;
-        samplerDesc.MinLOD = minLOD;
-        samplerDesc.MaxLOD = maxLOD;
-        samplerDesc.ShaderVisibility = shaderVisibility;
-        samplerDesc.RegisterSpace = registerSpace;
-    }
-    inline void Init(
-         UINT shaderRegister,
-         D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
-         D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
-         D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
-         D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
-         FLOAT mipLODBias = 0,
-         UINT maxAnisotropy = 16,
-         D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
-         D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
-         FLOAT minLOD = 0.f,
-         FLOAT maxLOD = D3D12_FLOAT32_MAX,
-         D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
-         UINT registerSpace = 0) noexcept
-    {
-        Init(
-            *this,
-            shaderRegister,
-            filter,
-            addressU,
-            addressV,
-            addressW,
-            mipLODBias,
-            maxAnisotropy,
-            comparisonFunc,
-            borderColor,
-            minLOD,
-            maxLOD,
-            shaderVisibility,
-            registerSpace);
-    }
-
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_ROOT_SIGNATURE_DESC : public D3D12_ROOT_SIGNATURE_DESC
-{
-    CD3DX12_ROOT_SIGNATURE_DESC() = default;
-    explicit CD3DX12_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) noexcept :
-        D3D12_ROOT_SIGNATURE_DESC(o)
-    {}
-    CD3DX12_ROOT_SIGNATURE_DESC(
-        UINT numParameters,
-        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
-        UINT numStaticSamplers = 0,
-        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
-        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
-    {
-        Init(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
-    }
-    CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) noexcept
-    {
-        Init(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE);
-    }
-
-    inline void Init(
-        UINT numParameters,
-        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
-        UINT numStaticSamplers = 0,
-        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
-        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
-    {
-        Init(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
-    }
-
-    static inline void Init(
-        _Out_ D3D12_ROOT_SIGNATURE_DESC &desc,
-        UINT numParameters,
-        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
-        UINT numStaticSamplers = 0,
-        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
-        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
-    {
-        desc.NumParameters = numParameters;
-        desc.pParameters = _pParameters;
-        desc.NumStaticSamplers = numStaticSamplers;
-        desc.pStaticSamplers = _pStaticSamplers;
-        desc.Flags = flags;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_DESCRIPTOR_RANGE1 : public D3D12_DESCRIPTOR_RANGE1
-{
-    CD3DX12_DESCRIPTOR_RANGE1() = default;
-    explicit CD3DX12_DESCRIPTOR_RANGE1(const D3D12_DESCRIPTOR_RANGE1 &o) noexcept :
-        D3D12_DESCRIPTOR_RANGE1(o)
-    {}
-    CD3DX12_DESCRIPTOR_RANGE1(
-        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
-        UINT numDescriptors,
-        UINT baseShaderRegister,
-        UINT registerSpace = 0,
-        D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
-        UINT offsetInDescriptorsFromTableStart =
-        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
-    {
-        Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart);
-    }
-
-    inline void Init(
-        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
-        UINT numDescriptors,
-        UINT baseShaderRegister,
-        UINT registerSpace = 0,
-        D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
-        UINT offsetInDescriptorsFromTableStart =
-        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
-    {
-        Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart);
-    }
-
-    static inline void Init(
-        _Out_ D3D12_DESCRIPTOR_RANGE1 &range,
-        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
-        UINT numDescriptors,
-        UINT baseShaderRegister,
-        UINT registerSpace = 0,
-        D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
-        UINT offsetInDescriptorsFromTableStart =
-        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
-    {
-        range.RangeType = rangeType;
-        range.NumDescriptors = numDescriptors;
-        range.BaseShaderRegister = baseShaderRegister;
-        range.RegisterSpace = registerSpace;
-        range.Flags = flags;
-        range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_ROOT_DESCRIPTOR_TABLE1 : public D3D12_ROOT_DESCRIPTOR_TABLE1
-{
-    CD3DX12_ROOT_DESCRIPTOR_TABLE1() = default;
-    explicit CD3DX12_ROOT_DESCRIPTOR_TABLE1(const D3D12_ROOT_DESCRIPTOR_TABLE1 &o) noexcept :
-        D3D12_ROOT_DESCRIPTOR_TABLE1(o)
-    {}
-    CD3DX12_ROOT_DESCRIPTOR_TABLE1(
-        UINT numDescriptorRanges,
-        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
-    {
-        Init(numDescriptorRanges, _pDescriptorRanges);
-    }
-
-    inline void Init(
-        UINT numDescriptorRanges,
-        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
-    {
-        Init(*this, numDescriptorRanges, _pDescriptorRanges);
-    }
-
-    static inline void Init(
-        _Out_ D3D12_ROOT_DESCRIPTOR_TABLE1 &rootDescriptorTable,
-        UINT numDescriptorRanges,
-        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
-    {
-        rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
-        rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_ROOT_DESCRIPTOR1 : public D3D12_ROOT_DESCRIPTOR1
-{
-    CD3DX12_ROOT_DESCRIPTOR1() = default;
-    explicit CD3DX12_ROOT_DESCRIPTOR1(const D3D12_ROOT_DESCRIPTOR1 &o) noexcept :
-        D3D12_ROOT_DESCRIPTOR1(o)
-    {}
-    CD3DX12_ROOT_DESCRIPTOR1(
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
-    {
-        Init(shaderRegister, registerSpace, flags);
-    }
-
-    inline void Init(
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
-    {
-        Init(*this, shaderRegister, registerSpace, flags);
-    }
-
-    static inline void Init(
-        _Out_ D3D12_ROOT_DESCRIPTOR1 &table,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
-    {
-        table.ShaderRegister = shaderRegister;
-        table.RegisterSpace = registerSpace;
-        table.Flags = flags;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_ROOT_PARAMETER1 : public D3D12_ROOT_PARAMETER1
-{
-    CD3DX12_ROOT_PARAMETER1() = default;
-    explicit CD3DX12_ROOT_PARAMETER1(const D3D12_ROOT_PARAMETER1 &o) noexcept :
-        D3D12_ROOT_PARAMETER1(o)
-    {}
-
-    static inline void InitAsDescriptorTable(
-        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
-        UINT numDescriptorRanges,
-        _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_DESCRIPTOR_TABLE1::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
-    }
-
-    static inline void InitAsConstants(
-        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
-        UINT num32BitValues,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
-    }
-
-    static inline void InitAsConstantBufferView(
-        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
-    }
-
-    static inline void InitAsShaderResourceView(
-        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
-    }
-
-    static inline void InitAsUnorderedAccessView(
-        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
-        rootParam.ShaderVisibility = visibility;
-        CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
-    }
-
-    inline void InitAsDescriptorTable(
-        UINT numDescriptorRanges,
-        _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
-    }
-
-    inline void InitAsConstants(
-        UINT num32BitValues,
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
-    }
-
-    inline void InitAsConstantBufferView(
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsConstantBufferView(*this, shaderRegister, registerSpace, flags, visibility);
-    }
-
-    inline void InitAsShaderResourceView(
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsShaderResourceView(*this, shaderRegister, registerSpace, flags, visibility);
-    }
-
-    inline void InitAsUnorderedAccessView(
-        UINT shaderRegister,
-        UINT registerSpace = 0,
-        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
-        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
-    {
-        InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, flags, visibility);
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC : public D3D12_VERSIONED_ROOT_SIGNATURE_DESC
-{
-    CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC() = default;
-    explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC &o) noexcept :
-        D3D12_VERSIONED_ROOT_SIGNATURE_DESC(o)
-    {}
-    explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) noexcept
-    {
-        Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
-        Desc_1_0 = o;
-    }
-    explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC1 &o) noexcept
-    {
-        Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
-        Desc_1_1 = o;
-    }
-    CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
-        UINT numParameters,
-        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
-        UINT numStaticSamplers = 0,
-        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
-        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
-    {
-        Init_1_0(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
-    }
-    CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
-        UINT numParameters,
-        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
-        UINT numStaticSamplers = 0,
-        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
-        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
-    {
-        Init_1_1(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
-    }
-    CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) noexcept
-    {
-        Init_1_1(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE);
-    }
-
-    inline void Init_1_0(
-        UINT numParameters,
-        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
-        UINT numStaticSamplers = 0,
-        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
-        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
-    {
-        Init_1_0(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
-    }
-
-    static inline void Init_1_0(
-        _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc,
-        UINT numParameters,
-        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
-        UINT numStaticSamplers = 0,
-        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
-        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
-    {
-        desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
-        desc.Desc_1_0.NumParameters = numParameters;
-        desc.Desc_1_0.pParameters = _pParameters;
-        desc.Desc_1_0.NumStaticSamplers = numStaticSamplers;
-        desc.Desc_1_0.pStaticSamplers = _pStaticSamplers;
-        desc.Desc_1_0.Flags = flags;
-    }
-
-    inline void Init_1_1(
-        UINT numParameters,
-        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
-        UINT numStaticSamplers = 0,
-        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
-        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
-    {
-        Init_1_1(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
-    }
-
-    static inline void Init_1_1(
-        _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc,
-        UINT numParameters,
-        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
-        UINT numStaticSamplers = 0,
-        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
-        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
-    {
-        desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
-        desc.Desc_1_1.NumParameters = numParameters;
-        desc.Desc_1_1.pParameters = _pParameters;
-        desc.Desc_1_1.NumStaticSamplers = numStaticSamplers;
-        desc.Desc_1_1.pStaticSamplers = _pStaticSamplers;
-        desc.Desc_1_1.Flags = flags;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_CPU_DESCRIPTOR_HANDLE : public D3D12_CPU_DESCRIPTOR_HANDLE
-{
-    CD3DX12_CPU_DESCRIPTOR_HANDLE() = default;
-    explicit CD3DX12_CPU_DESCRIPTOR_HANDLE(const D3D12_CPU_DESCRIPTOR_HANDLE &o) noexcept :
-        D3D12_CPU_DESCRIPTOR_HANDLE(o)
-    {}
-    CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) noexcept { ptr = 0; }
-    CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) noexcept
-    {
-        InitOffsetted(other, offsetScaledByIncrementSize);
-    }
-    CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
-    {
-        InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
-    }
-    CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
-    {
-        ptr = SIZE_T(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
-        return *this;
-    }
-    CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) noexcept
-    {
-        ptr = SIZE_T(INT64(ptr) + INT64(offsetScaledByIncrementSize));
-        return *this;
-    }
-    bool operator==(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const noexcept
-    {
-        return (ptr == other.ptr);
-    }
-    bool operator!=(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const noexcept
-    {
-        return (ptr != other.ptr);
-    }
-    CD3DX12_CPU_DESCRIPTOR_HANDLE &operator=(const D3D12_CPU_DESCRIPTOR_HANDLE &other) noexcept
-    {
-        ptr = other.ptr;
-        return *this;
-    }
-
-    inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
-    {
-        InitOffsetted(*this, base, offsetScaledByIncrementSize);
-    }
-
-    inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
-    {
-        InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
-    }
-
-    static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
-    {
-        handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
-    }
-
-    static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
-    {
-        handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_GPU_DESCRIPTOR_HANDLE : public D3D12_GPU_DESCRIPTOR_HANDLE
-{
-    CD3DX12_GPU_DESCRIPTOR_HANDLE() = default;
-    explicit CD3DX12_GPU_DESCRIPTOR_HANDLE(const D3D12_GPU_DESCRIPTOR_HANDLE &o) noexcept :
-        D3D12_GPU_DESCRIPTOR_HANDLE(o)
-    {}
-    CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) noexcept { ptr = 0; }
-    CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) noexcept
-    {
-        InitOffsetted(other, offsetScaledByIncrementSize);
-    }
-    CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
-    {
-        InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
-    }
-    CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
-    {
-        ptr = UINT64(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
-        return *this;
-    }
-    CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) noexcept
-    {
-        ptr = UINT64(INT64(ptr) + INT64(offsetScaledByIncrementSize));
-        return *this;
-    }
-    inline bool operator==(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const noexcept
-    {
-        return (ptr == other.ptr);
-    }
-    inline bool operator!=(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const noexcept
-    {
-        return (ptr != other.ptr);
-    }
-    CD3DX12_GPU_DESCRIPTOR_HANDLE &operator=(const D3D12_GPU_DESCRIPTOR_HANDLE &other) noexcept
-    {
-        ptr = other.ptr;
-        return *this;
-    }
-
-    inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
-    {
-        InitOffsetted(*this, base, offsetScaledByIncrementSize);
-    }
-
-    inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
-    {
-        InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
-    }
-
-    static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
-    {
-        handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
-    }
-
-    static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
-    {
-        handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-constexpr UINT D3D12CalcSubresource( UINT MipSlice, UINT ArraySlice, UINT PlaneSlice, UINT MipLevels, UINT ArraySize ) noexcept
-{
-    return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize;
-}
-
-//------------------------------------------------------------------------------------------------
-template <typename T, typename U, typename V>
-inline void D3D12DecomposeSubresource( UINT Subresource, UINT MipLevels, UINT ArraySize, _Out_ T& MipSlice, _Out_ U& ArraySlice, _Out_ V& PlaneSlice ) noexcept
-{
-    MipSlice = static_cast<T>(Subresource % MipLevels);
-    ArraySlice = static_cast<U>((Subresource / MipLevels) % ArraySize);
-    PlaneSlice = static_cast<V>(Subresource / (MipLevels * ArraySize));
-}
-
-//------------------------------------------------------------------------------------------------
-inline UINT8 D3D12GetFormatPlaneCount(
-    _In_ ID3D12Device* pDevice,
-    DXGI_FORMAT Format
-    ) noexcept
-{
-    D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = { Format, 0 };
-    if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &formatInfo, sizeof(formatInfo))))
-    {
-        return 0;
-    }
-    return formatInfo.PlaneCount;
-}
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC
-{
-    CD3DX12_RESOURCE_DESC() = default;
-    explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) noexcept :
-        D3D12_RESOURCE_DESC( o )
-    {}
-    CD3DX12_RESOURCE_DESC(
-        D3D12_RESOURCE_DIMENSION dimension,
-        UINT64 alignment,
-        UINT64 width,
-        UINT height,
-        UINT16 depthOrArraySize,
-        UINT16 mipLevels,
-        DXGI_FORMAT format,
-        UINT sampleCount,
-        UINT sampleQuality,
-        D3D12_TEXTURE_LAYOUT layout,
-        D3D12_RESOURCE_FLAGS flags ) noexcept
-    {
-        Dimension = dimension;
-        Alignment = alignment;
-        Width = width;
-        Height = height;
-        DepthOrArraySize = depthOrArraySize;
-        MipLevels = mipLevels;
-        Format = format;
-        SampleDesc.Count = sampleCount;
-        SampleDesc.Quality = sampleQuality;
-        Layout = layout;
-        Flags = flags;
-    }
-    static inline CD3DX12_RESOURCE_DESC Buffer(
-        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
-            1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
-    }
-    static inline CD3DX12_RESOURCE_DESC Buffer(
-        UINT64 width,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
-        UINT64 alignment = 0 ) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
-            DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
-    }
-    static inline CD3DX12_RESOURCE_DESC Tex1D(
-        DXGI_FORMAT format,
-        UINT64 width,
-        UINT16 arraySize = 1,
-        UINT16 mipLevels = 0,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
-        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
-        UINT64 alignment = 0 ) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
-            mipLevels, format, 1, 0, layout, flags );
-    }
-    static inline CD3DX12_RESOURCE_DESC Tex2D(
-        DXGI_FORMAT format,
-        UINT64 width,
-        UINT height,
-        UINT16 arraySize = 1,
-        UINT16 mipLevels = 0,
-        UINT sampleCount = 1,
-        UINT sampleQuality = 0,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
-        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
-        UINT64 alignment = 0 ) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
-            mipLevels, format, sampleCount, sampleQuality, layout, flags );
-    }
-    static inline CD3DX12_RESOURCE_DESC Tex3D(
-        DXGI_FORMAT format,
-        UINT64 width,
-        UINT height,
-        UINT16 depth,
-        UINT16 mipLevels = 0,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
-        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
-        UINT64 alignment = 0 ) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
-            mipLevels, format, 1, 0, layout, flags );
-    }
-    inline UINT16 Depth() const noexcept
-    { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
-    inline UINT16 ArraySize() const noexcept
-    { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
-    inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
-    { return D3D12GetFormatPlaneCount(pDevice, Format); }
-    inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
-    { return static_cast<UINT>(MipLevels) * ArraySize() * PlaneCount(pDevice); }
-    inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
-    { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
-};
-inline bool operator==( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) noexcept
-{
-    return l.Dimension == r.Dimension &&
-        l.Alignment == r.Alignment &&
-        l.Width == r.Width &&
-        l.Height == r.Height &&
-        l.DepthOrArraySize == r.DepthOrArraySize &&
-        l.MipLevels == r.MipLevels &&
-        l.Format == r.Format &&
-        l.SampleDesc.Count == r.SampleDesc.Count &&
-        l.SampleDesc.Quality == r.SampleDesc.Quality &&
-        l.Layout == r.Layout &&
-        l.Flags == r.Flags;
-}
-inline bool operator!=( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) noexcept
-{ return !( l == r ); }
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_RESOURCE_DESC1 : public D3D12_RESOURCE_DESC1
-{
-    CD3DX12_RESOURCE_DESC1() = default;
-    explicit CD3DX12_RESOURCE_DESC1( const D3D12_RESOURCE_DESC1& o ) noexcept :
-        D3D12_RESOURCE_DESC1( o )
-    {}
-    explicit CD3DX12_RESOURCE_DESC1( const D3D12_RESOURCE_DESC& o ) noexcept
-    {
-        Dimension = o.Dimension;
-        Alignment = o.Alignment;
-        Width = o.Width;
-        Height = o.Height;
-        DepthOrArraySize = o.DepthOrArraySize;
-        MipLevels = o.MipLevels;
-        Format = o.Format;
-        SampleDesc = o.SampleDesc;
-        Layout = o.Layout;
-        Flags = o.Flags;
-        SamplerFeedbackMipRegion = {};
-    }
-    CD3DX12_RESOURCE_DESC1(
-        D3D12_RESOURCE_DIMENSION dimension,
-        UINT64 alignment,
-        UINT64 width,
-        UINT height,
-        UINT16 depthOrArraySize,
-        UINT16 mipLevels,
-        DXGI_FORMAT format,
-        UINT sampleCount,
-        UINT sampleQuality,
-        D3D12_TEXTURE_LAYOUT layout,
-        D3D12_RESOURCE_FLAGS flags,
-        UINT samplerFeedbackMipRegionWidth = 0,
-        UINT samplerFeedbackMipRegionHeight = 0,
-        UINT samplerFeedbackMipRegionDepth = 0) noexcept
-    {
-        Dimension = dimension;
-        Alignment = alignment;
-        Width = width;
-        Height = height;
-        DepthOrArraySize = depthOrArraySize;
-        MipLevels = mipLevels;
-        Format = format;
-        SampleDesc.Count = sampleCount;
-        SampleDesc.Quality = sampleQuality;
-        Layout = layout;
-        Flags = flags;
-        SamplerFeedbackMipRegion.Width = samplerFeedbackMipRegionWidth;
-        SamplerFeedbackMipRegion.Height = samplerFeedbackMipRegionHeight;
-        SamplerFeedbackMipRegion.Depth = samplerFeedbackMipRegionDepth;
-    }
-    static inline CD3DX12_RESOURCE_DESC1 Buffer(
-        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
-            1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags, 0, 0, 0 );
-    }
-    static inline CD3DX12_RESOURCE_DESC1 Buffer(
-        UINT64 width,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
-        UINT64 alignment = 0 ) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
-            DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags, 0, 0, 0 );
-    }
-    static inline CD3DX12_RESOURCE_DESC1 Tex1D(
-        DXGI_FORMAT format,
-        UINT64 width,
-        UINT16 arraySize = 1,
-        UINT16 mipLevels = 0,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
-        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
-        UINT64 alignment = 0 ) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
-            mipLevels, format, 1, 0, layout, flags, 0, 0, 0 );
-    }
-    static inline CD3DX12_RESOURCE_DESC1 Tex2D(
-        DXGI_FORMAT format,
-        UINT64 width,
-        UINT height,
-        UINT16 arraySize = 1,
-        UINT16 mipLevels = 0,
-        UINT sampleCount = 1,
-        UINT sampleQuality = 0,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
-        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
-        UINT64 alignment = 0,
-        UINT samplerFeedbackMipRegionWidth = 0,
-        UINT samplerFeedbackMipRegionHeight = 0,
-        UINT samplerFeedbackMipRegionDepth = 0) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
-            mipLevels, format, sampleCount, sampleQuality, layout, flags, samplerFeedbackMipRegionWidth,
-            samplerFeedbackMipRegionHeight, samplerFeedbackMipRegionDepth );
-    }
-    static inline CD3DX12_RESOURCE_DESC1 Tex3D(
-        DXGI_FORMAT format,
-        UINT64 width,
-        UINT height,
-        UINT16 depth,
-        UINT16 mipLevels = 0,
-        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
-        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
-        UINT64 alignment = 0 ) noexcept
-    {
-        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
-            mipLevels, format, 1, 0, layout, flags, 0, 0, 0 );
-    }
-    inline UINT16 Depth() const noexcept
-    { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
-    inline UINT16 ArraySize() const noexcept
-    { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
-    inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
-    { return D3D12GetFormatPlaneCount(pDevice, Format); }
-    inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
-    { return static_cast<UINT>(MipLevels) * ArraySize() * PlaneCount(pDevice); }
-    inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
-    { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
-};
-inline bool operator==( const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r ) noexcept
-{
-    return l.Dimension == r.Dimension &&
-        l.Alignment == r.Alignment &&
-        l.Width == r.Width &&
-        l.Height == r.Height &&
-        l.DepthOrArraySize == r.DepthOrArraySize &&
-        l.MipLevels == r.MipLevels &&
-        l.Format == r.Format &&
-        l.SampleDesc.Count == r.SampleDesc.Count &&
-        l.SampleDesc.Quality == r.SampleDesc.Quality &&
-        l.Layout == r.Layout &&
-        l.Flags == r.Flags &&
-        l.SamplerFeedbackMipRegion.Width == r.SamplerFeedbackMipRegion.Width &&
-        l.SamplerFeedbackMipRegion.Height == r.SamplerFeedbackMipRegion.Height &&
-        l.SamplerFeedbackMipRegion.Depth == r.SamplerFeedbackMipRegion.Depth;
-}
-inline bool operator!=( const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r ) noexcept
-{ return !( l == r ); }
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_VIEW_INSTANCING_DESC : public D3D12_VIEW_INSTANCING_DESC
-{
-    CD3DX12_VIEW_INSTANCING_DESC() = default;
-    explicit CD3DX12_VIEW_INSTANCING_DESC( const D3D12_VIEW_INSTANCING_DESC& o ) noexcept :
-        D3D12_VIEW_INSTANCING_DESC( o )
-    {}
-    explicit CD3DX12_VIEW_INSTANCING_DESC( CD3DX12_DEFAULT ) noexcept
-    {
-        ViewInstanceCount = 0;
-        pViewInstanceLocations = nullptr;
-        Flags = D3D12_VIEW_INSTANCING_FLAG_NONE;
-    }
-    explicit CD3DX12_VIEW_INSTANCING_DESC(
-        UINT InViewInstanceCount,
-        const D3D12_VIEW_INSTANCE_LOCATION* InViewInstanceLocations,
-        D3D12_VIEW_INSTANCING_FLAGS InFlags) noexcept
-    {
-        ViewInstanceCount = InViewInstanceCount;
-        pViewInstanceLocations = InViewInstanceLocations;
-        Flags = InFlags;
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-// Row-by-row memcpy
-inline void MemcpySubresource(
-    _In_ const D3D12_MEMCPY_DEST* pDest,
-    _In_ const D3D12_SUBRESOURCE_DATA* pSrc,
-    SIZE_T RowSizeInBytes,
-    UINT NumRows,
-    UINT NumSlices) noexcept
-{
-    for (UINT z = 0; z < NumSlices; ++z)
-    {
-        auto pDestSlice = static_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
-        auto pSrcSlice = static_cast<const BYTE*>(pSrc->pData) + pSrc->SlicePitch * LONG_PTR(z);
-        for (UINT y = 0; y < NumRows; ++y)
-        {
-            memcpy(pDestSlice + pDest->RowPitch * y,
-                   pSrcSlice + pSrc->RowPitch * LONG_PTR(y),
-                   RowSizeInBytes);
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-// Row-by-row memcpy
-inline void MemcpySubresource(
-    _In_ const D3D12_MEMCPY_DEST* pDest,
-    _In_ const void* pResourceData,
-    _In_ const D3D12_SUBRESOURCE_INFO* pSrc,
-    SIZE_T RowSizeInBytes,
-    UINT NumRows,
-    UINT NumSlices) noexcept
-{
-    for (UINT z = 0; z < NumSlices; ++z)
-    {
-        auto pDestSlice = static_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
-        auto pSrcSlice = (static_cast<const BYTE*>(pResourceData) + pSrc->Offset) + pSrc->DepthPitch * ULONG_PTR(z);
-        for (UINT y = 0; y < NumRows; ++y)
-        {
-            memcpy(pDestSlice + pDest->RowPitch * y,
-                pSrcSlice + pSrc->RowPitch * ULONG_PTR(y),
-                RowSizeInBytes);
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-// Returns required size of a buffer to be used for data upload
-inline UINT64 GetRequiredIntermediateSize(
-    _In_ ID3D12Resource* pDestinationResource,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources) noexcept
-{
-#if defined(_MSC_VER) || !defined(_WIN32)
-    const auto Desc = pDestinationResource->GetDesc();
-#else
-    D3D12_RESOURCE_DESC tmpDesc;
-    const auto& Desc = *pDestinationResource->GetDesc(&tmpDesc);
-#endif
-    UINT64 RequiredSize = 0;
-
-    ID3D12Device* pDevice = nullptr;
-    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
-    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, 0, nullptr, nullptr, nullptr, &RequiredSize);
-    pDevice->Release();
-
-    return RequiredSize;
-}
-
-//------------------------------------------------------------------------------------------------
-// All arrays must be populated (e.g. by calling GetCopyableFootprints)
-inline UINT64 UpdateSubresources(
-    _In_ ID3D12GraphicsCommandList* pCmdList,
-    _In_ ID3D12Resource* pDestinationResource,
-    _In_ ID3D12Resource* pIntermediate,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
-    UINT64 RequiredSize,
-    _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts,
-    _In_reads_(NumSubresources) const UINT* pNumRows,
-    _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes,
-    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
-{
-    // Minor validation
-#if defined(_MSC_VER) || !defined(_WIN32)
-    const auto IntermediateDesc = pIntermediate->GetDesc();
-    const auto DestinationDesc = pDestinationResource->GetDesc();
-#else
-    D3D12_RESOURCE_DESC tmpDesc1, tmpDesc2;
-    const auto& IntermediateDesc = *pIntermediate->GetDesc(&tmpDesc1);
-    const auto& DestinationDesc = *pDestinationResource->GetDesc(&tmpDesc2);
-#endif
-    if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER ||
-        IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset ||
-        RequiredSize > SIZE_T(-1) ||
-        (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
-            (FirstSubresource != 0 || NumSubresources != 1)))
-    {
-        return 0;
-    }
-
-    BYTE* pData;
-    HRESULT hr = pIntermediate->Map(0, nullptr, reinterpret_cast<void**>(&pData));
-    if (FAILED(hr))
-    {
-        return 0;
-    }
-
-    for (UINT i = 0; i < NumSubresources; ++i)
-    {
-        if (pRowSizesInBytes[i] > SIZE_T(-1)) return 0;
-        D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, SIZE_T(pLayouts[i].Footprint.RowPitch) * SIZE_T(pNumRows[i]) };
-        MemcpySubresource(&DestData, &pSrcData[i], static_cast<SIZE_T>(pRowSizesInBytes[i]), pNumRows[i], pLayouts[i].Footprint.Depth);
-    }
-    pIntermediate->Unmap(0, nullptr);
-
-    if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
-    {
-        pCmdList->CopyBufferRegion(
-            pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width);
-    }
-    else
-    {
-        for (UINT i = 0; i < NumSubresources; ++i)
-        {
-            const CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource);
-            const CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
-            pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
-        }
-    }
-    return RequiredSize;
-}
-
-//------------------------------------------------------------------------------------------------
-// All arrays must be populated (e.g. by calling GetCopyableFootprints)
-inline UINT64 UpdateSubresources(
-    _In_ ID3D12GraphicsCommandList* pCmdList,
-    _In_ ID3D12Resource* pDestinationResource,
-    _In_ ID3D12Resource* pIntermediate,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
-    UINT64 RequiredSize,
-    _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts,
-    _In_reads_(NumSubresources) const UINT* pNumRows,
-    _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes,
-    _In_ const void* pResourceData,
-    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
-{
-    // Minor validation
-#if defined(_MSC_VER) || !defined(_WIN32)
-    const auto IntermediateDesc = pIntermediate->GetDesc();
-    const auto DestinationDesc = pDestinationResource->GetDesc();
-#else
-    D3D12_RESOURCE_DESC tmpDesc1, tmpDesc2;
-    const auto& IntermediateDesc = *pIntermediate->GetDesc(&tmpDesc1);
-    const auto& DestinationDesc = *pDestinationResource->GetDesc(&tmpDesc2);
-#endif
-    if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER ||
-        IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset ||
-        RequiredSize > SIZE_T(-1) ||
-        (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
-            (FirstSubresource != 0 || NumSubresources != 1)))
-    {
-        return 0;
-    }
-
-    BYTE* pData;
-    HRESULT hr = pIntermediate->Map(0, nullptr, reinterpret_cast<void**>(&pData));
-    if (FAILED(hr))
-    {
-        return 0;
-    }
-
-    for (UINT i = 0; i < NumSubresources; ++i)
-    {
-        if (pRowSizesInBytes[i] > SIZE_T(-1)) return 0;
-        D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, SIZE_T(pLayouts[i].Footprint.RowPitch) * SIZE_T(pNumRows[i]) };
-        MemcpySubresource(&DestData, pResourceData, &pSrcData[i], static_cast<SIZE_T>(pRowSizesInBytes[i]), pNumRows[i], pLayouts[i].Footprint.Depth);
-    }
-    pIntermediate->Unmap(0, nullptr);
-
-    if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
-    {
-        pCmdList->CopyBufferRegion(
-            pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width);
-    }
-    else
-    {
-        for (UINT i = 0; i < NumSubresources; ++i)
-        {
-            const CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource);
-            const CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
-            pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
-        }
-    }
-    return RequiredSize;
-}
-
-//------------------------------------------------------------------------------------------------
-// Heap-allocating UpdateSubresources implementation
-inline UINT64 UpdateSubresources(
-    _In_ ID3D12GraphicsCommandList* pCmdList,
-    _In_ ID3D12Resource* pDestinationResource,
-    _In_ ID3D12Resource* pIntermediate,
-    UINT64 IntermediateOffset,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
-    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
-{
-    UINT64 RequiredSize = 0;
-    const auto MemToAlloc = static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources;
-    if (MemToAlloc > SIZE_MAX)
-    {
-       return 0;
-    }
-    void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
-    if (pMem == nullptr)
-    {
-       return 0;
-    }
-    auto pLayouts = static_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
-    auto pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
-    auto pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
-
-#if defined(_MSC_VER) || !defined(_WIN32)
-    const auto Desc = pDestinationResource->GetDesc();
-#else
-    D3D12_RESOURCE_DESC tmpDesc;
-    const auto& Desc = *pDestinationResource->GetDesc(&tmpDesc);
-#endif
-    ID3D12Device* pDevice = nullptr;
-    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
-    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize);
-    pDevice->Release();
-
-    const UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pSrcData);
-    HeapFree(GetProcessHeap(), 0, pMem);
-    return Result;
-}
-
-//------------------------------------------------------------------------------------------------
-// Heap-allocating UpdateSubresources implementation
-inline UINT64 UpdateSubresources(
-    _In_ ID3D12GraphicsCommandList* pCmdList,
-    _In_ ID3D12Resource* pDestinationResource,
-    _In_ ID3D12Resource* pIntermediate,
-    UINT64 IntermediateOffset,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
-    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
-    _In_ const void* pResourceData,
-    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
-{
-    UINT64 RequiredSize = 0;
-    const auto MemToAlloc = static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources;
-    if (MemToAlloc > SIZE_MAX)
-    {
-        return 0;
-    }
-    void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
-    if (pMem == nullptr)
-    {
-        return 0;
-    }
-    auto pLayouts = static_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
-    auto pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
-    auto pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
-
-#if defined(_MSC_VER) || !defined(_WIN32)
-    const auto Desc = pDestinationResource->GetDesc();
-#else
-    D3D12_RESOURCE_DESC tmpDesc;
-    const auto& Desc = *pDestinationResource->GetDesc(&tmpDesc);
-#endif
-    ID3D12Device* pDevice = nullptr;
-    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
-    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize);
-    pDevice->Release();
-
-    const UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pResourceData, pSrcData);
-    HeapFree(GetProcessHeap(), 0, pMem);
-    return Result;
-}
-
-//------------------------------------------------------------------------------------------------
-// Stack-allocating UpdateSubresources implementation
-template <UINT MaxSubresources>
-inline UINT64 UpdateSubresources(
-    _In_ ID3D12GraphicsCommandList* pCmdList,
-    _In_ ID3D12Resource* pDestinationResource,
-    _In_ ID3D12Resource* pIntermediate,
-    UINT64 IntermediateOffset,
-    _In_range_(0,MaxSubresources) UINT FirstSubresource,
-    _In_range_(1,MaxSubresources-FirstSubresource) UINT NumSubresources,
-    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
-{
-    UINT64 RequiredSize = 0;
-    D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
-    UINT NumRows[MaxSubresources];
-    UINT64 RowSizesInBytes[MaxSubresources];
-
-#if defined(_MSC_VER) || !defined(_WIN32)
-    const auto Desc = pDestinationResource->GetDesc();
-#else
-    D3D12_RESOURCE_DESC tmpDesc;
-    const auto& Desc = *pDestinationResource->GetDesc(&tmpDesc);
-#endif
-    ID3D12Device* pDevice = nullptr;
-    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
-    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize);
-    pDevice->Release();
-
-    return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pSrcData);
-}
-
-//------------------------------------------------------------------------------------------------
-// Stack-allocating UpdateSubresources implementation
-template <UINT MaxSubresources>
-inline UINT64 UpdateSubresources(
-    _In_ ID3D12GraphicsCommandList* pCmdList,
-    _In_ ID3D12Resource* pDestinationResource,
-    _In_ ID3D12Resource* pIntermediate,
-    UINT64 IntermediateOffset,
-    _In_range_(0,MaxSubresources) UINT FirstSubresource,
-    _In_range_(1,MaxSubresources-FirstSubresource) UINT NumSubresources,
-    _In_ const void* pResourceData,
-    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
-{
-    UINT64 RequiredSize = 0;
-    D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
-    UINT NumRows[MaxSubresources];
-    UINT64 RowSizesInBytes[MaxSubresources];
-
-#if defined(_MSC_VER) || !defined(_WIN32)
-    const auto Desc = pDestinationResource->GetDesc();
-#else
-    D3D12_RESOURCE_DESC tmpDesc;
-    const auto& Desc = *pDestinationResource->GetDesc(&tmpDesc);
-#endif
-    ID3D12Device* pDevice = nullptr;
-    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
-    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize);
-    pDevice->Release();
-
-    return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pResourceData, pSrcData);
-}
-
-//------------------------------------------------------------------------------------------------
-constexpr bool D3D12IsLayoutOpaque( D3D12_TEXTURE_LAYOUT Layout ) noexcept
-{ return Layout == D3D12_TEXTURE_LAYOUT_UNKNOWN || Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE; }
-
-//------------------------------------------------------------------------------------------------
-template <typename t_CommandListType>
-inline ID3D12CommandList * const * CommandListCast(t_CommandListType * const * pp) noexcept
-{
-    // This cast is useful for passing strongly typed command list pointers into
-    // ExecuteCommandLists.
-    // This cast is valid as long as the const-ness is respected. D3D12 APIs do
-    // respect the const-ness of their arguments.
-    return reinterpret_cast<ID3D12CommandList * const *>(pp);
-}
-
-//------------------------------------------------------------------------------------------------
-// D3D12 exports a new method for serializing root signatures in the Windows 10 Anniversary Update.
-// To help enable root signature 1.1 features when they are available and not require maintaining
-// two code paths for building root signatures, this helper method reconstructs a 1.0 signature when
-// 1.1 is not supported.
-inline HRESULT D3DX12SerializeVersionedRootSignature(
-    _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignatureDesc,
-    D3D_ROOT_SIGNATURE_VERSION MaxVersion,
-    _Outptr_ ID3DBlob** ppBlob,
-    _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob) noexcept
-{
-    if (ppErrorBlob != nullptr)
-    {
-        *ppErrorBlob = nullptr;
-    }
-
-    switch (MaxVersion)
-    {
-        case D3D_ROOT_SIGNATURE_VERSION_1_0:
-            switch (pRootSignatureDesc->Version)
-            {
-                case D3D_ROOT_SIGNATURE_VERSION_1_0:
-                    return D3D12SerializeRootSignature(&pRootSignatureDesc->Desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob);
-
-                case D3D_ROOT_SIGNATURE_VERSION_1_1:
-                {
-                    HRESULT hr = S_OK;
-                    const D3D12_ROOT_SIGNATURE_DESC1& desc_1_1 = pRootSignatureDesc->Desc_1_1;
-
-                    const SIZE_T ParametersSize = sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters;
-                    void* pParameters = (ParametersSize > 0) ? HeapAlloc(GetProcessHeap(), 0, ParametersSize) : nullptr;
-                    if (ParametersSize > 0 && pParameters == nullptr)
-                    {
-                        hr = E_OUTOFMEMORY;
-                    }
-                    auto pParameters_1_0 = static_cast<D3D12_ROOT_PARAMETER*>(pParameters);
-
-                    if (SUCCEEDED(hr))
-                    {
-                        for (UINT n = 0; n < desc_1_1.NumParameters; n++)
-                        {
-                            __analysis_assume(ParametersSize == sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters);
-                            pParameters_1_0[n].ParameterType = desc_1_1.pParameters[n].ParameterType;
-                            pParameters_1_0[n].ShaderVisibility = desc_1_1.pParameters[n].ShaderVisibility;
-
-                            switch (desc_1_1.pParameters[n].ParameterType)
-                            {
-                            case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
-                                pParameters_1_0[n].Constants.Num32BitValues = desc_1_1.pParameters[n].Constants.Num32BitValues;
-                                pParameters_1_0[n].Constants.RegisterSpace = desc_1_1.pParameters[n].Constants.RegisterSpace;
-                                pParameters_1_0[n].Constants.ShaderRegister = desc_1_1.pParameters[n].Constants.ShaderRegister;
-                                break;
-
-                            case D3D12_ROOT_PARAMETER_TYPE_CBV:
-                            case D3D12_ROOT_PARAMETER_TYPE_SRV:
-                            case D3D12_ROOT_PARAMETER_TYPE_UAV:
-                                pParameters_1_0[n].Descriptor.RegisterSpace = desc_1_1.pParameters[n].Descriptor.RegisterSpace;
-                                pParameters_1_0[n].Descriptor.ShaderRegister = desc_1_1.pParameters[n].Descriptor.ShaderRegister;
-                                break;
-
-                            case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
-                                const D3D12_ROOT_DESCRIPTOR_TABLE1& table_1_1 = desc_1_1.pParameters[n].DescriptorTable;
-
-                                const SIZE_T DescriptorRangesSize = sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges;
-                                void* pDescriptorRanges = (DescriptorRangesSize > 0 && SUCCEEDED(hr)) ? HeapAlloc(GetProcessHeap(), 0, DescriptorRangesSize) : nullptr;
-                                if (DescriptorRangesSize > 0 && pDescriptorRanges == nullptr)
-                                {
-                                    hr = E_OUTOFMEMORY;
-                                }
-                                auto pDescriptorRanges_1_0 = static_cast<D3D12_DESCRIPTOR_RANGE*>(pDescriptorRanges);
-
-                                if (SUCCEEDED(hr))
-                                {
-                                    for (UINT x = 0; x < table_1_1.NumDescriptorRanges; x++)
-                                    {
-                                        __analysis_assume(DescriptorRangesSize == sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges);
-                                        pDescriptorRanges_1_0[x].BaseShaderRegister = table_1_1.pDescriptorRanges[x].BaseShaderRegister;
-                                        pDescriptorRanges_1_0[x].NumDescriptors = table_1_1.pDescriptorRanges[x].NumDescriptors;
-                                        pDescriptorRanges_1_0[x].OffsetInDescriptorsFromTableStart = table_1_1.pDescriptorRanges[x].OffsetInDescriptorsFromTableStart;
-                                        pDescriptorRanges_1_0[x].RangeType = table_1_1.pDescriptorRanges[x].RangeType;
-                                        pDescriptorRanges_1_0[x].RegisterSpace = table_1_1.pDescriptorRanges[x].RegisterSpace;
-                                    }
-                                }
-
-                                D3D12_ROOT_DESCRIPTOR_TABLE& table_1_0 = pParameters_1_0[n].DescriptorTable;
-                                table_1_0.NumDescriptorRanges = table_1_1.NumDescriptorRanges;
-                                table_1_0.pDescriptorRanges = pDescriptorRanges_1_0;
-                            }
-                        }
-                    }
-
-                    if (SUCCEEDED(hr))
-                    {
-                        const CD3DX12_ROOT_SIGNATURE_DESC desc_1_0(desc_1_1.NumParameters, pParameters_1_0, desc_1_1.NumStaticSamplers, desc_1_1.pStaticSamplers, desc_1_1.Flags);
-                        hr = D3D12SerializeRootSignature(&desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob);
-                    }
-
-                    if (pParameters)
-                    {
-                        for (UINT n = 0; n < desc_1_1.NumParameters; n++)
-                        {
-                            if (desc_1_1.pParameters[n].ParameterType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
-                            {
-                                auto pDescriptorRanges_1_0 = pParameters_1_0[n].DescriptorTable.pDescriptorRanges;
-                                HeapFree(GetProcessHeap(), 0, reinterpret_cast<void*>(const_cast<D3D12_DESCRIPTOR_RANGE*>(pDescriptorRanges_1_0)));
-                            }
-                        }
-                        HeapFree(GetProcessHeap(), 0, pParameters);
-                    }
-                    return hr;
-                }
-            }
-            break;
-
-        case D3D_ROOT_SIGNATURE_VERSION_1_1:
-            return D3D12SerializeVersionedRootSignature(pRootSignatureDesc, ppBlob, ppErrorBlob);
-    }
-
-    return E_INVALIDARG;
-}
-
-//------------------------------------------------------------------------------------------------
-struct CD3DX12_RT_FORMAT_ARRAY : public D3D12_RT_FORMAT_ARRAY
-{
-    CD3DX12_RT_FORMAT_ARRAY() = default;
-    explicit CD3DX12_RT_FORMAT_ARRAY(const D3D12_RT_FORMAT_ARRAY& o) noexcept
-        : D3D12_RT_FORMAT_ARRAY(o)
-    {}
-    explicit CD3DX12_RT_FORMAT_ARRAY(_In_reads_(NumFormats) const DXGI_FORMAT* pFormats, UINT NumFormats) noexcept
-    {
-        NumRenderTargets = NumFormats;
-        memcpy(RTFormats, pFormats, sizeof(RTFormats));
-        // assumes ARRAY_SIZE(pFormats) == ARRAY_SIZE(RTFormats)
-    }
-};
-
-//------------------------------------------------------------------------------------------------
-// Pipeline State Stream Helpers
-//------------------------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------------------------
-// Stream Subobjects, i.e. elements of a stream
-
-struct DefaultSampleMask { operator UINT() noexcept { return UINT_MAX; } };
-struct DefaultSampleDesc { operator DXGI_SAMPLE_DESC() noexcept { return DXGI_SAMPLE_DESC{1, 0}; } };
-
-#pragma warning(push)
-#pragma warning(disable : 4324)
-template <typename InnerStructType, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE Type, typename DefaultArg = InnerStructType>
-class alignas(void*) CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT
-{
-private:
-    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE pssType;
-    InnerStructType pssInner;
-public:
-    CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT() noexcept : pssType(Type), pssInner(DefaultArg()) {}
-    CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const& i) noexcept : pssType(Type), pssInner(i) {}
-    CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(InnerStructType const& i) noexcept { pssType = Type; pssInner = i; return *this; }
-    operator InnerStructType const&() const noexcept { return pssInner; }
-    operator InnerStructType&() noexcept { return pssInner; }
-    InnerStructType* operator&() noexcept { return &pssInner; }
-    InnerStructType const* operator&() const noexcept { return &pssInner; }
-};
-#pragma warning(pop)
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PIPELINE_STATE_FLAGS,         D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS>                             CD3DX12_PIPELINE_STATE_STREAM_FLAGS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT,                               D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK>                         CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< ID3D12RootSignature*,               D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE>                    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INPUT_LAYOUT_DESC,            D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT>                      CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INDEX_BUFFER_STRIP_CUT_VALUE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE>                CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PRIMITIVE_TOPOLOGY_TYPE,      D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY>                CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS>                                CD3DX12_PIPELINE_STATE_STREAM_VS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS>                                CD3DX12_PIPELINE_STATE_STREAM_GS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_STREAM_OUTPUT_DESC,           D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT>                     CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS>                                CD3DX12_PIPELINE_STATE_STREAM_HS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS>                                CD3DX12_PIPELINE_STATE_STREAM_DS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS>                                CD3DX12_PIPELINE_STATE_STREAM_PS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS>                                CD3DX12_PIPELINE_STATE_STREAM_AS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS>                                CD3DX12_PIPELINE_STATE_STREAM_MS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS>                                CD3DX12_PIPELINE_STATE_STREAM_CS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_BLEND_DESC,                 D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND,          CD3DX12_DEFAULT>   CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC,         D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL,  CD3DX12_DEFAULT>   CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC1,        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1, CD3DX12_DEFAULT>   CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_FORMAT,                        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT>              CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_RASTERIZER_DESC,            D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER,     CD3DX12_DEFAULT>   CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_RT_FORMAT_ARRAY,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS>             CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_SAMPLE_DESC,                   D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC,    DefaultSampleDesc> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT,                               D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK,    DefaultSampleMask> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_CACHED_PIPELINE_STATE,        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO>                        CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO;
-typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_VIEW_INSTANCING_DESC,       D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING, CD3DX12_DEFAULT>  CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING;
-
-//------------------------------------------------------------------------------------------------
-// Stream Parser Helpers
-
-struct ID3DX12PipelineParserCallbacks
-{
-    // Subobject Callbacks
-    virtual void FlagsCb(D3D12_PIPELINE_STATE_FLAGS) {}
-    virtual void NodeMaskCb(UINT) {}
-    virtual void RootSignatureCb(ID3D12RootSignature*) {}
-    virtual void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC&) {}
-    virtual void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE) {}
-    virtual void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE) {}
-    virtual void VSCb(const D3D12_SHADER_BYTECODE&) {}
-    virtual void GSCb(const D3D12_SHADER_BYTECODE&) {}
-    virtual void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC&) {}
-    virtual void HSCb(const D3D12_SHADER_BYTECODE&) {}
-    virtual void DSCb(const D3D12_SHADER_BYTECODE&) {}
-    virtual void PSCb(const D3D12_SHADER_BYTECODE&) {}
-    virtual void CSCb(const D3D12_SHADER_BYTECODE&) {}
-    virtual void ASCb(const D3D12_SHADER_BYTECODE&) {}
-    virtual void MSCb(const D3D12_SHADER_BYTECODE&) {}
-    virtual void BlendStateCb(const D3D12_BLEND_DESC&) {}
-    virtual void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC&) {}
-    virtual void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1&) {}
-    virtual void DSVFormatCb(DXGI_FORMAT) {}
-    virtual void RasterizerStateCb(const D3D12_RASTERIZER_DESC&) {}
-    virtual void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY&) {}
-    virtual void SampleDescCb(const DXGI_SAMPLE_DESC&) {}
-    virtual void SampleMaskCb(UINT) {}
-    virtual void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC&) {}
-    virtual void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE&) {}
-
-    // Error Callbacks
-    virtual void ErrorBadInputParameter(UINT /*ParameterIndex*/) {}
-    virtual void ErrorDuplicateSubobject(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE /*DuplicateType*/) {}
-    virtual void ErrorUnknownSubobject(UINT /*UnknownTypeValue*/) {}
-
-    virtual ~ID3DX12PipelineParserCallbacks() = default;
-};
-
-struct D3DX12_MESH_SHADER_PIPELINE_STATE_DESC
-{
-    ID3D12RootSignature*          pRootSignature;
-    D3D12_SHADER_BYTECODE         AS;
-    D3D12_SHADER_BYTECODE         MS;
-    D3D12_SHADER_BYTECODE         PS;
-    D3D12_BLEND_DESC              BlendState;
-    UINT                          SampleMask;
-    D3D12_RASTERIZER_DESC         RasterizerState;
-    D3D12_DEPTH_STENCIL_DESC      DepthStencilState;
-    D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType;
-    UINT                          NumRenderTargets;
-    DXGI_FORMAT                   RTVFormats[ D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT ];
-    DXGI_FORMAT                   DSVFormat;
-    DXGI_SAMPLE_DESC              SampleDesc;
-    UINT                          NodeMask;
-    D3D12_CACHED_PIPELINE_STATE   CachedPSO;
-    D3D12_PIPELINE_STATE_FLAGS    Flags;
-};
-
-// CD3DX12_PIPELINE_STATE_STREAM2 Works on OS Build 19041+ (where there is a new mesh shader pipeline).
-// Use CD3DX12_PIPELINE_STATE_STREAM1 for OS Build 16299+ (where there is a new view instancing subobject).
-// Use CD3DX12_PIPELINE_STATE_STREAM for OS Build 15063+ support.
-struct CD3DX12_PIPELINE_STATE_STREAM2
-{
-    CD3DX12_PIPELINE_STATE_STREAM2() = default;
-    // Mesh and amplification shaders must be set manually, since they do not have representation in D3D12_GRAPHICS_PIPELINE_STATE_DESC
-    CD3DX12_PIPELINE_STATE_STREAM2(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
-        : Flags(Desc.Flags)
-        , NodeMask(Desc.NodeMask)
-        , pRootSignature(Desc.pRootSignature)
-        , InputLayout(Desc.InputLayout)
-        , IBStripCutValue(Desc.IBStripCutValue)
-        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
-        , VS(Desc.VS)
-        , GS(Desc.GS)
-        , StreamOutput(Desc.StreamOutput)
-        , HS(Desc.HS)
-        , DS(Desc.DS)
-        , PS(Desc.PS)
-        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
-        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
-        , DSVFormat(Desc.DSVFormat)
-        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
-        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
-        , SampleDesc(Desc.SampleDesc)
-        , SampleMask(Desc.SampleMask)
-        , CachedPSO(Desc.CachedPSO)
-        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
-    {}
-    CD3DX12_PIPELINE_STATE_STREAM2(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
-        : Flags(Desc.Flags)
-        , NodeMask(Desc.NodeMask)
-        , pRootSignature(Desc.pRootSignature)
-        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
-        , PS(Desc.PS)
-        , AS(Desc.AS)
-        , MS(Desc.MS)
-        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
-        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
-        , DSVFormat(Desc.DSVFormat)
-        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
-        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
-        , SampleDesc(Desc.SampleDesc)
-        , SampleMask(Desc.SampleMask)
-        , CachedPSO(Desc.CachedPSO)
-        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
-    {}
-    CD3DX12_PIPELINE_STATE_STREAM2(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
-        : Flags(Desc.Flags)
-        , NodeMask(Desc.NodeMask)
-        , pRootSignature(Desc.pRootSignature)
-        , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
-        , CachedPSO(Desc.CachedPSO)
-    {
-        static_cast<D3D12_DEPTH_STENCIL_DESC1&>(DepthStencilState).DepthEnable = false;
-    }
-    CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
-    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
-    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
-    CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
-    CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
-    CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
-    CD3DX12_PIPELINE_STATE_STREAM_VS VS;
-    CD3DX12_PIPELINE_STATE_STREAM_GS GS;
-    CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
-    CD3DX12_PIPELINE_STATE_STREAM_HS HS;
-    CD3DX12_PIPELINE_STATE_STREAM_DS DS;
-    CD3DX12_PIPELINE_STATE_STREAM_PS PS;
-    CD3DX12_PIPELINE_STATE_STREAM_AS AS;
-    CD3DX12_PIPELINE_STATE_STREAM_MS MS;
-    CD3DX12_PIPELINE_STATE_STREAM_CS CS;
-    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
-    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
-    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
-    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
-    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
-    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
-    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
-    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
-    CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
-    D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
-    {
-        D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
-        D.Flags                 = this->Flags;
-        D.NodeMask              = this->NodeMask;
-        D.pRootSignature        = this->pRootSignature;
-        D.InputLayout           = this->InputLayout;
-        D.IBStripCutValue       = this->IBStripCutValue;
-        D.PrimitiveTopologyType = this->PrimitiveTopologyType;
-        D.VS                    = this->VS;
-        D.GS                    = this->GS;
-        D.StreamOutput          = this->StreamOutput;
-        D.HS                    = this->HS;
-        D.DS                    = this->DS;
-        D.PS                    = this->PS;
-        D.BlendState            = this->BlendState;
-        D.DepthStencilState     = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
-        D.DSVFormat             = this->DSVFormat;
-        D.RasterizerState       = this->RasterizerState;
-        D.NumRenderTargets      = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
-        memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
-        D.SampleDesc            = this->SampleDesc;
-        D.SampleMask            = this->SampleMask;
-        D.CachedPSO             = this->CachedPSO;
-        return D;
-    }
-    D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
-    {
-        D3D12_COMPUTE_PIPELINE_STATE_DESC D;
-        D.Flags                 = this->Flags;
-        D.NodeMask              = this->NodeMask;
-        D.pRootSignature        = this->pRootSignature;
-        D.CS                    = this->CS;
-        D.CachedPSO             = this->CachedPSO;
-        return D;
-    }
-};
-
-// CD3DX12_PIPELINE_STATE_STREAM1 Works on OS Build 16299+ (where there is a new view instancing subobject).
-// Use CD3DX12_PIPELINE_STATE_STREAM for OS Build 15063+ support.
-struct CD3DX12_PIPELINE_STATE_STREAM1
-{
-    CD3DX12_PIPELINE_STATE_STREAM1() = default;
-    // Mesh and amplification shaders must be set manually, since they do not have representation in D3D12_GRAPHICS_PIPELINE_STATE_DESC
-    CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
-        : Flags(Desc.Flags)
-        , NodeMask(Desc.NodeMask)
-        , pRootSignature(Desc.pRootSignature)
-        , InputLayout(Desc.InputLayout)
-        , IBStripCutValue(Desc.IBStripCutValue)
-        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
-        , VS(Desc.VS)
-        , GS(Desc.GS)
-        , StreamOutput(Desc.StreamOutput)
-        , HS(Desc.HS)
-        , DS(Desc.DS)
-        , PS(Desc.PS)
-        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
-        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
-        , DSVFormat(Desc.DSVFormat)
-        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
-        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
-        , SampleDesc(Desc.SampleDesc)
-        , SampleMask(Desc.SampleMask)
-        , CachedPSO(Desc.CachedPSO)
-        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
-    {}
-    CD3DX12_PIPELINE_STATE_STREAM1(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
-        : Flags(Desc.Flags)
-        , NodeMask(Desc.NodeMask)
-        , pRootSignature(Desc.pRootSignature)
-        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
-        , PS(Desc.PS)
-        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
-        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
-        , DSVFormat(Desc.DSVFormat)
-        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
-        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
-        , SampleDesc(Desc.SampleDesc)
-        , SampleMask(Desc.SampleMask)
-        , CachedPSO(Desc.CachedPSO)
-        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
-    {}
-    CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
-        : Flags(Desc.Flags)
-        , NodeMask(Desc.NodeMask)
-        , pRootSignature(Desc.pRootSignature)
-        , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
-        , CachedPSO(Desc.CachedPSO)
-    {
-        static_cast<D3D12_DEPTH_STENCIL_DESC1&>(DepthStencilState).DepthEnable = false;
-    }
-    CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
-    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
-    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
-    CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
-    CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
-    CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
-    CD3DX12_PIPELINE_STATE_STREAM_VS VS;
-    CD3DX12_PIPELINE_STATE_STREAM_GS GS;
-    CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
-    CD3DX12_PIPELINE_STATE_STREAM_HS HS;
-    CD3DX12_PIPELINE_STATE_STREAM_DS DS;
-    CD3DX12_PIPELINE_STATE_STREAM_PS PS;
-    CD3DX12_PIPELINE_STATE_STREAM_CS CS;
-    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
-    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
-    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
-    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
-    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
-    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
-    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
-    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
-    CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
-    D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
-    {
-        D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
-        D.Flags                 = this->Flags;
-        D.NodeMask              = this->NodeMask;
-        D.pRootSignature        = this->pRootSignature;
-        D.InputLayout           = this->InputLayout;
-        D.IBStripCutValue       = this->IBStripCutValue;
-        D.PrimitiveTopologyType = this->PrimitiveTopologyType;
-        D.VS                    = this->VS;
-        D.GS                    = this->GS;
-        D.StreamOutput          = this->StreamOutput;
-        D.HS                    = this->HS;
-        D.DS                    = this->DS;
-        D.PS                    = this->PS;
-        D.BlendState            = this->BlendState;
-        D.DepthStencilState     = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
-        D.DSVFormat             = this->DSVFormat;
-        D.RasterizerState       = this->RasterizerState;
-        D.NumRenderTargets      = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
-        memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
-        D.SampleDesc            = this->SampleDesc;
-        D.SampleMask            = this->SampleMask;
-        D.CachedPSO             = this->CachedPSO;
-        return D;
-    }
-    D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
-    {
-        D3D12_COMPUTE_PIPELINE_STATE_DESC D;
-        D.Flags                 = this->Flags;
-        D.NodeMask              = this->NodeMask;
-        D.pRootSignature        = this->pRootSignature;
-        D.CS                    = this->CS;
-        D.CachedPSO             = this->CachedPSO;
-        return D;
-    }
-};
-
-
-struct CD3DX12_PIPELINE_MESH_STATE_STREAM
-{
-    CD3DX12_PIPELINE_MESH_STATE_STREAM() = default;
-    CD3DX12_PIPELINE_MESH_STATE_STREAM(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
-        : Flags(Desc.Flags)
-        , NodeMask(Desc.NodeMask)
-        , pRootSignature(Desc.pRootSignature)
-        , PS(Desc.PS)
-        , AS(Desc.AS)
-        , MS(Desc.MS)
-        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
-        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
-        , DSVFormat(Desc.DSVFormat)
-        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
-        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
-        , SampleDesc(Desc.SampleDesc)
-        , SampleMask(Desc.SampleMask)
-        , CachedPSO(Desc.CachedPSO)
-        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
-    {}
-    CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
-    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
-    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
-    CD3DX12_PIPELINE_STATE_STREAM_PS PS;
-    CD3DX12_PIPELINE_STATE_STREAM_AS AS;
-    CD3DX12_PIPELINE_STATE_STREAM_MS MS;
-    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
-    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
-    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
-    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
-    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
-    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
-    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
-    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
-    CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
-    D3DX12_MESH_SHADER_PIPELINE_STATE_DESC MeshShaderDescV0() const noexcept
-    {
-        D3DX12_MESH_SHADER_PIPELINE_STATE_DESC D;
-        D.Flags                 = this->Flags;
-        D.NodeMask              = this->NodeMask;
-        D.pRootSignature        = this->pRootSignature;
-        D.PS                    = this->PS;
-        D.AS                    = this->AS;
-        D.MS                    = this->MS;
-        D.BlendState            = this->BlendState;
-        D.DepthStencilState     = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
-        D.DSVFormat             = this->DSVFormat;
-        D.RasterizerState       = this->RasterizerState;
-        D.NumRenderTargets      = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
-        memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
-        D.SampleDesc            = this->SampleDesc;
-        D.SampleMask            = this->SampleMask;
-        D.CachedPSO             = this->CachedPSO;
-        return D;
-    }
-};
-
-// CD3DX12_PIPELINE_STATE_STREAM works on OS Build 15063+ but does not support new subobject(s) added in OS Build 16299+.
-// See CD3DX12_PIPELINE_STATE_STREAM1 for instance.
-struct CD3DX12_PIPELINE_STATE_STREAM
-{
-    CD3DX12_PIPELINE_STATE_STREAM() = default;
-    CD3DX12_PIPELINE_STATE_STREAM(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
-        : Flags(Desc.Flags)
-        , NodeMask(Desc.NodeMask)
-        , pRootSignature(Desc.pRootSignature)
-        , InputLayout(Desc.InputLayout)
-        , IBStripCutValue(Desc.IBStripCutValue)
-        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
-        , VS(Desc.VS)
-        , GS(Desc.GS)
-        , StreamOutput(Desc.StreamOutput)
-        , HS(Desc.HS)
-        , DS(Desc.DS)
-        , PS(Desc.PS)
-        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
-        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
-        , DSVFormat(Desc.DSVFormat)
-        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
-        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
-        , SampleDesc(Desc.SampleDesc)
-        , SampleMask(Desc.SampleMask)
-        , CachedPSO(Desc.CachedPSO)
-    {}
-    CD3DX12_PIPELINE_STATE_STREAM(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
-        : Flags(Desc.Flags)
-        , NodeMask(Desc.NodeMask)
-        , pRootSignature(Desc.pRootSignature)
-        , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
-        , CachedPSO(Desc.CachedPSO)
-    {}
-    CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
-    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
-    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
-    CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
-    CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
-    CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
-    CD3DX12_PIPELINE_STATE_STREAM_VS VS;
-    CD3DX12_PIPELINE_STATE_STREAM_GS GS;
-    CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
-    CD3DX12_PIPELINE_STATE_STREAM_HS HS;
-    CD3DX12_PIPELINE_STATE_STREAM_DS DS;
-    CD3DX12_PIPELINE_STATE_STREAM_PS PS;
-    CD3DX12_PIPELINE_STATE_STREAM_CS CS;
-    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
-    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
-    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
-    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
-    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
-    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
-    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
-    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
-    D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
-    {
-        D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
-        D.Flags                 = this->Flags;
-        D.NodeMask              = this->NodeMask;
-        D.pRootSignature        = this->pRootSignature;
-        D.InputLayout           = this->InputLayout;
-        D.IBStripCutValue       = this->IBStripCutValue;
-        D.PrimitiveTopologyType = this->PrimitiveTopologyType;
-        D.VS                    = this->VS;
-        D.GS                    = this->GS;
-        D.StreamOutput          = this->StreamOutput;
-        D.HS                    = this->HS;
-        D.DS                    = this->DS;
-        D.PS                    = this->PS;
-        D.BlendState            = this->BlendState;
-        D.DepthStencilState     = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
-        D.DSVFormat             = this->DSVFormat;
-        D.RasterizerState       = this->RasterizerState;
-        D.NumRenderTargets      = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
-        memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
-        D.SampleDesc            = this->SampleDesc;
-        D.SampleMask            = this->SampleMask;
-        D.CachedPSO             = this->CachedPSO;
-        return D;
-    }
-    D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
-    {
-        D3D12_COMPUTE_PIPELINE_STATE_DESC D;
-        D.Flags                 = this->Flags;
-        D.NodeMask              = this->NodeMask;
-        D.pRootSignature        = this->pRootSignature;
-        D.CS                    = this->CS;
-        D.CachedPSO             = this->CachedPSO;
-        return D;
-    }
-};
-
-struct CD3DX12_PIPELINE_STATE_STREAM2_PARSE_HELPER : public ID3DX12PipelineParserCallbacks
-{
-    CD3DX12_PIPELINE_STATE_STREAM2 PipelineStream;
-    CD3DX12_PIPELINE_STATE_STREAM2_PARSE_HELPER() noexcept
-        : SeenDSS(false)
-    {
-        // Adjust defaults to account for absent members.
-        PipelineStream.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
-
-        // Depth disabled if no DSV format specified.
-        static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = false;
-    }
-
-    // ID3DX12PipelineParserCallbacks
-    void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override {PipelineStream.Flags = Flags;}
-    void NodeMaskCb(UINT NodeMask) override {PipelineStream.NodeMask = NodeMask;}
-    void RootSignatureCb(ID3D12RootSignature* pRootSignature) override {PipelineStream.pRootSignature = pRootSignature;}
-    void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC& InputLayout) override {PipelineStream.InputLayout = InputLayout;}
-    void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override {PipelineStream.IBStripCutValue = IBStripCutValue;}
-    void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override {PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType;}
-    void VSCb(const D3D12_SHADER_BYTECODE& VS) override {PipelineStream.VS = VS;}
-    void GSCb(const D3D12_SHADER_BYTECODE& GS) override {PipelineStream.GS = GS;}
-    void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC& StreamOutput) override {PipelineStream.StreamOutput = StreamOutput;}
-    void HSCb(const D3D12_SHADER_BYTECODE& HS) override {PipelineStream.HS = HS;}
-    void DSCb(const D3D12_SHADER_BYTECODE& DS) override {PipelineStream.DS = DS;}
-    void PSCb(const D3D12_SHADER_BYTECODE& PS) override {PipelineStream.PS = PS;}
-    void CSCb(const D3D12_SHADER_BYTECODE& CS) override {PipelineStream.CS = CS;}
-    void ASCb(const D3D12_SHADER_BYTECODE& AS) override {PipelineStream.AS = AS;}
-    void MSCb(const D3D12_SHADER_BYTECODE& MS) override {PipelineStream.MS = MS;}
-    void BlendStateCb(const D3D12_BLEND_DESC& BlendState) override {PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState);}
-    void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC& DepthStencilState) override
-    {
-        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
-        SeenDSS = true;
-    }
-    void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1& DepthStencilState) override
-    {
-        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
-        SeenDSS = true;
-    }
-    void DSVFormatCb(DXGI_FORMAT DSVFormat) override
-    {
-        PipelineStream.DSVFormat = DSVFormat;
-        if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN)
-        {
-            // Re-enable depth for the default state.
-            static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = true;
-        }
-    }
-    void RasterizerStateCb(const D3D12_RASTERIZER_DESC& RasterizerState) override {PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState);}
-    void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY& RTVFormats) override {PipelineStream.RTVFormats = RTVFormats;}
-    void SampleDescCb(const DXGI_SAMPLE_DESC& SampleDesc) override {PipelineStream.SampleDesc = SampleDesc;}
-    void SampleMaskCb(UINT SampleMask) override {PipelineStream.SampleMask = SampleMask;}
-    void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC& ViewInstancingDesc) override {PipelineStream.ViewInstancingDesc = CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc);}
-    void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE& CachedPSO) override {PipelineStream.CachedPSO = CachedPSO;}
-
-private:
-    bool SeenDSS;
-};
-
-
-struct CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER : public ID3DX12PipelineParserCallbacks
-{
-    CD3DX12_PIPELINE_STATE_STREAM1 PipelineStream;
-    CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER() noexcept
-        : SeenDSS(false)
-    {
-        // Adjust defaults to account for absent members.
-        PipelineStream.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
-
-        // Depth disabled if no DSV format specified.
-        static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = false;
-    }
-
-    // ID3DX12PipelineParserCallbacks
-    void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override {PipelineStream.Flags = Flags;}
-    void NodeMaskCb(UINT NodeMask) override {PipelineStream.NodeMask = NodeMask;}
-    void RootSignatureCb(ID3D12RootSignature* pRootSignature) override {PipelineStream.pRootSignature = pRootSignature;}
-    void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC& InputLayout) override {PipelineStream.InputLayout = InputLayout;}
-    void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override {PipelineStream.IBStripCutValue = IBStripCutValue;}
-    void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override {PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType;}
-    void VSCb(const D3D12_SHADER_BYTECODE& VS) override {PipelineStream.VS = VS;}
-    void GSCb(const D3D12_SHADER_BYTECODE& GS) override {PipelineStream.GS = GS;}
-    void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC& StreamOutput) override {PipelineStream.StreamOutput = StreamOutput;}
-    void HSCb(const D3D12_SHADER_BYTECODE& HS) override {PipelineStream.HS = HS;}
-    void DSCb(const D3D12_SHADER_BYTECODE& DS) override {PipelineStream.DS = DS;}
-    void PSCb(const D3D12_SHADER_BYTECODE& PS) override {PipelineStream.PS = PS;}
-    void CSCb(const D3D12_SHADER_BYTECODE& CS) override {PipelineStream.CS = CS;}
-    void BlendStateCb(const D3D12_BLEND_DESC& BlendState) override {PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState);}
-    void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC& DepthStencilState) override
-    {
-        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
-        SeenDSS = true;
-    }
-    void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1& DepthStencilState) override
-    {
-        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
-        SeenDSS = true;
-    }
-    void DSVFormatCb(DXGI_FORMAT DSVFormat) override
-    {
-        PipelineStream.DSVFormat = DSVFormat;
-        if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN)
-        {
-            // Re-enable depth for the default state.
-            static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = true;
-        }
-    }
-    void RasterizerStateCb(const D3D12_RASTERIZER_DESC& RasterizerState) override {PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState);}
-    void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY& RTVFormats) override {PipelineStream.RTVFormats = RTVFormats;}
-    void SampleDescCb(const DXGI_SAMPLE_DESC& SampleDesc) override {PipelineStream.SampleDesc = SampleDesc;}
-    void SampleMaskCb(UINT SampleMask) override {PipelineStream.SampleMask = SampleMask;}
-    void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC& ViewInstancingDesc) override {PipelineStream.ViewInstancingDesc = CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc);}
-    void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE& CachedPSO) override {PipelineStream.CachedPSO = CachedPSO;}
-
-private:
-    bool SeenDSS;
-};
-
-inline D3D12_PIPELINE_STATE_SUBOBJECT_TYPE D3DX12GetBaseSubobjectType(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE SubobjectType) noexcept
-{
-    switch (SubobjectType)
-    {
-    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1:
-        return D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL;
-    default:
-        return SubobjectType;
-    }
-}
-
-inline HRESULT D3DX12ParsePipelineStream(const D3D12_PIPELINE_STATE_STREAM_DESC& Desc, ID3DX12PipelineParserCallbacks* pCallbacks)
-{
-    if (pCallbacks == nullptr)
-    {
-        return E_INVALIDARG;
-    }
-
-    if (Desc.SizeInBytes == 0 || Desc.pPipelineStateSubobjectStream == nullptr)
-    {
-        pCallbacks->ErrorBadInputParameter(1); // first parameter issue
-        return E_INVALIDARG;
-    }
-
-    bool SubobjectSeen[D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID] = {};
-    for (SIZE_T CurOffset = 0, SizeOfSubobject = 0; CurOffset < Desc.SizeInBytes; CurOffset += SizeOfSubobject)
-    {
-        BYTE* pStream = static_cast<BYTE*>(Desc.pPipelineStateSubobjectStream)+CurOffset;
-        auto SubobjectType = *reinterpret_cast<D3D12_PIPELINE_STATE_SUBOBJECT_TYPE*>(pStream);
-        if (SubobjectType < 0 || SubobjectType >= D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID)
-        {
-            pCallbacks->ErrorUnknownSubobject(SubobjectType);
-            return E_INVALIDARG;
-        }
-        if (SubobjectSeen[D3DX12GetBaseSubobjectType(SubobjectType)])
-        {
-            pCallbacks->ErrorDuplicateSubobject(SubobjectType);
-            return E_INVALIDARG; // disallow subobject duplicates in a stream
-        }
-        SubobjectSeen[SubobjectType] = true;
-        switch (SubobjectType)
-        {
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE:
-            pCallbacks->RootSignatureCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS:
-            pCallbacks->VSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::VS)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::VS);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS:
-            pCallbacks->PSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::PS)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PS);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS:
-            pCallbacks->DSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DS)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DS);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS:
-            pCallbacks->HSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::HS)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::HS);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS:
-            pCallbacks->GSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::GS)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::GS);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS:
-            pCallbacks->CSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::CS)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CS);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS:
-            pCallbacks->ASCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM2::AS)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM2::AS);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS:
-            pCallbacks->MSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM2::MS)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM2::MS);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT:
-            pCallbacks->StreamOutputCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND:
-            pCallbacks->BlendStateCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::BlendState)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::BlendState);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK:
-            pCallbacks->SampleMaskCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::SampleMask)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleMask);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER:
-            pCallbacks->RasterizerStateCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL:
-            pCallbacks->DepthStencilStateCb(*reinterpret_cast<CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1:
-            pCallbacks->DepthStencilState1Cb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT:
-            pCallbacks->InputLayoutCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::InputLayout)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::InputLayout);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE:
-            pCallbacks->IBStripCutValueCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY:
-            pCallbacks->PrimitiveTopologyTypeCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS:
-            pCallbacks->RTVFormatsCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT:
-            pCallbacks->DSVFormatCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC:
-            pCallbacks->SampleDescCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK:
-            pCallbacks->NodeMaskCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::NodeMask)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::NodeMask);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO:
-            pCallbacks->CachedPSOCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS:
-            pCallbacks->FlagsCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::Flags)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::Flags);
-            break;
-        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING:
-            pCallbacks->ViewInstancingCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc)*>(pStream));
-            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc);
-            break;
-        default:
-            pCallbacks->ErrorUnknownSubobject(SubobjectType);
-            return E_INVALIDARG;
-        }
-    }
-
-    return S_OK;
-}
-
-//------------------------------------------------------------------------------------------------
-inline bool operator==( const D3D12_CLEAR_VALUE &a, const D3D12_CLEAR_VALUE &b) noexcept
-{
-    if (a.Format != b.Format) return false;
-    if (a.Format == DXGI_FORMAT_D24_UNORM_S8_UINT
-     || a.Format == DXGI_FORMAT_D16_UNORM
-     || a.Format == DXGI_FORMAT_D32_FLOAT
-     || a.Format == DXGI_FORMAT_D32_FLOAT_S8X24_UINT)
-    {
-        return (a.DepthStencil.Depth == b.DepthStencil.Depth) &&
-          (a.DepthStencil.Stencil == b.DepthStencil.Stencil);
-    } else {
-        return (a.Color[0] == b.Color[0]) &&
-               (a.Color[1] == b.Color[1]) &&
-               (a.Color[2] == b.Color[2]) &&
-               (a.Color[3] == b.Color[3]);
-    }
-}
-inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &b) noexcept
-{
-    return a.ClearValue == b.ClearValue;
-}
-inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &a, const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &b) noexcept
-{
-    if (a.pSrcResource != b.pSrcResource) return false;
-    if (a.pDstResource != b.pDstResource) return false;
-    if (a.SubresourceCount != b.SubresourceCount) return false;
-    if (a.Format != b.Format) return false;
-    if (a.ResolveMode != b.ResolveMode) return false;
-    if (a.PreserveResolveSource != b.PreserveResolveSource) return false;
-    return true;
-}
-inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS &b) noexcept
-{
-    if (a.Type != b.Type) return false;
-    if (a.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR && !(a.Clear == b.Clear)) return false;
-    return true;
-}
-inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS &a, const D3D12_RENDER_PASS_ENDING_ACCESS &b) noexcept
-{
-    if (a.Type != b.Type) return false;
-    if (a.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE && !(a.Resolve == b.Resolve)) return false;
-    return true;
-}
-inline bool operator==( const D3D12_RENDER_PASS_RENDER_TARGET_DESC &a, const D3D12_RENDER_PASS_RENDER_TARGET_DESC &b) noexcept
-{
-    if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false;
-    if (!(a.BeginningAccess == b.BeginningAccess)) return false;
-    if (!(a.EndingAccess == b.EndingAccess)) return false;
-    return true;
-}
-inline bool operator==( const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &a, const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &b) noexcept
-{
-    if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false;
-    if (!(a.DepthBeginningAccess == b.DepthBeginningAccess)) return false;
-    if (!(a.StencilBeginningAccess == b.StencilBeginningAccess)) return false;
-    if (!(a.DepthEndingAccess == b.DepthEndingAccess)) return false;
-    if (!(a.StencilEndingAccess == b.StencilEndingAccess)) return false;
-    return true;
-}
-
-
-#ifndef D3DX12_NO_STATE_OBJECT_HELPERS
-
-//================================================================================================
-// D3DX12 State Object Creation Helpers
-//
-// Helper classes for creating new style state objects out of an arbitrary set of subobjects.
-// Uses STL
-//
-// Start by instantiating CD3DX12_STATE_OBJECT_DESC (see its public methods).
-// One of its methods is CreateSubobject(), which has a comment showing a couple of options for
-// defining subobjects using the helper classes for each subobject (CD3DX12_DXIL_LIBRARY_SUBOBJECT
-// etc.). The subobject helpers each have methods specific to the subobject for configuring its
-// contents.
-//
-//================================================================================================
-#include <list>
-#include <memory>
-#include <string>
-#include <vector>
-#ifndef D3DX12_USE_ATL
-#include <wrl/client.h>
-#define D3DX12_COM_PTR Microsoft::WRL::ComPtr
-#define D3DX12_COM_PTR_GET(x) x.Get()
-#define D3DX12_COM_PTR_ADDRESSOF(x) x.GetAddressOf()
-#else
-#include <atlbase.h>
-#define D3DX12_COM_PTR ATL::CComPtr
-#define D3DX12_COM_PTR_GET(x) x.p
-#define D3DX12_COM_PTR_ADDRESSOF(x) &x.p
-#endif
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_STATE_OBJECT_DESC
-{
-public:
-    CD3DX12_STATE_OBJECT_DESC() noexcept
-    {
-        Init(D3D12_STATE_OBJECT_TYPE_COLLECTION);
-    }
-    CD3DX12_STATE_OBJECT_DESC(D3D12_STATE_OBJECT_TYPE Type) noexcept
-    {
-        Init(Type);
-    }
-    void SetStateObjectType(D3D12_STATE_OBJECT_TYPE Type) noexcept { m_Desc.Type = Type; }
-    operator const D3D12_STATE_OBJECT_DESC&()
-    {
-        // Do final preparation work
-        m_RepointedAssociations.clear();
-        m_SubobjectArray.clear();
-        m_SubobjectArray.reserve(m_Desc.NumSubobjects);
-        // Flatten subobjects into an array (each flattened subobject still has a
-        // member that's a pointer to its desc that's not flattened)
-        for (auto Iter = m_SubobjectList.begin();
-            Iter != m_SubobjectList.end(); Iter++)
-        {
-            m_SubobjectArray.push_back(*Iter);
-            // Store new location in array so we can redirect pointers contained in subobjects
-            Iter->pSubobjectArrayLocation = &m_SubobjectArray.back();
-        }
-        // For subobjects with pointer fields, create a new copy of those subobject definitions
-        // with fixed pointers
-        for (UINT i = 0; i < m_Desc.NumSubobjects; i++)
-        {
-            if (m_SubobjectArray[i].Type == D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION)
-            {
-                auto pOriginalSubobjectAssociation =
-                    static_cast<const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION*>(m_SubobjectArray[i].pDesc);
-                D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION Repointed = *pOriginalSubobjectAssociation;
-                auto pWrapper =
-                    static_cast<const SUBOBJECT_WRAPPER*>(pOriginalSubobjectAssociation->pSubobjectToAssociate);
-                Repointed.pSubobjectToAssociate = pWrapper->pSubobjectArrayLocation;
-                m_RepointedAssociations.push_back(Repointed);
-                m_SubobjectArray[i].pDesc = &m_RepointedAssociations.back();
-            }
-        }
-        // Below: using ugly way to get pointer in case .data() is not defined
-        m_Desc.pSubobjects = m_Desc.NumSubobjects ? &m_SubobjectArray[0] : nullptr;
-        return m_Desc;
-    }
-    operator const D3D12_STATE_OBJECT_DESC*()
-    {
-        // Cast calls the above final preparation work
-        return &static_cast<const D3D12_STATE_OBJECT_DESC&>(*this);
-    }
-
-    // CreateSubobject creates a sububject helper (e.g. CD3DX12_HIT_GROUP_SUBOBJECT)
-    // whose lifetime is owned by this class.
-    // e.g.
-    //
-    //    CD3DX12_STATE_OBJECT_DESC Collection1(D3D12_STATE_OBJECT_TYPE_COLLECTION);
-    //    auto Lib0 = Collection1.CreateSubobject<CD3DX12_DXIL_LIBRARY_SUBOBJECT>();
-    //    Lib0->SetDXILLibrary(&pMyAppDxilLibs[0]);
-    //    Lib0->DefineExport(L"rayGenShader0"); // in practice these export listings might be
-    //                                          // data/engine driven
-    //    etc.
-    //
-    // Alternatively, users can instantiate sububject helpers explicitly, such as via local
-    // variables instead, passing the state object desc that should point to it into the helper
-    // constructor (or call mySubobjectHelper.AddToStateObject(Collection1)).
-    // In this alternative scenario, the user must keep the subobject alive as long as the state
-    // object it is associated with is alive, else its pointer references will be stale.
-    // e.g.
-    //
-    //    CD3DX12_STATE_OBJECT_DESC RaytracingState2(D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE);
-    //    CD3DX12_DXIL_LIBRARY_SUBOBJECT LibA(RaytracingState2);
-    //    LibA.SetDXILLibrary(&pMyAppDxilLibs[4]); // not manually specifying exports
-    //                                             // - meaning all exports in the libraries
-    //                                             // are exported
-    //    etc.
-
-    template<typename T>
-    T* CreateSubobject()
-    {
-        T* pSubobject = new T(*this);
-        m_OwnedSubobjectHelpers.emplace_back(pSubobject);
-        return pSubobject;
-    }
-
-private:
-    D3D12_STATE_SUBOBJECT* TrackSubobject(D3D12_STATE_SUBOBJECT_TYPE Type, void* pDesc)
-    {
-        SUBOBJECT_WRAPPER Subobject;
-        Subobject.pSubobjectArrayLocation = nullptr;
-        Subobject.Type = Type;
-        Subobject.pDesc = pDesc;
-        m_SubobjectList.push_back(Subobject);
-        m_Desc.NumSubobjects++;
-        return &m_SubobjectList.back();
-    }
-    void Init(D3D12_STATE_OBJECT_TYPE Type) noexcept
-    {
-        SetStateObjectType(Type);
-        m_Desc.pSubobjects = nullptr;
-        m_Desc.NumSubobjects = 0;
-        m_SubobjectList.clear();
-        m_SubobjectArray.clear();
-        m_RepointedAssociations.clear();
-    }
-    typedef struct SUBOBJECT_WRAPPER : public D3D12_STATE_SUBOBJECT
-    {
-        D3D12_STATE_SUBOBJECT* pSubobjectArrayLocation; // new location when flattened into array
-                                                        // for repointing pointers in subobjects
-    } SUBOBJECT_WRAPPER;
-    D3D12_STATE_OBJECT_DESC m_Desc;
-    std::list<SUBOBJECT_WRAPPER>   m_SubobjectList; // Pointers to list nodes handed out so
-                                                    // these can be edited live
-    std::vector<D3D12_STATE_SUBOBJECT> m_SubobjectArray; // Built at the end, copying list contents
-
-    std::list<D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION>
-            m_RepointedAssociations; // subobject type that contains pointers to other subobjects,
-                                     // repointed to flattened array
-
-    class StringContainer
-    {
-    public:
-        LPCWSTR LocalCopy(LPCWSTR string, bool bSingleString = false)
-        {
-            if (string)
-            {
-                if (bSingleString)
-                {
-                    m_Strings.clear();
-                    m_Strings.push_back(string);
-                }
-                else
-                {
-                    m_Strings.push_back(string);
-                }
-                return m_Strings.back().c_str();
-            }
-            else
-            {
-                return nullptr;
-            }
-        }
-        void clear() noexcept { m_Strings.clear(); }
-    private:
-        std::list<std::wstring> m_Strings;
-    };
-
-    class SUBOBJECT_HELPER_BASE
-    {
-    public:
-        SUBOBJECT_HELPER_BASE() noexcept { Init(); }
-        virtual ~SUBOBJECT_HELPER_BASE() = default;
-        virtual D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept = 0;
-        void AddToStateObject(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-        {
-            m_pSubobject = ContainingStateObject.TrackSubobject(Type(), Data());
-        }
-    protected:
-        virtual void* Data() noexcept = 0;
-        void Init() noexcept { m_pSubobject = nullptr; }
-        D3D12_STATE_SUBOBJECT* m_pSubobject;
-    };
-
-#if(__cplusplus >= 201103L)
-    std::list<std::unique_ptr<const SUBOBJECT_HELPER_BASE>> m_OwnedSubobjectHelpers;
-#else
-    class OWNED_HELPER
-    {
-    public:
-        OWNED_HELPER(const SUBOBJECT_HELPER_BASE* pHelper) noexcept { m_pHelper = pHelper; }
-        ~OWNED_HELPER() { delete m_pHelper; }
-        const SUBOBJECT_HELPER_BASE* m_pHelper;
-    };
-
-    std::list<OWNED_HELPER> m_OwnedSubobjectHelpers;
-#endif
-
-    friend class CD3DX12_DXIL_LIBRARY_SUBOBJECT;
-    friend class CD3DX12_EXISTING_COLLECTION_SUBOBJECT;
-    friend class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT;
-    friend class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
-    friend class CD3DX12_HIT_GROUP_SUBOBJECT;
-    friend class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT;
-    friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT;
-    friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT;
-    friend class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT;
-    friend class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT;
-    friend class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT;
-    friend class CD3DX12_NODE_MASK_SUBOBJECT;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_DXIL_LIBRARY_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_DXIL_LIBRARY_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_DXIL_LIBRARY_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void SetDXILLibrary(const D3D12_SHADER_BYTECODE* pCode) noexcept
-    {
-        static const D3D12_SHADER_BYTECODE Default = {};
-        m_Desc.DXILLibrary = pCode ? *pCode : Default;
-    }
-    void DefineExport(
-        LPCWSTR Name,
-        LPCWSTR ExportToRename = nullptr,
-        D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE)
-    {
-        D3D12_EXPORT_DESC Export;
-        Export.Name = m_Strings.LocalCopy(Name);
-        Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
-        Export.Flags = Flags;
-        m_Exports.push_back(Export);
-        m_Desc.pExports = &m_Exports[0];  // using ugly way to get pointer in case .data() is not defined
-        m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
-    }
-    template<size_t N>
-    void DefineExports(LPCWSTR(&Exports)[N])
-    {
-        for (UINT i = 0; i < N; i++)
-        {
-            DefineExport(Exports[i]);
-        }
-    }
-    void DefineExports(const LPCWSTR* Exports, UINT N)
-    {
-        for (UINT i = 0; i < N; i++)
-        {
-            DefineExport(Exports[i]);
-        }
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_DXIL_LIBRARY_DESC&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-        m_Strings.clear();
-        m_Exports.clear();
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_DXIL_LIBRARY_DESC m_Desc;
-    CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
-    std::vector<D3D12_EXPORT_DESC> m_Exports;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_EXISTING_COLLECTION_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_EXISTING_COLLECTION_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_EXISTING_COLLECTION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void SetExistingCollection(ID3D12StateObject*pExistingCollection) noexcept
-    {
-        m_Desc.pExistingCollection = pExistingCollection;
-        m_CollectionRef = pExistingCollection;
-    }
-    void DefineExport(
-        LPCWSTR Name,
-        LPCWSTR ExportToRename = nullptr,
-        D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE)
-    {
-        D3D12_EXPORT_DESC Export;
-        Export.Name = m_Strings.LocalCopy(Name);
-        Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
-        Export.Flags = Flags;
-        m_Exports.push_back(Export);
-        m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
-        m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
-    }
-    template<size_t N>
-    void DefineExports(LPCWSTR(&Exports)[N])
-    {
-        for (UINT i = 0; i < N; i++)
-        {
-            DefineExport(Exports[i]);
-        }
-    }
-    void DefineExports(const LPCWSTR* Exports, UINT N)
-    {
-        for (UINT i = 0; i < N; i++)
-        {
-            DefineExport(Exports[i]);
-        }
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_EXISTING_COLLECTION_DESC&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-        m_CollectionRef = nullptr;
-        m_Strings.clear();
-        m_Exports.clear();
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_EXISTING_COLLECTION_DESC m_Desc;
-    D3DX12_COM_PTR<ID3D12StateObject> m_CollectionRef;
-    CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
-    std::vector<D3D12_EXPORT_DESC> m_Exports;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void SetSubobjectToAssociate(const D3D12_STATE_SUBOBJECT& SubobjectToAssociate) noexcept
-    {
-        m_Desc.pSubobjectToAssociate = &SubobjectToAssociate;
-    }
-    void AddExport(LPCWSTR Export)
-    {
-        m_Desc.NumExports++;
-        m_Exports.push_back(m_Strings.LocalCopy(Export));
-        m_Desc.pExports = &m_Exports[0];  // using ugly way to get pointer in case .data() is not defined
-    }
-    template<size_t N>
-    void AddExports(LPCWSTR (&Exports)[N])
-    {
-        for (UINT i = 0; i < N; i++)
-        {
-            AddExport(Exports[i]);
-        }
-    }
-    void AddExports(const LPCWSTR* Exports, UINT N)
-    {
-        for (UINT i = 0; i < N; i++)
-        {
-            AddExport(Exports[i]);
-        }
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-        m_Strings.clear();
-        m_Exports.clear();
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
-    CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
-    std::vector<LPCWSTR> m_Exports;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION() noexcept
-    {
-        Init();
-    }
-    CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void SetSubobjectNameToAssociate(LPCWSTR SubobjectToAssociate)
-    {
-        m_Desc.SubobjectToAssociate = m_SubobjectName.LocalCopy(SubobjectToAssociate, true);
-    }
-    void AddExport(LPCWSTR Export)
-    {
-        m_Desc.NumExports++;
-        m_Exports.push_back(m_Strings.LocalCopy(Export));
-        m_Desc.pExports = &m_Exports[0];  // using ugly way to get pointer in case .data() is not defined
-    }
-    template<size_t N>
-    void AddExports(LPCWSTR (&Exports)[N])
-    {
-        for (UINT i = 0; i < N; i++)
-        {
-            AddExport(Exports[i]);
-        }
-    }
-    void AddExports(const LPCWSTR* Exports, UINT N)
-    {
-        for (UINT i = 0; i < N; i++)
-        {
-            AddExport(Exports[i]);
-        }
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-        m_Strings.clear();
-        m_SubobjectName.clear();
-        m_Exports.clear();
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
-    CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
-    CD3DX12_STATE_OBJECT_DESC::StringContainer m_SubobjectName;
-    std::vector<LPCWSTR> m_Exports;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_HIT_GROUP_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_HIT_GROUP_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_HIT_GROUP_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void SetHitGroupExport(LPCWSTR exportName)
-    {
-        m_Desc.HitGroupExport = m_Strings[0].LocalCopy(exportName, true);
-    }
-    void SetHitGroupType(D3D12_HIT_GROUP_TYPE Type) noexcept { m_Desc.Type = Type; }
-    void SetAnyHitShaderImport(LPCWSTR importName)
-    {
-        m_Desc.AnyHitShaderImport = m_Strings[1].LocalCopy(importName, true);
-    }
-    void SetClosestHitShaderImport(LPCWSTR importName)
-    {
-        m_Desc.ClosestHitShaderImport = m_Strings[2].LocalCopy(importName, true);
-    }
-    void SetIntersectionShaderImport(LPCWSTR importName)
-    {
-        m_Desc.IntersectionShaderImport = m_Strings[3].LocalCopy(importName, true);
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_HIT_GROUP_DESC&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-        for (UINT i = 0; i < m_NumStrings; i++)
-        {
-            m_Strings[i].clear();
-        }
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_HIT_GROUP_DESC m_Desc;
-    static constexpr UINT m_NumStrings = 4;
-    CD3DX12_STATE_OBJECT_DESC::StringContainer
-        m_Strings[m_NumStrings]; // one string for every entrypoint name
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void Config(UINT MaxPayloadSizeInBytes, UINT MaxAttributeSizeInBytes) noexcept
-    {
-        m_Desc.MaxPayloadSizeInBytes = MaxPayloadSizeInBytes;
-        m_Desc.MaxAttributeSizeInBytes = MaxAttributeSizeInBytes;
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_RAYTRACING_SHADER_CONFIG&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_RAYTRACING_SHADER_CONFIG m_Desc;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void Config(UINT MaxTraceRecursionDepth) noexcept
-    {
-        m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_RAYTRACING_PIPELINE_CONFIG&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_RAYTRACING_PIPELINE_CONFIG m_Desc;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void Config(UINT MaxTraceRecursionDepth, D3D12_RAYTRACING_PIPELINE_FLAGS Flags) noexcept
-    {
-        m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
-        m_Desc.Flags = Flags;
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_RAYTRACING_PIPELINE_CONFIG1&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_RAYTRACING_PIPELINE_CONFIG1 m_Desc;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
-    {
-        m_pRootSig = pRootSig;
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator ID3D12RootSignature*() const noexcept { return D3DX12_COM_PTR_GET(m_pRootSig); }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_pRootSig = nullptr;
-    }
-    void* Data() noexcept override { return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig); }
-    D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
-    {
-        m_pRootSig = pRootSig;
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator ID3D12RootSignature*() const noexcept { return D3DX12_COM_PTR_GET(m_pRootSig); }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_pRootSig = nullptr;
-    }
-    void* Data() noexcept override { return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig); }
-    D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void SetFlags(D3D12_STATE_OBJECT_FLAGS Flags) noexcept
-    {
-        m_Desc.Flags = Flags;
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_STATE_OBJECT_CONFIG&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_STATE_OBJECT_CONFIG m_Desc;
-};
-
-//------------------------------------------------------------------------------------------------
-class CD3DX12_NODE_MASK_SUBOBJECT
-    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
-{
-public:
-    CD3DX12_NODE_MASK_SUBOBJECT() noexcept
-    {
-        Init();
-    }
-    CD3DX12_NODE_MASK_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
-    {
-        Init();
-        AddToStateObject(ContainingStateObject);
-    }
-    void SetNodeMask(UINT NodeMask) noexcept
-    {
-        m_Desc.NodeMask = NodeMask;
-    }
-    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
-    {
-        return D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK;
-    }
-    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
-    operator const D3D12_NODE_MASK&() const noexcept { return m_Desc; }
-private:
-    void Init() noexcept
-    {
-        SUBOBJECT_HELPER_BASE::Init();
-        m_Desc = {};
-    }
-    void* Data() noexcept override { return &m_Desc; }
-    D3D12_NODE_MASK m_Desc;
-};
-
-#endif // !D3DX12_NO_STATE_OBJECT_HELPERS
-
-
-#if defined(NTDDI_WIN10_NI) || defined(USING_D3D12_AGILITY_SDK)
-
-//================================================================================================
-// D3DX12 Enhanced Barrier Helpers
-//================================================================================================
-
-class CD3DX12_BARRIER_SUBRESOURCE_RANGE : public D3D12_BARRIER_SUBRESOURCE_RANGE
-{
-public:
-    CD3DX12_BARRIER_SUBRESOURCE_RANGE() = default;
-    CD3DX12_BARRIER_SUBRESOURCE_RANGE(const D3D12_BARRIER_SUBRESOURCE_RANGE &o) noexcept :
-        D3D12_BARRIER_SUBRESOURCE_RANGE(o)
-    {}
-    explicit CD3DX12_BARRIER_SUBRESOURCE_RANGE(UINT Subresource) noexcept :
-        D3D12_BARRIER_SUBRESOURCE_RANGE{ Subresource, 0, 0, 0, 0, 0 }
-    {}
-    CD3DX12_BARRIER_SUBRESOURCE_RANGE(
-        UINT firstMipLevel,
-        UINT numMips,
-        UINT firstArraySlice,
-        UINT numArraySlices,
-        UINT firstPlane = 0,
-        UINT numPlanes = 1) noexcept :
-        D3D12_BARRIER_SUBRESOURCE_RANGE
-        {
-            firstMipLevel,
-            numMips,
-            firstArraySlice,
-            numArraySlices,
-            firstPlane,
-            numPlanes
-        }
-    {}
-};
-
-class CD3DX12_GLOBAL_BARRIER : public D3D12_GLOBAL_BARRIER
-{
-public:
-    CD3DX12_GLOBAL_BARRIER() = default;
-    CD3DX12_GLOBAL_BARRIER(const D3D12_GLOBAL_BARRIER &o) noexcept : D3D12_GLOBAL_BARRIER(o){}
-    CD3DX12_GLOBAL_BARRIER(
-        D3D12_BARRIER_SYNC syncBefore,
-        D3D12_BARRIER_SYNC syncAfter,
-        D3D12_BARRIER_ACCESS accessBefore,
-        D3D12_BARRIER_ACCESS accessAfter) noexcept : D3D12_GLOBAL_BARRIER {
-            syncBefore,
-            syncAfter,
-            accessBefore,
-            accessAfter
-        }
-    {}
-};
-
-class CD3DX12_BUFFER_BARRIER : public D3D12_BUFFER_BARRIER
-{
-public:
-    CD3DX12_BUFFER_BARRIER() = default;
-    CD3DX12_BUFFER_BARRIER(const D3D12_BUFFER_BARRIER &o) noexcept : D3D12_BUFFER_BARRIER(o){}
-    CD3DX12_BUFFER_BARRIER(
-        D3D12_BARRIER_SYNC syncBefore,
-        D3D12_BARRIER_SYNC syncAfter,
-        D3D12_BARRIER_ACCESS accessBefore,
-        D3D12_BARRIER_ACCESS accessAfter,
-        ID3D12Resource *pRes) noexcept : D3D12_BUFFER_BARRIER {
-            syncBefore,
-            syncAfter,
-            accessBefore,
-            accessAfter,
-            pRes,
-            0, ULLONG_MAX
-        }
-    {}
-};
-
-class CD3DX12_TEXTURE_BARRIER : public D3D12_TEXTURE_BARRIER
-{
-public:
-    CD3DX12_TEXTURE_BARRIER() = default;
-    CD3DX12_TEXTURE_BARRIER(const D3D12_TEXTURE_BARRIER &o) noexcept : D3D12_TEXTURE_BARRIER(o){}
-    CD3DX12_TEXTURE_BARRIER(
-        D3D12_BARRIER_SYNC syncBefore,
-        D3D12_BARRIER_SYNC syncAfter,
-        D3D12_BARRIER_ACCESS accessBefore,
-        D3D12_BARRIER_ACCESS accessAfter,
-        D3D12_BARRIER_LAYOUT layoutBefore,
-        D3D12_BARRIER_LAYOUT layoutAfter,
-        ID3D12Resource *pRes,
-        const D3D12_BARRIER_SUBRESOURCE_RANGE &subresources,
-        D3D12_TEXTURE_BARRIER_FLAGS flag = D3D12_TEXTURE_BARRIER_FLAG_NONE) noexcept : D3D12_TEXTURE_BARRIER {
-            syncBefore,
-            syncAfter,
-            accessBefore,
-            accessAfter,
-            layoutBefore,
-            layoutAfter,
-            pRes,
-            subresources,
-            flag
-        }
-    {}
-};
-
-class CD3DX12_BARRIER_GROUP : public D3D12_BARRIER_GROUP
-{
-public:
-    CD3DX12_BARRIER_GROUP() = default;
-    CD3DX12_BARRIER_GROUP(const D3D12_BARRIER_GROUP &o) noexcept : D3D12_BARRIER_GROUP(o){}
-    CD3DX12_BARRIER_GROUP(UINT32 numBarriers, const D3D12_BUFFER_BARRIER *pBarriers) noexcept
-    {
-        Type = D3D12_BARRIER_TYPE_BUFFER;
-        NumBarriers = numBarriers;
-        pBufferBarriers = pBarriers;
-    }
-    CD3DX12_BARRIER_GROUP(UINT32 numBarriers, const D3D12_TEXTURE_BARRIER *pBarriers) noexcept
-    {
-        Type = D3D12_BARRIER_TYPE_TEXTURE;
-        NumBarriers = numBarriers;
-        pTextureBarriers = pBarriers;
-    }
-    CD3DX12_BARRIER_GROUP(UINT32 numBarriers, const D3D12_GLOBAL_BARRIER *pBarriers) noexcept
-    {
-        Type = D3D12_BARRIER_TYPE_GLOBAL;
-        NumBarriers = numBarriers;
-        pGlobalBarriers = pBarriers;
-    }
-};
-
-#endif // NTDDI_WIN10_NI || USING_D3D12_AGILITY_SDK
-
-
-#if (defined(NTDDI_WIN10_CO) || defined(USING_D3D12_AGILITY_SDK)) && !defined(D3DX12_NO_CHECK_FEATURE_SUPPORT_CLASS)
-
-//================================================================================================
-// D3DX12 Check Feature Support
-//================================================================================================
-
-#include <vector>
-
-class CD3DX12FeatureSupport
-{
-public: // Function declaration
-    // Default constructor that creates an empty object
-    CD3DX12FeatureSupport() noexcept;
-
-    // Initialize data from the given device
-    HRESULT Init(ID3D12Device* pDevice);
-
-    // Retreives the status of the object. If an error occurred in the initialization process, the function returns the error code.
-    HRESULT GetStatus() const noexcept { return m_hStatus; }
-
-    // Getter functions for each feature class
-    // D3D12_OPTIONS
-    BOOL DoublePrecisionFloatShaderOps() const noexcept;
-    BOOL OutputMergerLogicOp() const noexcept;
-    D3D12_SHADER_MIN_PRECISION_SUPPORT MinPrecisionSupport() const noexcept;
-    D3D12_TILED_RESOURCES_TIER TiledResourcesTier() const noexcept;
-    D3D12_RESOURCE_BINDING_TIER ResourceBindingTier() const noexcept;
-    BOOL PSSpecifiedStencilRefSupported() const noexcept;
-    BOOL TypedUAVLoadAdditionalFormats() const noexcept;
-    BOOL ROVsSupported() const noexcept;
-    D3D12_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier() const noexcept;
-    BOOL StandardSwizzle64KBSupported() const noexcept;
-    BOOL CrossAdapterRowMajorTextureSupported() const noexcept;
-    BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation() const noexcept;
-    D3D12_RESOURCE_HEAP_TIER ResourceHeapTier() const noexcept;
-    D3D12_CROSS_NODE_SHARING_TIER CrossNodeSharingTier() const noexcept;
-    UINT MaxGPUVirtualAddressBitsPerResource() const noexcept;
-
-    // FEATURE_LEVELS
-    D3D_FEATURE_LEVEL MaxSupportedFeatureLevel() const noexcept;
-
-    // FORMAT_SUPPORT
-    HRESULT FormatSupport(DXGI_FORMAT Format, D3D12_FORMAT_SUPPORT1& Support1, D3D12_FORMAT_SUPPORT2& Support2) const;
-
-    // MUTLTISAMPLE_QUALITY_LEVELS
-    HRESULT MultisampleQualityLevels(DXGI_FORMAT Format, UINT SampleCount, D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags, UINT& NumQualityLevels) const;
-
-    // FORMAT_INFO
-    HRESULT FormatInfo(DXGI_FORMAT Format, UINT8& PlaneCount) const;
-
-    // GPU_VIRTUAL_ADDRESS_SUPPORT
-    UINT MaxGPUVirtualAddressBitsPerProcess() const noexcept;
-
-    // SHADER_MODEL
-    D3D_SHADER_MODEL HighestShaderModel() const noexcept;
-
-    // D3D12_OPTIONS1
-    BOOL WaveOps() const noexcept;
-    UINT WaveLaneCountMin() const noexcept;
-    UINT WaveLaneCountMax() const noexcept;
-    UINT TotalLaneCount() const noexcept;
-    BOOL ExpandedComputeResourceStates() const noexcept;
-    BOOL Int64ShaderOps() const noexcept;
-
-    // PROTECTED_RESOURCE_SESSION_SUPPORT
-    D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS ProtectedResourceSessionSupport(UINT NodeIndex = 0) const;
-
-    // ROOT_SIGNATURE
-    D3D_ROOT_SIGNATURE_VERSION HighestRootSignatureVersion() const noexcept;
-
-    // ARCHITECTURE1
-    BOOL TileBasedRenderer(UINT NodeIndex = 0) const;
-    BOOL UMA(UINT NodeIndex = 0) const;
-    BOOL CacheCoherentUMA(UINT NodeIndex = 0) const;
-    BOOL IsolatedMMU(UINT NodeIndex = 0) const;
-
-    // D3D12_OPTIONS2
-    BOOL DepthBoundsTestSupported() const noexcept;
-    D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier() const noexcept;
-
-    // SHADER_CACHE
-    D3D12_SHADER_CACHE_SUPPORT_FLAGS ShaderCacheSupportFlags() const noexcept;
-
-    // COMMAND_QUEUE_PRIORITY
-    BOOL CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE CommandListType, UINT Priority);
-
-    // D3D12_OPTIONS3
-    BOOL CopyQueueTimestampQueriesSupported() const noexcept;
-    BOOL CastingFullyTypedFormatSupported() const noexcept;
-    D3D12_COMMAND_LIST_SUPPORT_FLAGS WriteBufferImmediateSupportFlags() const noexcept;
-    D3D12_VIEW_INSTANCING_TIER ViewInstancingTier() const noexcept;
-    BOOL BarycentricsSupported() const noexcept;
-
-    // EXISTING_HEAPS
-    BOOL ExistingHeapsSupported() const noexcept;
-
-    // D3D12_OPTIONS4
-    BOOL MSAA64KBAlignedTextureSupported() const noexcept;
-    D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier() const noexcept;
-    BOOL Native16BitShaderOpsSupported() const noexcept;
-
-    // SERIALIZATION
-    D3D12_HEAP_SERIALIZATION_TIER HeapSerializationTier(UINT NodeIndex = 0) const;
-
-    // CROSS_NODE
-    // CrossNodeSharingTier handled in D3D12Options
-    BOOL CrossNodeAtomicShaderInstructions() const noexcept;
-
-    // D3D12_OPTIONS5
-    BOOL SRVOnlyTiledResourceTier3() const noexcept;
-    D3D12_RENDER_PASS_TIER RenderPassesTier() const noexcept;
-    D3D12_RAYTRACING_TIER RaytracingTier() const noexcept;
-
-    // DISPLAYABLE
-    BOOL DisplayableTexture() const noexcept;
-    // SharedResourceCompatibilityTier handled in D3D12Options4
-
-    // D3D12_OPTIONS6
-    BOOL AdditionalShadingRatesSupported() const noexcept;
-    BOOL PerPrimitiveShadingRateSupportedWithViewportIndexing() const noexcept;
-    D3D12_VARIABLE_SHADING_RATE_TIER VariableShadingRateTier() const noexcept;
-    UINT ShadingRateImageTileSize() const noexcept;
-    BOOL BackgroundProcessingSupported() const noexcept;
-
-    // QUERY_META_COMMAND
-    HRESULT QueryMetaCommand(D3D12_FEATURE_DATA_QUERY_META_COMMAND& dQueryMetaCommand) const;
-
-    // D3D12_OPTIONS7
-    D3D12_MESH_SHADER_TIER MeshShaderTier() const noexcept;
-    D3D12_SAMPLER_FEEDBACK_TIER SamplerFeedbackTier() const noexcept;
-
-    // PROTECTED_RESOURCE_SESSION_TYPE_COUNT
-    UINT ProtectedResourceSessionTypeCount(UINT NodeIndex = 0) const;
-
-    // PROTECTED_RESOURCE_SESSION_TYPES
-    std::vector<GUID> ProtectedResourceSessionTypes(UINT NodeIndex = 0) const;
-
-    // D3D12_OPTIONS8
-    BOOL UnalignedBlockTexturesSupported() const noexcept;
-
-    // D3D12_OPTIONS9
-    BOOL MeshShaderPipelineStatsSupported() const noexcept;
-    BOOL MeshShaderSupportsFullRangeRenderTargetArrayIndex() const noexcept;
-    BOOL AtomicInt64OnTypedResourceSupported() const noexcept;
-    BOOL AtomicInt64OnGroupSharedSupported() const noexcept;
-    BOOL DerivativesInMeshAndAmplificationShadersSupported() const noexcept;
-    D3D12_WAVE_MMA_TIER WaveMMATier() const noexcept;
-
-    // D3D12_OPTIONS10
-    BOOL VariableRateShadingSumCombinerSupported() const noexcept;
-    BOOL MeshShaderPerPrimitiveShadingRateSupported() const noexcept;
-
-    // D3D12_OPTIONS11
-    BOOL AtomicInt64OnDescriptorHeapResourceSupported() const noexcept;
-
-
-#if defined(NTDDI_WIN10_NI) || defined(USING_D3D12_AGILITY_SDK)
-    // D3D12_OPTIONS12
-    D3D12_TRI_STATE MSPrimitivesPipelineStatisticIncludesCulledPrimitives() const noexcept;
-    BOOL EnhancedBarriersSupported() const noexcept;
-    BOOL RelaxedFormatCastingSupported() const noexcept;
-
-    // D3D12_OPTIONS13
-    BOOL UnrestrictedBufferTextureCopyPitchSupported() const noexcept;
-    BOOL UnrestrictedVertexElementAlignmentSupported() const noexcept;
-    BOOL InvertedViewportHeightFlipsYSupported() const noexcept;
-    BOOL InvertedViewportDepthFlipsZSupported() const noexcept;
-    BOOL TextureCopyBetweenDimensionsSupported() const noexcept;
-    BOOL AlphaBlendFactorSupported() const noexcept;
-#endif
-
-private: // Private structs and helpers declaration
-    struct ProtectedResourceSessionTypesLocal : D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES
-    {
-        std::vector<GUID> TypeVec;
-    };
-
-    // Helper function to decide the highest shader model supported by the system
-    // Stores the result in m_dShaderModel
-    // Must be updated whenever a new shader model is added to the d3d12.h header
-    HRESULT QueryHighestShaderModel();
-
-    // Helper function to decide the highest root signature supported
-    // Must be updated whenever a new root signature version is added to the d3d12.h header
-    HRESULT QueryHighestRootSignatureVersion();
-
-    // Helper funcion to decide the highest feature level
-    HRESULT QueryHighestFeatureLevel();
-
-    // Helper function to initialize local protected resource session types structs
-    HRESULT QueryProtectedResourceSessionTypes(UINT NodeIndex, UINT Count);
-
-private: // Member data
-    // Pointer to the underlying device
-    ID3D12Device* m_pDevice;
-
-    // Stores the error code from initialization
-    HRESULT m_hStatus;
-
-    // Feature support data structs
-    D3D12_FEATURE_DATA_D3D12_OPTIONS m_dOptions;
-    D3D_FEATURE_LEVEL m_eMaxFeatureLevel;
-    D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT m_dGPUVASupport;
-    D3D12_FEATURE_DATA_SHADER_MODEL m_dShaderModel;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS1 m_dOptions1;
-    std::vector<D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT> m_dProtectedResourceSessionSupport;
-    D3D12_FEATURE_DATA_ROOT_SIGNATURE m_dRootSignature;
-    std::vector<D3D12_FEATURE_DATA_ARCHITECTURE1> m_dArchitecture1;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS2 m_dOptions2;
-    D3D12_FEATURE_DATA_SHADER_CACHE m_dShaderCache;
-    D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY m_dCommandQueuePriority;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS3 m_dOptions3;
-    D3D12_FEATURE_DATA_EXISTING_HEAPS m_dExistingHeaps;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS4 m_dOptions4;
-    std::vector<D3D12_FEATURE_DATA_SERIALIZATION> m_dSerialization; // Cat2 NodeIndex
-    D3D12_FEATURE_DATA_CROSS_NODE m_dCrossNode;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS5 m_dOptions5;
-    D3D12_FEATURE_DATA_DISPLAYABLE m_dDisplayable;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS6 m_dOptions6;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS7 m_dOptions7;
-    std::vector<D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT> m_dProtectedResourceSessionTypeCount; // Cat2 NodeIndex
-    std::vector<ProtectedResourceSessionTypesLocal> m_dProtectedResourceSessionTypes; // Cat3
-    D3D12_FEATURE_DATA_D3D12_OPTIONS8 m_dOptions8;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS9 m_dOptions9;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS10 m_dOptions10;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS11 m_dOptions11;
-#if defined(NTDDI_WIN10_NI) || defined(USING_D3D12_AGILITY_SDK)
-    D3D12_FEATURE_DATA_D3D12_OPTIONS12 m_dOptions12;
-    D3D12_FEATURE_DATA_D3D12_OPTIONS13 m_dOptions13;
-#endif
-};
-
-// Implementations for CD3DX12FeatureSupport functions
-
-// Macro to set up a getter function for each entry in feature support data
-// The getter function will have the same name as the feature option name
-#define FEATURE_SUPPORT_GET(RETTYPE,FEATURE,OPTION) \
-inline RETTYPE CD3DX12FeatureSupport::OPTION() const noexcept \
-{ \
-    return FEATURE.OPTION; \
-}
-
-// Macro to set up a getter function for each entry in feature support data
-// Also specifies the name for the function which can be different from the feature name
-#define FEATURE_SUPPORT_GET_NAME(RETTYPE,FEATURE,OPTION,NAME) \
-inline RETTYPE CD3DX12FeatureSupport::NAME() const noexcept \
-{\
-    return FEATURE.OPTION; \
-}
-
-// Macro to set up a getter function for feature data indexed by the graphics node ID
-// The default parameter is 0, or the first availabe graphics device node
-#define FEATURE_SUPPORT_GET_NODE_INDEXED(RETTYPE,FEATURE,OPTION) \
-inline RETTYPE CD3DX12FeatureSupport::OPTION(UINT NodeIndex) const \
-{\
-    return FEATURE[NodeIndex].OPTION; \
-}
-
-// Macro to set up a getter function for feature data indexed by NodeIndex
-// Allows a custom name for the getter function
-#define FEATURE_SUPPORT_GET_NODE_INDEXED_NAME(RETTYPE,FEATURE,OPTION,NAME) \
-inline RETTYPE CD3DX12FeatureSupport::NAME(UINT NodeIndex) const \
-{\
-    return FEATURE[NodeIndex].OPTION; \
-}
-
-inline CD3DX12FeatureSupport::CD3DX12FeatureSupport() noexcept
-: m_pDevice(nullptr)
-, m_hStatus(E_INVALIDARG)
-, m_dOptions{}
-, m_eMaxFeatureLevel{}
-, m_dGPUVASupport{}
-, m_dShaderModel{}
-, m_dOptions1{}
-, m_dRootSignature{}
-, m_dOptions2{}
-, m_dShaderCache{}
-, m_dCommandQueuePriority{}
-, m_dOptions3{}
-, m_dExistingHeaps{}
-, m_dOptions4{}
-, m_dCrossNode{}
-, m_dOptions5{}
-, m_dDisplayable{}
-, m_dOptions6{}
-, m_dOptions7{}
-, m_dOptions8{}
-, m_dOptions9{}
-, m_dOptions10{}
-, m_dOptions11{}
-#if defined(NTDDI_WIN10_NI) || defined(USING_D3D12_AGILITY_SDK)
-, m_dOptions12{}
-, m_dOptions13{}
-#endif
-{}
-
-inline HRESULT CD3DX12FeatureSupport::Init(ID3D12Device* pDevice)
-{
-    if (!pDevice)
-    {
-        m_hStatus = E_INVALIDARG;
-        return m_hStatus;
-    }
-
-    m_pDevice = pDevice;
-
-    // Initialize static feature support data structures
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &m_dOptions, sizeof(m_dOptions))))
-    {
-        m_dOptions.DoublePrecisionFloatShaderOps = false;
-        m_dOptions.OutputMergerLogicOp = false;
-        m_dOptions.MinPrecisionSupport = D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE;
-        m_dOptions.TiledResourcesTier = D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED;
-        m_dOptions.ResourceBindingTier = static_cast<D3D12_RESOURCE_BINDING_TIER>(0);
-        m_dOptions.PSSpecifiedStencilRefSupported = false;
-        m_dOptions.TypedUAVLoadAdditionalFormats = false;
-        m_dOptions.ROVsSupported = false;
-        m_dOptions.ConservativeRasterizationTier = D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED;
-        m_dOptions.MaxGPUVirtualAddressBitsPerResource = 0;
-        m_dOptions.StandardSwizzle64KBSupported = false;
-        m_dOptions.CrossNodeSharingTier = D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED;
-        m_dOptions.CrossAdapterRowMajorTextureSupported = false;
-        m_dOptions.VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation = false;
-        m_dOptions.ResourceHeapTier = static_cast<D3D12_RESOURCE_HEAP_TIER>(0);
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT, &m_dGPUVASupport, sizeof(m_dGPUVASupport))))
-    {
-        m_dGPUVASupport.MaxGPUVirtualAddressBitsPerProcess = 0;
-        m_dGPUVASupport.MaxGPUVirtualAddressBitsPerResource = 0;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS1, &m_dOptions1, sizeof(m_dOptions1))))
-    {
-        m_dOptions1.WaveOps = false;
-        m_dOptions1.WaveLaneCountMax = 0;
-        m_dOptions1.WaveLaneCountMin = 0;
-        m_dOptions1.TotalLaneCount = 0;
-        m_dOptions1.ExpandedComputeResourceStates = 0;
-        m_dOptions1.Int64ShaderOps = 0;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS2, &m_dOptions2, sizeof(m_dOptions2))))
-    {
-        m_dOptions2.DepthBoundsTestSupported = false;
-        m_dOptions2.ProgrammableSamplePositionsTier = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_SHADER_CACHE, &m_dShaderCache, sizeof(m_dShaderCache))))
-    {
-        m_dShaderCache.SupportFlags = D3D12_SHADER_CACHE_SUPPORT_NONE;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &m_dOptions3, sizeof(m_dOptions3))))
-    {
-        m_dOptions3.CopyQueueTimestampQueriesSupported = false;
-        m_dOptions3.CastingFullyTypedFormatSupported = false;
-        m_dOptions3.WriteBufferImmediateSupportFlags = D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE;
-        m_dOptions3.ViewInstancingTier = D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED;
-        m_dOptions3.BarycentricsSupported = false;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_EXISTING_HEAPS, &m_dExistingHeaps, sizeof(m_dExistingHeaps))))
-    {
-        m_dExistingHeaps.Supported = false;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS4, &m_dOptions4, sizeof(m_dOptions4))))
-    {
-        m_dOptions4.MSAA64KBAlignedTextureSupported = false;
-        m_dOptions4.Native16BitShaderOpsSupported = false;
-        m_dOptions4.SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_CROSS_NODE, &m_dCrossNode, sizeof(m_dCrossNode))))
-    {
-        m_dCrossNode.SharingTier = D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED;
-        m_dCrossNode.AtomicShaderInstructions = false;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS5, &m_dOptions5, sizeof(m_dOptions5))))
-    {
-        m_dOptions5.SRVOnlyTiledResourceTier3 = false;
-        m_dOptions5.RenderPassesTier = D3D12_RENDER_PASS_TIER_0;
-        m_dOptions5.RaytracingTier = D3D12_RAYTRACING_TIER_NOT_SUPPORTED;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_DISPLAYABLE, &m_dDisplayable, sizeof(m_dDisplayable))))
-    {
-        m_dDisplayable.DisplayableTexture = false;
-        m_dDisplayable.SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS6, &m_dOptions6, sizeof(m_dOptions6))))
-    {
-        m_dOptions6.AdditionalShadingRatesSupported = false;
-        m_dOptions6.PerPrimitiveShadingRateSupportedWithViewportIndexing = false;
-        m_dOptions6.VariableShadingRateTier = D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED;
-        m_dOptions6.ShadingRateImageTileSize = 0;
-        m_dOptions6.BackgroundProcessingSupported = false;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &m_dOptions7, sizeof(m_dOptions7))))
-    {
-        m_dOptions7.MeshShaderTier = D3D12_MESH_SHADER_TIER_NOT_SUPPORTED;
-        m_dOptions7.SamplerFeedbackTier = D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS8, &m_dOptions8, sizeof(m_dOptions8))))
-    {
-        m_dOptions8.UnalignedBlockTexturesSupported = false;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS9, &m_dOptions9, sizeof(m_dOptions9))))
-    {
-        m_dOptions9.MeshShaderPipelineStatsSupported = false;
-        m_dOptions9.MeshShaderSupportsFullRangeRenderTargetArrayIndex = false;
-        m_dOptions9.AtomicInt64OnGroupSharedSupported = false;
-        m_dOptions9.AtomicInt64OnTypedResourceSupported = false;
-        m_dOptions9.DerivativesInMeshAndAmplificationShadersSupported = false;
-        m_dOptions9.WaveMMATier = D3D12_WAVE_MMA_TIER_NOT_SUPPORTED;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS10, &m_dOptions10, sizeof(m_dOptions10))))
-    {
-        m_dOptions10.MeshShaderPerPrimitiveShadingRateSupported = false;
-        m_dOptions10.VariableRateShadingSumCombinerSupported = false;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS11, &m_dOptions11, sizeof(m_dOptions11))))
-    {
-        m_dOptions11.AtomicInt64OnDescriptorHeapResourceSupported = false;
-    }
-
-#if defined(NTDDI_WIN10_NI) || defined(USING_D3D12_AGILITY_SDK)
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS12, &m_dOptions12, sizeof(m_dOptions12))))
-    {
-        m_dOptions12.MSPrimitivesPipelineStatisticIncludesCulledPrimitives = D3D12_TRI_STATE::D3D12_TRI_STATE_UNKNOWN;
-        m_dOptions12.EnhancedBarriersSupported = false;
-        m_dOptions12.RelaxedFormatCastingSupported = false;
-    }
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS13, &m_dOptions13, sizeof(m_dOptions13))))
-    {
-        m_dOptions13.UnrestrictedBufferTextureCopyPitchSupported = false;
-        m_dOptions13.UnrestrictedVertexElementAlignmentSupported = false;
-        m_dOptions13.InvertedViewportHeightFlipsYSupported = false;
-        m_dOptions13.InvertedViewportDepthFlipsZSupported = false;
-        m_dOptions13.TextureCopyBetweenDimensionsSupported = false;
-        m_dOptions13.AlphaBlendFactorSupported = false;
-    }
-#endif
-
-    // Initialize per-node feature support data structures
-    const UINT uNodeCount = m_pDevice->GetNodeCount();
-    m_dProtectedResourceSessionSupport.resize(uNodeCount);
-    m_dArchitecture1.resize(uNodeCount);
-    m_dSerialization.resize(uNodeCount);
-    m_dProtectedResourceSessionTypeCount.resize(uNodeCount);
-    m_dProtectedResourceSessionTypes.resize(uNodeCount);
-    for (UINT NodeIndex = 0; NodeIndex < uNodeCount; NodeIndex++)
-    {
-        m_dProtectedResourceSessionSupport[NodeIndex].NodeIndex = NodeIndex;
-        if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT, &m_dProtectedResourceSessionSupport[NodeIndex], sizeof(m_dProtectedResourceSessionSupport[NodeIndex]))))
-        {
-            m_dProtectedResourceSessionSupport[NodeIndex].Support = D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE;
-        }
-
-        m_dArchitecture1[NodeIndex].NodeIndex = NodeIndex;
-        if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE1, &m_dArchitecture1[NodeIndex], sizeof(m_dArchitecture1[NodeIndex]))))
-        {
-            D3D12_FEATURE_DATA_ARCHITECTURE dArchLocal = {};
-            dArchLocal.NodeIndex = NodeIndex;
-            if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE, &dArchLocal, sizeof(dArchLocal))))
-            {
-                dArchLocal.TileBasedRenderer = false;
-                dArchLocal.UMA = false;
-                dArchLocal.CacheCoherentUMA = false;
-            }
-
-            m_dArchitecture1[NodeIndex].TileBasedRenderer = dArchLocal.TileBasedRenderer;
-            m_dArchitecture1[NodeIndex].UMA = dArchLocal.UMA;
-            m_dArchitecture1[NodeIndex].CacheCoherentUMA = dArchLocal.CacheCoherentUMA;
-            m_dArchitecture1[NodeIndex].IsolatedMMU = false;
-        }
-
-        m_dSerialization[NodeIndex].NodeIndex = NodeIndex;
-        if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_SERIALIZATION, &m_dSerialization[NodeIndex], sizeof(m_dSerialization[NodeIndex]))))
-        {
-            m_dSerialization[NodeIndex].HeapSerializationTier = D3D12_HEAP_SERIALIZATION_TIER_0;
-        }
-
-        m_dProtectedResourceSessionTypeCount[NodeIndex].NodeIndex = NodeIndex;
-        if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT, &m_dProtectedResourceSessionTypeCount[NodeIndex], sizeof(m_dProtectedResourceSessionTypeCount[NodeIndex]))))
-        {
-            m_dProtectedResourceSessionTypeCount[NodeIndex].Count = 0;
-        }
-
-        // Special procedure to initialize local protected resource session types structs
-        // Must wait until session type count initialized
-        QueryProtectedResourceSessionTypes(NodeIndex, m_dProtectedResourceSessionTypeCount[NodeIndex].Count);
-    }
-
-    // Initialize features that requires highest version check
-    if (FAILED(m_hStatus = QueryHighestShaderModel()))
-    {
-        return m_hStatus;
-    }
-
-    if (FAILED(m_hStatus = QueryHighestRootSignatureVersion()))
-    {
-        return m_hStatus;
-    }
-
-    // Initialize Feature Levels data
-    if (FAILED(m_hStatus = QueryHighestFeatureLevel()))
-    {
-        return m_hStatus;
-    }
-
-    return m_hStatus;
-}
-
-// 0: D3D12_OPTIONS
-FEATURE_SUPPORT_GET(BOOL, m_dOptions, DoublePrecisionFloatShaderOps);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions, OutputMergerLogicOp);
-FEATURE_SUPPORT_GET(D3D12_SHADER_MIN_PRECISION_SUPPORT, m_dOptions, MinPrecisionSupport);
-FEATURE_SUPPORT_GET(D3D12_TILED_RESOURCES_TIER, m_dOptions, TiledResourcesTier);
-FEATURE_SUPPORT_GET(D3D12_RESOURCE_BINDING_TIER, m_dOptions, ResourceBindingTier);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions, PSSpecifiedStencilRefSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions, TypedUAVLoadAdditionalFormats);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions, ROVsSupported);
-FEATURE_SUPPORT_GET(D3D12_CONSERVATIVE_RASTERIZATION_TIER, m_dOptions, ConservativeRasterizationTier);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions, StandardSwizzle64KBSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions, CrossAdapterRowMajorTextureSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions, VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation);
-FEATURE_SUPPORT_GET(D3D12_RESOURCE_HEAP_TIER, m_dOptions, ResourceHeapTier);
-
-// Special procedure for handling caps that is also part of other features
-inline D3D12_CROSS_NODE_SHARING_TIER CD3DX12FeatureSupport::CrossNodeSharingTier() const noexcept
-{
-    if (m_dCrossNode.SharingTier > D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED)
-    {
-        return m_dCrossNode.SharingTier;
-    }
-    else
-    {
-        return m_dOptions.CrossNodeSharingTier;
-    }
-}
-
-inline UINT CD3DX12FeatureSupport::MaxGPUVirtualAddressBitsPerResource() const noexcept
-{
-    if (m_dOptions.MaxGPUVirtualAddressBitsPerResource > 0)
-    {
-        return m_dOptions.MaxGPUVirtualAddressBitsPerResource;
-    }
-    else
-    {
-        return m_dGPUVASupport.MaxGPUVirtualAddressBitsPerResource;
-    }
-}
-
-// 1: Architecture
-// Combined with Architecture1
-
-// 2: Feature Levels
-// Simply returns the highest supported feature level
-inline D3D_FEATURE_LEVEL CD3DX12FeatureSupport::MaxSupportedFeatureLevel() const noexcept
-{
-    return m_eMaxFeatureLevel;
-}
-
-// 3: Feature Format Support
-inline HRESULT CD3DX12FeatureSupport::FormatSupport(DXGI_FORMAT Format, D3D12_FORMAT_SUPPORT1& Support1, D3D12_FORMAT_SUPPORT2& Support2) const
-{
-    D3D12_FEATURE_DATA_FORMAT_SUPPORT dFormatSupport;
-    dFormatSupport.Format = Format;
-
-    // It is possible that the function call returns an error
-    HRESULT result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &dFormatSupport, sizeof(D3D12_FEATURE_DATA_FORMAT_SUPPORT));
-
-    Support1 = dFormatSupport.Support1;
-    Support2 = dFormatSupport.Support2; // Two outputs. Probably better just to take in the struct as an argument?
-
-    return result;
-}
-
-// 4: Multisample Quality Levels
-inline HRESULT CD3DX12FeatureSupport::MultisampleQualityLevels(DXGI_FORMAT Format, UINT SampleCount, D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags, UINT& NumQualityLevels) const
-{
-    D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS dMultisampleQualityLevels;
-    dMultisampleQualityLevels.Format = Format;
-    dMultisampleQualityLevels.SampleCount = SampleCount;
-    dMultisampleQualityLevels.Flags = Flags;
-
-    HRESULT result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS, &dMultisampleQualityLevels, sizeof(D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS));
-
-    if (SUCCEEDED(result))
-    {
-        NumQualityLevels = dMultisampleQualityLevels.NumQualityLevels;
-    }
-    else
-    {
-        NumQualityLevels = 0;
-    }
-
-    return result;
-}
-
-// 5: Format Info
-inline HRESULT CD3DX12FeatureSupport::FormatInfo(DXGI_FORMAT Format, UINT8& PlaneCount) const
-{
-    D3D12_FEATURE_DATA_FORMAT_INFO dFormatInfo;
-    dFormatInfo.Format = Format;
-
-    HRESULT result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &dFormatInfo, sizeof(D3D12_FEATURE_DATA_FORMAT_INFO));
-    if (FAILED(result))
-    {
-        PlaneCount = 0;
-    }
-    else
-    {
-        PlaneCount = dFormatInfo.PlaneCount;
-    }
-    return result;
-}
-
-// 6: GPU Virtual Address Support
-// MaxGPUVirtualAddressBitsPerResource handled in D3D12Options
-FEATURE_SUPPORT_GET(UINT, m_dGPUVASupport, MaxGPUVirtualAddressBitsPerProcess);
-
-// 7: Shader Model
-inline D3D_SHADER_MODEL CD3DX12FeatureSupport::HighestShaderModel() const noexcept
-{
-    return m_dShaderModel.HighestShaderModel;
-}
-
-// 8: D3D12 Options1
-FEATURE_SUPPORT_GET(BOOL, m_dOptions1, WaveOps);
-FEATURE_SUPPORT_GET(UINT, m_dOptions1, WaveLaneCountMin);
-FEATURE_SUPPORT_GET(UINT, m_dOptions1, WaveLaneCountMax);
-FEATURE_SUPPORT_GET(UINT, m_dOptions1, TotalLaneCount);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions1, ExpandedComputeResourceStates);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions1, Int64ShaderOps);
-
-// 10: Protected Resource Session Support
-inline D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS CD3DX12FeatureSupport::ProtectedResourceSessionSupport(UINT NodeIndex) const
-{
-    return m_dProtectedResourceSessionSupport[NodeIndex].Support;
-}
-
-// 12: Root Signature
-inline D3D_ROOT_SIGNATURE_VERSION CD3DX12FeatureSupport::HighestRootSignatureVersion() const noexcept
-{
-    return m_dRootSignature.HighestVersion;
-}
-
-// 16: Architecture1
-// Same data fields can be queried from m_dArchitecture
-FEATURE_SUPPORT_GET_NODE_INDEXED(BOOL, m_dArchitecture1, TileBasedRenderer);
-FEATURE_SUPPORT_GET_NODE_INDEXED(BOOL, m_dArchitecture1, UMA);
-FEATURE_SUPPORT_GET_NODE_INDEXED(BOOL, m_dArchitecture1, CacheCoherentUMA);
-FEATURE_SUPPORT_GET_NODE_INDEXED(BOOL, m_dArchitecture1, IsolatedMMU);
-
-// 18: D3D12 Options2
-FEATURE_SUPPORT_GET(BOOL, m_dOptions2, DepthBoundsTestSupported);
-FEATURE_SUPPORT_GET(D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER, m_dOptions2, ProgrammableSamplePositionsTier);
-
-// 19: Shader Cache
-FEATURE_SUPPORT_GET_NAME(D3D12_SHADER_CACHE_SUPPORT_FLAGS, m_dShaderCache, SupportFlags, ShaderCacheSupportFlags);
-
-// 20: Command Queue Priority
-inline BOOL CD3DX12FeatureSupport::CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE CommandListType, UINT Priority)
-{
-    m_dCommandQueuePriority.CommandListType = CommandListType;
-    m_dCommandQueuePriority.Priority = Priority;
-
-    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_COMMAND_QUEUE_PRIORITY, &m_dCommandQueuePriority, sizeof(D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY))))
-    {
-        return false;
-    }
-
-    return m_dCommandQueuePriority.PriorityForTypeIsSupported;
-}
-
-// 21: D3D12 Options3
-FEATURE_SUPPORT_GET(BOOL, m_dOptions3, CopyQueueTimestampQueriesSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions3, CastingFullyTypedFormatSupported);
-FEATURE_SUPPORT_GET(D3D12_COMMAND_LIST_SUPPORT_FLAGS, m_dOptions3, WriteBufferImmediateSupportFlags);
-FEATURE_SUPPORT_GET(D3D12_VIEW_INSTANCING_TIER, m_dOptions3, ViewInstancingTier);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions3, BarycentricsSupported);
-
-// 22: Existing Heaps
-FEATURE_SUPPORT_GET_NAME(BOOL, m_dExistingHeaps, Supported, ExistingHeapsSupported);
-
-// 23: D3D12 Options4
-FEATURE_SUPPORT_GET(BOOL, m_dOptions4, MSAA64KBAlignedTextureSupported);
-FEATURE_SUPPORT_GET(D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER, m_dOptions4, SharedResourceCompatibilityTier);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions4, Native16BitShaderOpsSupported);
-
-// 24: Serialization
-FEATURE_SUPPORT_GET_NODE_INDEXED(D3D12_HEAP_SERIALIZATION_TIER, m_dSerialization, HeapSerializationTier);
-
-// 25: Cross Node
-// CrossNodeSharingTier handled in D3D12Options
-FEATURE_SUPPORT_GET_NAME(BOOL, m_dCrossNode, AtomicShaderInstructions, CrossNodeAtomicShaderInstructions);
-
-// 27: D3D12 Options5
-FEATURE_SUPPORT_GET(BOOL, m_dOptions5, SRVOnlyTiledResourceTier3);
-FEATURE_SUPPORT_GET(D3D12_RENDER_PASS_TIER, m_dOptions5, RenderPassesTier);
-FEATURE_SUPPORT_GET(D3D12_RAYTRACING_TIER, m_dOptions5, RaytracingTier);
-
-// 28: Displayable
-FEATURE_SUPPORT_GET(BOOL, m_dDisplayable, DisplayableTexture);
-// SharedResourceCompatibilityTier handled in D3D12Options4
-
-// 30: D3D12 Options6
-FEATURE_SUPPORT_GET(BOOL, m_dOptions6, AdditionalShadingRatesSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions6, PerPrimitiveShadingRateSupportedWithViewportIndexing);
-FEATURE_SUPPORT_GET(D3D12_VARIABLE_SHADING_RATE_TIER, m_dOptions6, VariableShadingRateTier);
-FEATURE_SUPPORT_GET(UINT, m_dOptions6, ShadingRateImageTileSize);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions6, BackgroundProcessingSupported);
-
-// 31: Query Meta Command
-// Keep the original call routine
-inline HRESULT CD3DX12FeatureSupport::QueryMetaCommand(D3D12_FEATURE_DATA_QUERY_META_COMMAND& dQueryMetaCommand) const
-{
-    return m_pDevice->CheckFeatureSupport(D3D12_FEATURE_QUERY_META_COMMAND, &dQueryMetaCommand, sizeof(D3D12_FEATURE_DATA_QUERY_META_COMMAND));
-}
-
-// 32: D3D12 Options7
-FEATURE_SUPPORT_GET(D3D12_MESH_SHADER_TIER, m_dOptions7, MeshShaderTier);
-FEATURE_SUPPORT_GET(D3D12_SAMPLER_FEEDBACK_TIER, m_dOptions7, SamplerFeedbackTier);
-
-// 33: Protected Resource Session Type Count
-FEATURE_SUPPORT_GET_NODE_INDEXED_NAME(UINT, m_dProtectedResourceSessionTypeCount, Count, ProtectedResourceSessionTypeCount);
-
-// 34: Protected Resource Session Types
-FEATURE_SUPPORT_GET_NODE_INDEXED_NAME(std::vector<GUID>, m_dProtectedResourceSessionTypes, TypeVec, ProtectedResourceSessionTypes);
-
-// 36: Options8
-FEATURE_SUPPORT_GET(BOOL, m_dOptions8, UnalignedBlockTexturesSupported);
-
-// 37: Options9
-FEATURE_SUPPORT_GET(BOOL, m_dOptions9, MeshShaderPipelineStatsSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions9, MeshShaderSupportsFullRangeRenderTargetArrayIndex);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions9, AtomicInt64OnTypedResourceSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions9, AtomicInt64OnGroupSharedSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions9, DerivativesInMeshAndAmplificationShadersSupported);
-FEATURE_SUPPORT_GET(D3D12_WAVE_MMA_TIER, m_dOptions9, WaveMMATier);
-
-// 39: Options10
-FEATURE_SUPPORT_GET(BOOL, m_dOptions10, VariableRateShadingSumCombinerSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions10, MeshShaderPerPrimitiveShadingRateSupported);
-
-// 40: Options11
-FEATURE_SUPPORT_GET(BOOL, m_dOptions11, AtomicInt64OnDescriptorHeapResourceSupported);
-
-#if defined(NTDDI_WIN10_NI) || defined(USING_D3D12_AGILITY_SDK)
-// 41: Options12
-FEATURE_SUPPORT_GET(D3D12_TRI_STATE, m_dOptions12, MSPrimitivesPipelineStatisticIncludesCulledPrimitives);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions12, EnhancedBarriersSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions12, RelaxedFormatCastingSupported);
-
-// 42: Options13
-FEATURE_SUPPORT_GET(BOOL, m_dOptions13, UnrestrictedBufferTextureCopyPitchSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions13, UnrestrictedVertexElementAlignmentSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions13, InvertedViewportHeightFlipsYSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions13, InvertedViewportDepthFlipsZSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions13, TextureCopyBetweenDimensionsSupported);
-FEATURE_SUPPORT_GET(BOOL, m_dOptions13, AlphaBlendFactorSupported);
-#endif
-
-// Helper function to decide the highest shader model supported by the system
-// Stores the result in m_dShaderModel
-// Must be updated whenever a new shader model is added to the d3d12.h header
-inline HRESULT CD3DX12FeatureSupport::QueryHighestShaderModel()
-{
-    // Check support in descending order
-    HRESULT result;
-
-    const D3D_SHADER_MODEL allModelVersions[] =
-    {
-        D3D_SHADER_MODEL_6_7,
-        D3D_SHADER_MODEL_6_6,
-        D3D_SHADER_MODEL_6_5,
-        D3D_SHADER_MODEL_6_4,
-        D3D_SHADER_MODEL_6_3,
-        D3D_SHADER_MODEL_6_2,
-        D3D_SHADER_MODEL_6_1,
-        D3D_SHADER_MODEL_6_0,
-        D3D_SHADER_MODEL_5_1
-    };
-    constexpr size_t numModelVersions = sizeof(allModelVersions) / sizeof(D3D_SHADER_MODEL);
-
-    for (size_t i = 0; i < numModelVersions; i++)
-    {
-        m_dShaderModel.HighestShaderModel = allModelVersions[i];
-        result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_SHADER_MODEL, &m_dShaderModel, sizeof(D3D12_FEATURE_DATA_SHADER_MODEL));
-        if (result != E_INVALIDARG)
-        {
-            // Indicates that the version is recognizable by the runtime and stored in the struct
-            // Also terminate on unexpected error code
-            if (FAILED(result))
-            {
-                m_dShaderModel.HighestShaderModel = static_cast<D3D_SHADER_MODEL>(0);
-            }
-            return result;
-        }
-    }
-
-    // Shader model may not be supported. Continue the rest initializations
-    m_dShaderModel.HighestShaderModel = static_cast<D3D_SHADER_MODEL>(0);
-    return S_OK;
-}
-
-// Helper function to decide the highest root signature supported
-// Must be updated whenever a new root signature version is added to the d3d12.h header
-inline HRESULT CD3DX12FeatureSupport::QueryHighestRootSignatureVersion()
-{
-    HRESULT result;
-
-    const D3D_ROOT_SIGNATURE_VERSION allRootSignatureVersions[] =
-    {
-        D3D_ROOT_SIGNATURE_VERSION_1_1,
-        D3D_ROOT_SIGNATURE_VERSION_1_0,
-        D3D_ROOT_SIGNATURE_VERSION_1,
-    };
-    constexpr size_t numRootSignatureVersions = sizeof(allRootSignatureVersions) / sizeof(D3D_ROOT_SIGNATURE_VERSION);
-
-    for (size_t i = 0; i < numRootSignatureVersions; i++)
-    {
-        m_dRootSignature.HighestVersion = allRootSignatureVersions[i];
-        result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_ROOT_SIGNATURE, &m_dRootSignature, sizeof(D3D12_FEATURE_DATA_ROOT_SIGNATURE));
-        if (result != E_INVALIDARG)
-        {
-            if (FAILED(result))
-            {
-                m_dRootSignature.HighestVersion = static_cast<D3D_ROOT_SIGNATURE_VERSION>(0);
-            }
-            // If succeeded, the highest version is already written into the member struct
-            return result;
-        }
-    }
-
-    // No version left. Set to invalid value and continue.
-    m_dRootSignature.HighestVersion = static_cast<D3D_ROOT_SIGNATURE_VERSION>(0);
-    return S_OK;
-}
-
-// Helper funcion to decide the highest feature level
-inline HRESULT CD3DX12FeatureSupport::QueryHighestFeatureLevel()
-{
-    HRESULT result;
-
-    // Check against a list of all feature levels present in d3dcommon.h
-    // Needs to be updated for future feature levels
-    const D3D_FEATURE_LEVEL allLevels[] =
-    {
-        D3D_FEATURE_LEVEL_12_2,
-        D3D_FEATURE_LEVEL_12_1,
-        D3D_FEATURE_LEVEL_12_0,
-        D3D_FEATURE_LEVEL_11_1,
-        D3D_FEATURE_LEVEL_11_0,
-        D3D_FEATURE_LEVEL_10_1,
-        D3D_FEATURE_LEVEL_10_0,
-        D3D_FEATURE_LEVEL_9_3,
-        D3D_FEATURE_LEVEL_9_2,
-        D3D_FEATURE_LEVEL_9_1,
-        D3D_FEATURE_LEVEL_1_0_CORE
-    };
-
-    D3D12_FEATURE_DATA_FEATURE_LEVELS dFeatureLevel;
-    dFeatureLevel.NumFeatureLevels = static_cast<UINT>(sizeof(allLevels) / sizeof(D3D_FEATURE_LEVEL));
-    dFeatureLevel.pFeatureLevelsRequested = allLevels;
-
-    result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_FEATURE_LEVELS, &dFeatureLevel, sizeof(D3D12_FEATURE_DATA_FEATURE_LEVELS));
-    if (SUCCEEDED(result))
-    {
-        m_eMaxFeatureLevel = dFeatureLevel.MaxSupportedFeatureLevel;
-    }
-    else
-    {
-        m_eMaxFeatureLevel = static_cast<D3D_FEATURE_LEVEL>(0);
-
-        if (result == DXGI_ERROR_UNSUPPORTED)
-        {
-            // Indicates that none supported. Continue initialization
-            result = S_OK;
-        }
-    }
-    return result;
-}
-
-// Helper function to initialize local protected resource session types structs
-inline HRESULT CD3DX12FeatureSupport::QueryProtectedResourceSessionTypes(UINT NodeIndex, UINT Count)
-{
-    auto& CurrentPRSTypes = m_dProtectedResourceSessionTypes[NodeIndex];
-    CurrentPRSTypes.NodeIndex = NodeIndex;
-    CurrentPRSTypes.Count = Count;
-    CurrentPRSTypes.TypeVec.resize(CurrentPRSTypes.Count);
-    CurrentPRSTypes.pTypes = CurrentPRSTypes.TypeVec.data();
-
-    HRESULT result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES, &m_dProtectedResourceSessionTypes[NodeIndex], sizeof(D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES));
-    if (FAILED(result))
-    {
-        // Resize TypeVec to empty
-        CurrentPRSTypes.TypeVec.clear();
-    }
-
-    return result;
-}
-
-#undef FEATURE_SUPPORT_GET
-#undef FEATURE_SUPPORT_GET_NAME
-#undef FEATURE_SUPPORT_GET_NODE_INDEXED
-#undef FEATURE_SUPPORT_GET_NODE_INDEXED_NAME
-
-// end CD3DX12FeatureSupport
-
-#endif // !D3DX12_NO_CHECK_FEATURE_SUPPORT_CLASS
-
-#undef D3DX12_COM_PTR
-#undef D3DX12_COM_PTR_GET
-#undef D3DX12_COM_PTR_ADDRESSOF
-
-#endif // defined( __cplusplus )
-
-#endif //__D3DX12_H__
diff --git a/thirdparty/directxtex/filters.h b/thirdparty/directxtex/filters.h
deleted file mode 100644
index fb8a63f..0000000
--- a/thirdparty/directxtex/filters.h
+++ /dev/null
@@ -1,422 +0,0 @@
-//-------------------------------------------------------------------------------------
-// filters.h
-//
-// Utility header with helpers for implementing image filters
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-#include <DirectXMath.h>
-#include <DirectXPackedVector.h>
-
-#include <memory>
-
-#include "scoped.h"
-
-
-namespace DirectX
-{
-    namespace Filters
-    {
-        //-------------------------------------------------------------------------------------
-        // Box filtering helpers
-        //-------------------------------------------------------------------------------------
-
-        XMGLOBALCONST XMVECTORF32 g_boxScale = { { { 0.25f, 0.25f, 0.25f, 0.25f } } };
-        XMGLOBALCONST XMVECTORF32 g_boxScale3D = { { { 0.125f, 0.125f, 0.125f, 0.125f } } };
-
-    #define AVERAGE4( res, p0, p1, p2, p3 ) \
-{ \
-    XMVECTOR v = XMVectorAdd((p0), (p1)); \
-    v = XMVectorAdd(v, (p2)); \
-    v = XMVectorAdd(v, (p3)); \
-    res = XMVectorMultiply(v, g_boxScale); \
-}
-
-    #define AVERAGE8( res, p0, p1, p2, p3, p4, p5, p6, p7) \
-{ \
-    XMVECTOR v = XMVectorAdd((p0), (p1)); \
-    v = XMVectorAdd(v, (p2)); \
-    v = XMVectorAdd(v, (p3)); \
-    v = XMVectorAdd(v, (p4)); \
-    v = XMVectorAdd(v, (p5)); \
-    v = XMVectorAdd(v, (p6)); \
-    v = XMVectorAdd(v, (p7)); \
-    res = XMVectorMultiply(v, g_boxScale3D); \
-}
-
-
-        //-------------------------------------------------------------------------------------
-        // Linear filtering helpers
-        //-------------------------------------------------------------------------------------
-
-        struct LinearFilter
-        {
-            size_t  u0;
-            float   weight0;
-            size_t  u1;
-            float   weight1;
-        };
-
-        inline void CreateLinearFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Out_writes_(dest) LinearFilter* lf) noexcept
-        {
-            assert(source > 0);
-            assert(dest > 0);
-            assert(lf != nullptr);
-
-            const float scale = float(source) / float(dest);
-
-            // Mirror is the same case as clamp for linear
-
-            for (size_t u = 0; u < dest; ++u)
-            {
-                const float srcB = (float(u) + 0.5f) * scale + 0.5f;
-
-                ptrdiff_t isrcB = ptrdiff_t(srcB);
-                ptrdiff_t isrcA = isrcB - 1;
-
-                const float weight = 1.0f + float(isrcB) - srcB;
-
-                if (isrcA < 0)
-                {
-                    isrcA = (wrap) ? (ptrdiff_t(source) - 1) : 0;
-                }
-
-                if (size_t(isrcB) >= source)
-                {
-                    isrcB = (wrap) ? 0 : (ptrdiff_t(source) - 1);
-                }
-
-                auto& entry = lf[u];
-                entry.u0 = size_t(isrcA);
-                entry.weight0 = weight;
-
-                entry.u1 = size_t(isrcB);
-                entry.weight1 = 1.0f - weight;
-            }
-        }
-
-    #define BILINEAR_INTERPOLATE( res, x, y, r0, r1 ) \
-    res = XMVectorAdd(XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0), \
-                      XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1) );
-
-    #define TRILINEAR_INTERPOLATE( res, x, y, z, r0, r1, r2, r3 ) \
-{\
-    const XMVECTOR a0 = XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0 ), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0); \
-    const XMVECTOR a1 = XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0 ), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1); \
-    const XMVECTOR a2 = XMVectorScale(XMVectorAdd(XMVectorScale((r2)[ x.u0 ], x.weight0 ), XMVectorScale((r2)[ x.u1 ], x.weight1)), y.weight0); \
-    const XMVECTOR a3 = XMVectorScale(XMVectorAdd(XMVectorScale((r3)[ x.u0 ], x.weight0 ), XMVectorScale((r3)[ x.u1 ], x.weight1)), y.weight1); \
-    res = XMVectorAdd(XMVectorScale(XMVectorAdd(a0, a1), z.weight0), XMVectorScale(XMVectorAdd(a2, a3), z.weight1)); \
-}
-
-        //-------------------------------------------------------------------------------------
-        // Cubic filtering helpers
-        //-------------------------------------------------------------------------------------
-
-        XMGLOBALCONST XMVECTORF32 g_cubicThird = { { { 1.f / 3.f, 1.f / 3.f, 1.f / 3.f, 1.f / 3.f } } };
-        XMGLOBALCONST XMVECTORF32 g_cubicSixth = { { { 1.f / 6.f, 1.f / 6.f, 1.f / 6.f, 1.f / 6.f } } };
-        XMGLOBALCONST XMVECTORF32 g_cubicHalf = { { { 1.f / 2.f, 1.f / 2.f, 1.f / 2.f, 1.f / 2.f } } };
-
-        constexpr ptrdiff_t bounduvw(ptrdiff_t u, ptrdiff_t maxu, bool wrap, bool mirror) noexcept
-        {
-            if (wrap)
-            {
-                if (u < 0)
-                {
-                    u = maxu + u + 1;
-                }
-                else if (u > maxu)
-                {
-                    u = u - maxu - 1;
-                }
-            }
-            else if (mirror)
-            {
-                if (u < 0)
-                {
-                    u = (-u) - 1;
-                }
-                else if (u > maxu)
-                {
-                    u = maxu - (u - maxu - 1);
-                }
-            }
-
-            // Handles clamp, but also a safety factor for degenerate images for wrap/mirror
-            u = std::min<ptrdiff_t>(u, maxu);
-            u = std::max<ptrdiff_t>(u, 0);
-
-            return u;
-        }
-
-        struct CubicFilter
-        {
-            size_t  u0;
-            size_t  u1;
-            size_t  u2;
-            size_t  u3;
-            float   x;
-        };
-
-        inline void CreateCubicFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _In_ bool mirror, _Out_writes_(dest) CubicFilter* cf) noexcept
-        {
-            assert(source > 0);
-            assert(dest > 0);
-            assert(cf != nullptr);
-
-            const float scale = float(source) / float(dest);
-
-            for (size_t u = 0; u < dest; ++u)
-            {
-                const float srcB = (float(u) + 0.5f) * scale - 0.5f;
-
-                const ptrdiff_t isrcB = bounduvw(ptrdiff_t(srcB), ptrdiff_t(source) - 1, wrap, mirror);
-                const ptrdiff_t isrcA = bounduvw(isrcB - 1, ptrdiff_t(source) - 1, wrap, mirror);
-                const ptrdiff_t isrcC = bounduvw(isrcB + 1, ptrdiff_t(source) - 1, wrap, mirror);
-                const ptrdiff_t isrcD = bounduvw(isrcB + 2, ptrdiff_t(source) - 1, wrap, mirror);
-
-                auto& entry = cf[u];
-                entry.u0 = size_t(isrcA);
-                entry.u1 = size_t(isrcB);
-                entry.u2 = size_t(isrcC);
-                entry.u3 = size_t(isrcD);
-
-                const float x = srcB - float(isrcB);
-                entry.x = x;
-            }
-        }
-
-    #define CUBIC_INTERPOLATE( res, dx, p0, p1, p2, p3 ) \
-{ \
-    const XMVECTOR a0 = (p1); \
-    const XMVECTOR d0 = XMVectorSubtract(p0, a0); \
-    const XMVECTOR d2 = XMVectorSubtract(p2, a0); \
-    const XMVECTOR d3 = XMVectorSubtract(p3, a0); \
-    XMVECTOR a1 = XMVectorSubtract(d2, XMVectorMultiply(g_cubicThird, d0)); \
-    a1 = XMVectorSubtract(a1, XMVectorMultiply(g_cubicSixth, d3)); \
-    const XMVECTOR a2 = XMVectorAdd(XMVectorMultiply(g_cubicHalf, d0), XMVectorMultiply(g_cubicHalf, d2)); \
-    XMVECTOR a3 = XMVectorSubtract(XMVectorMultiply(g_cubicSixth, d3), XMVectorMultiply(g_cubicSixth, d0)); \
-    a3 = XMVectorSubtract(a3, XMVectorMultiply(g_cubicHalf, d2)); \
-    const XMVECTOR vdx = XMVectorReplicate(dx); \
-    const XMVECTOR vdx2 = XMVectorMultiply(vdx, vdx); \
-    const XMVECTOR vdx3 = XMVectorMultiply(vdx2, vdx); \
-    res = XMVectorAdd(XMVectorAdd(XMVectorAdd(a0, XMVectorMultiply(a1, vdx)), XMVectorMultiply(a2, vdx2)), XMVectorMultiply(a3, vdx3)); \
-}
-
-
-        //-------------------------------------------------------------------------------------
-        // Triangle filtering helpers
-        //-------------------------------------------------------------------------------------
-
-        struct FilterTo
-        {
-            size_t      u;
-            float       weight;
-        };
-
-        struct FilterFrom
-        {
-            size_t      count;
-            size_t      sizeInBytes;
-            FilterTo    to[1]; // variable-sized array
-        };
-
-        struct Filter
-        {
-            size_t      sizeInBytes;
-            size_t      totalSize;
-            FilterFrom  from[1]; // variable-sized array
-        };
-
-        struct TriangleRow
-        {
-            size_t                      remaining;
-            TriangleRow* next;
-            ScopedAlignedArrayXMVECTOR  scanline;
-
-            TriangleRow() noexcept : remaining(0), next(nullptr) {}
-        };
-
-        constexpr size_t TF_FILTER_SIZE = sizeof(Filter) - sizeof(FilterFrom);
-        constexpr size_t TF_FROM_SIZE = sizeof(FilterFrom) - sizeof(FilterTo);
-        constexpr size_t TF_TO_SIZE = sizeof(FilterTo);
-
-        constexpr float TF_EPSILON = 0.00001f;
-
-        inline HRESULT CreateTriangleFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Inout_ std::unique_ptr<Filter>& tf) noexcept
-        {
-            assert(source > 0);
-            assert(dest > 0);
-
-            const float scale = float(dest) / float(source);
-            const float scaleInv = 0.5f / scale;
-
-            // Determine storage required for filter and allocate memory if needed
-            size_t totalSize = TF_FILTER_SIZE + TF_FROM_SIZE + TF_TO_SIZE;
-            const float repeat = (wrap) ? 1.f : 0.f;
-
-            for (size_t u = 0; u < source; ++u)
-            {
-                const float src = float(u) - 0.5f;
-                const float destMin = src * scale;
-                const float destMax = destMin + scale;
-                const float t = destMax - destMin + repeat + 1.f;
-                totalSize += TF_FROM_SIZE + TF_TO_SIZE + size_t(t) * TF_TO_SIZE * 2;
-            }
-
-            uint8_t* pFilter = nullptr;
-
-            if (tf)
-            {
-                // See if existing filter memory block is large enough to reuse
-                if (tf->totalSize >= totalSize)
-                {
-                    pFilter = reinterpret_cast<uint8_t*>(tf.get());
-                }
-                else
-                {
-                    // Need to reallocate filter memory block
-                    tf.reset(nullptr);
-                }
-            }
-
-            if (!tf)
-            {
-                // Allocate filter memory block
-                pFilter = new (std::nothrow) uint8_t[totalSize];
-                if (!pFilter)
-                    return E_OUTOFMEMORY;
-
-                tf.reset(reinterpret_cast<Filter*>(pFilter));
-                tf->totalSize = totalSize;
-            }
-
-            assert(pFilter != nullptr);
-            _Analysis_assume_(pFilter != nullptr);
-
-            // Filter setup
-            size_t sizeInBytes = TF_FILTER_SIZE;
-            size_t accumU = 0;
-            float accumWeight = 0.f;
-
-            for (size_t u = 0; u < source; ++u)
-            {
-                // Setup from entry
-                const size_t sizeFrom = sizeInBytes;
-                auto pFrom = reinterpret_cast<FilterFrom*>(pFilter + sizeInBytes);
-                sizeInBytes += TF_FROM_SIZE;
-
-                if (sizeInBytes > totalSize)
-                    return E_FAIL;
-
-                size_t toCount = 0;
-
-                // Perform two passes to capture the influences from both sides
-                for (size_t j = 0; j < 2; ++j)
-                {
-                    const float src = float(u + j) - 0.5f;
-
-                    float destMin = src * scale;
-                    float destMax = destMin + scale;
-
-                    if (!wrap)
-                    {
-                        // Clamp
-                        if (destMin < 0.f)
-                            destMin = 0.f;
-                        if (destMax > float(dest))
-                            destMax = float(dest);
-                    }
-
-                    for (auto k = static_cast<ptrdiff_t>(floorf(destMin)); float(k) < destMax; ++k)
-                    {
-                        float d0 = float(k);
-                        float d1 = d0 + 1.f;
-
-                        size_t u0;
-                        if (k < 0)
-                        {
-                            // Handle wrap
-                            u0 = size_t(k + ptrdiff_t(dest));
-                        }
-                        else if (k >= ptrdiff_t(dest))
-                        {
-                            // Handle wrap
-                            u0 = size_t(k - ptrdiff_t(dest));
-                        }
-                        else
-                        {
-                            u0 = size_t(k);
-                        }
-
-                        // Save previous accumulated weight (if any)
-                        if (u0 != accumU)
-                        {
-                            if (accumWeight > TF_EPSILON)
-                            {
-                                auto pTo = reinterpret_cast<FilterTo*>(pFilter + sizeInBytes);
-                                sizeInBytes += TF_TO_SIZE;
-                                ++toCount;
-
-                                if (sizeInBytes > totalSize)
-                                    return E_FAIL;
-
-                                pTo->u = accumU;
-                                pTo->weight = accumWeight;
-                            }
-
-                            accumWeight = 0.f;
-                            accumU = u0;
-                        }
-
-                        // Clip destination
-                        if (d0 < destMin)
-                            d0 = destMin;
-                        if (d1 > destMax)
-                            d1 = destMax;
-
-                        // Calculate average weight over destination pixel
-
-                        float weight;
-                        if (!wrap && src < 0.f)
-                            weight = 1.f;
-                        else if (!wrap && ((src + 1.f) >= float(source)))
-                            weight = 0.f;
-                        else
-                            weight = (d0 + d1) * scaleInv - src;
-
-                        accumWeight += (d1 - d0) * (j ? (1.f - weight) : weight);
-                    }
-                }
-
-                // Store accumulated weight
-                if (accumWeight > TF_EPSILON)
-                {
-                    auto pTo = reinterpret_cast<FilterTo*>(pFilter + sizeInBytes);
-                    sizeInBytes += TF_TO_SIZE;
-                    ++toCount;
-
-                    if (sizeInBytes > totalSize)
-                        return E_FAIL;
-
-                    pTo->u = accumU;
-                    pTo->weight = accumWeight;
-                }
-
-                accumWeight = 0.f;
-
-                // Finalize from entry
-                pFrom->count = toCount;
-                pFrom->sizeInBytes = sizeInBytes - sizeFrom;
-            }
-
-            tf->sizeInBytes = sizeInBytes;
-
-            return S_OK;
-        }
-
-    } // namespace Filters
-} // namespace DirectX
diff --git a/thirdparty/directxtex/scoped.h b/thirdparty/directxtex/scoped.h
deleted file mode 100644
index 363c393..0000000
--- a/thirdparty/directxtex/scoped.h
+++ /dev/null
@@ -1,112 +0,0 @@
-//-------------------------------------------------------------------------------------
-// scoped.h
-//
-// Utility header with helper classes for exception-safe handling of resources
-//
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-//-------------------------------------------------------------------------------------
-
-#pragma once
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <tuple>
-
-#ifndef _WIN32
-#include <cstdlib>
-
-struct aligned_deleter { void operator()(void* p) noexcept { free(p); } };
-
-using ScopedAlignedArrayFloat = std::unique_ptr<float[], aligned_deleter>;
-
-inline ScopedAlignedArrayFloat make_AlignedArrayFloat(uint64_t count)
-{
-    uint64_t size = sizeof(float) * count;
-    size = (size + 15u) & ~0xF;
-    if (size > static_cast<uint64_t>(UINT32_MAX))
-        return nullptr;
-
-    auto ptr = aligned_alloc(16, static_cast<size_t>(size));
-    return ScopedAlignedArrayFloat(static_cast<float*>(ptr));
-}
-
-using ScopedAlignedArrayXMVECTOR = std::unique_ptr<DirectX::XMVECTOR[], aligned_deleter>;
-
-inline ScopedAlignedArrayXMVECTOR make_AlignedArrayXMVECTOR(uint64_t count)
-{
-    uint64_t size = sizeof(DirectX::XMVECTOR) * count;
-    if (size > static_cast<uint64_t>(UINT32_MAX))
-        return nullptr;
-    auto ptr = aligned_alloc(16, static_cast<size_t>(size));
-    return ScopedAlignedArrayXMVECTOR(static_cast<DirectX::XMVECTOR*>(ptr));
-}
-
-#else // WIN32
-//---------------------------------------------------------------------------------
-#include <malloc.h>
-
-struct aligned_deleter { void operator()(void* p) noexcept { _aligned_free(p); } };
-
-using ScopedAlignedArrayFloat = std::unique_ptr<float[], aligned_deleter>;
-
-inline ScopedAlignedArrayFloat make_AlignedArrayFloat(uint64_t count)
-{
-    const uint64_t size = sizeof(float) * count;
-    if (size > static_cast<uint64_t>(UINT32_MAX))
-        return nullptr;
-    auto ptr = _aligned_malloc(static_cast<size_t>(size), 16);
-    return ScopedAlignedArrayFloat(static_cast<float*>(ptr));
-}
-
-using ScopedAlignedArrayXMVECTOR = std::unique_ptr<DirectX::XMVECTOR[], aligned_deleter>;
-
-inline ScopedAlignedArrayXMVECTOR make_AlignedArrayXMVECTOR(uint64_t count)
-{
-    const uint64_t size = sizeof(DirectX::XMVECTOR) * count;
-    if (size > static_cast<uint64_t>(UINT32_MAX))
-        return nullptr;
-    auto ptr = _aligned_malloc(static_cast<size_t>(size), 16);
-    return ScopedAlignedArrayXMVECTOR(static_cast<DirectX::XMVECTOR*>(ptr));
-}
-
-//---------------------------------------------------------------------------------
-struct handle_closer { void operator()(HANDLE h) noexcept { assert(h != INVALID_HANDLE_VALUE); if (h) CloseHandle(h); } };
-
-using ScopedHandle = std::unique_ptr<void, handle_closer>;
-
-inline HANDLE safe_handle(HANDLE h) noexcept { return (h == INVALID_HANDLE_VALUE) ? nullptr : h; }
-
-//---------------------------------------------------------------------------------
-struct find_closer { void operator()(HANDLE h) noexcept { assert(h != INVALID_HANDLE_VALUE); if (h) FindClose(h); } };
-
-using ScopedFindHandle = std::unique_ptr<void, find_closer>;
-
-//---------------------------------------------------------------------------------
-class auto_delete_file
-{
-public:
-    auto_delete_file(HANDLE hFile) noexcept : m_handle(hFile) {}
-
-    auto_delete_file(const auto_delete_file&) = delete;
-    auto_delete_file& operator=(const auto_delete_file&) = delete;
-
-    ~auto_delete_file()
-    {
-        if (m_handle)
-        {
-            FILE_DISPOSITION_INFO info = {};
-            info.DeleteFile = TRUE;
-            std::ignore = SetFileInformationByHandle(m_handle, FileDispositionInfo, &info, sizeof(info));
-        }
-    }
-
-    void clear() noexcept { m_handle = nullptr; }
-
-private:
-    HANDLE m_handle;
-};
-
-#endif // WIN32
diff --git a/thirdparty/json/LICENSE.MIT b/thirdparty/json/LICENSE.MIT
deleted file mode 100644
index f0622d6..0000000
--- a/thirdparty/json/LICENSE.MIT
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License 
-
-Copyright (c) 2013-2021 Niels Lohmann
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/thirdparty/json/json.hpp b/thirdparty/json/json.hpp
deleted file mode 100644
index a70aaf8..0000000
--- a/thirdparty/json/json.hpp
+++ /dev/null
@@ -1,25447 +0,0 @@
-/*
-    __ _____ _____ _____
- __|  |   __|     |   | |  JSON for Modern C++
-|  |  |__   |  |  | | | |  version 3.9.1
-|_____|_____|_____|_|___|  https://github.com/nlohmann/json
-
-Licensed under the MIT License <http://opensource.org/licenses/MIT>.
-SPDX-License-Identifier: MIT
-Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
-
-Permission is hereby  granted, free of charge, to any  person obtaining a copy
-of this software and associated  documentation files (the "Software"), to deal
-in the Software  without restriction, including without  limitation the rights
-to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
-copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
-IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
-FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
-AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
-LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-#ifndef INCLUDE_NLOHMANN_JSON_HPP_
-#define INCLUDE_NLOHMANN_JSON_HPP_
-
-#define NLOHMANN_JSON_VERSION_MAJOR 3
-#define NLOHMANN_JSON_VERSION_MINOR 9
-#define NLOHMANN_JSON_VERSION_PATCH 1
-
-#include <algorithm> // all_of, find, for_each
-#include <cstddef> // nullptr_t, ptrdiff_t, size_t
-#include <functional> // hash, less
-#include <initializer_list> // initializer_list
-#include <iosfwd> // istream, ostream
-#include <iterator> // random_access_iterator_tag
-#include <memory> // unique_ptr
-#include <numeric> // accumulate
-#include <string> // string, stoi, to_string
-#include <utility> // declval, forward, move, pair, swap
-#include <vector> // vector
-
-// #include <nlohmann/adl_serializer.hpp>
-
-
-#include <utility>
-
-// #include <nlohmann/detail/conversions/from_json.hpp>
-
-
-#include <algorithm> // transform
-#include <array> // array
-#include <forward_list> // forward_list
-#include <iterator> // inserter, front_inserter, end
-#include <map> // map
-#include <string> // string
-#include <tuple> // tuple, make_tuple
-#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
-#include <unordered_map> // unordered_map
-#include <utility> // pair, declval
-#include <valarray> // valarray
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-
-#include <exception> // exception
-#include <stdexcept> // runtime_error
-#include <string> // to_string
-
-// #include <nlohmann/detail/input/position_t.hpp>
-
-
-#include <cstddef> // size_t
-
-namespace nlohmann
-{
-namespace detail
-{
-/// struct to capture the start position of the current token
-struct position_t
-{
-    /// the total number of characters read
-    std::size_t chars_read_total = 0;
-    /// the number of characters read in the current line
-    std::size_t chars_read_current_line = 0;
-    /// the number of lines read
-    std::size_t lines_read = 0;
-
-    /// conversion to size_t to preserve SAX interface
-    constexpr operator size_t() const
-    {
-        return chars_read_total;
-    }
-};
-
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-
-#include <utility> // pair
-// #include <nlohmann/thirdparty/hedley/hedley.hpp>
-/* Hedley - https://nemequ.github.io/hedley
- * Created by Evan Nemerson <evan@nemerson.com>
- *
- * To the extent possible under law, the author(s) have dedicated all
- * copyright and related and neighboring rights to this software to
- * the public domain worldwide. This software is distributed without
- * any warranty.
- *
- * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
- * SPDX-License-Identifier: CC0-1.0
- */
-
-#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 13)
-#if defined(JSON_HEDLEY_VERSION)
-    #undef JSON_HEDLEY_VERSION
-#endif
-#define JSON_HEDLEY_VERSION 13
-
-#if defined(JSON_HEDLEY_STRINGIFY_EX)
-    #undef JSON_HEDLEY_STRINGIFY_EX
-#endif
-#define JSON_HEDLEY_STRINGIFY_EX(x) #x
-
-#if defined(JSON_HEDLEY_STRINGIFY)
-    #undef JSON_HEDLEY_STRINGIFY
-#endif
-#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
-
-#if defined(JSON_HEDLEY_CONCAT_EX)
-    #undef JSON_HEDLEY_CONCAT_EX
-#endif
-#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
-
-#if defined(JSON_HEDLEY_CONCAT)
-    #undef JSON_HEDLEY_CONCAT
-#endif
-#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
-
-#if defined(JSON_HEDLEY_CONCAT3_EX)
-    #undef JSON_HEDLEY_CONCAT3_EX
-#endif
-#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
-
-#if defined(JSON_HEDLEY_CONCAT3)
-    #undef JSON_HEDLEY_CONCAT3
-#endif
-#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
-
-#if defined(JSON_HEDLEY_VERSION_ENCODE)
-    #undef JSON_HEDLEY_VERSION_ENCODE
-#endif
-#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
-
-#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
-    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
-#endif
-#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
-
-#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
-    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
-#endif
-#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
-
-#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
-    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
-#endif
-#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
-
-#if defined(JSON_HEDLEY_GNUC_VERSION)
-    #undef JSON_HEDLEY_GNUC_VERSION
-#endif
-#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
-    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
-#elif defined(__GNUC__)
-    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
-    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_GNUC_VERSION)
-    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_MSVC_VERSION)
-    #undef JSON_HEDLEY_MSVC_VERSION
-#endif
-#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
-    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
-#elif defined(_MSC_FULL_VER)
-    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
-#elif defined(_MSC_VER)
-    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
-#endif
-
-#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
-    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
-#endif
-#if !defined(_MSC_VER)
-    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
-#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
-    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
-#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
-    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
-#else
-    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
-#endif
-
-#if defined(JSON_HEDLEY_INTEL_VERSION)
-    #undef JSON_HEDLEY_INTEL_VERSION
-#endif
-#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
-    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
-#elif defined(__INTEL_COMPILER)
-    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
-#endif
-
-#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
-    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_INTEL_VERSION)
-    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_PGI_VERSION)
-    #undef JSON_HEDLEY_PGI_VERSION
-#endif
-#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
-    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
-#endif
-
-#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
-    #undef JSON_HEDLEY_PGI_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_PGI_VERSION)
-    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_SUNPRO_VERSION)
-    #undef JSON_HEDLEY_SUNPRO_VERSION
-#endif
-#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
-    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
-#elif defined(__SUNPRO_C)
-    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
-#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
-    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
-#elif defined(__SUNPRO_CC)
-    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
-#endif
-
-#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
-    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_SUNPRO_VERSION)
-    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
-    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
-#endif
-#if defined(__EMSCRIPTEN__)
-    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
-#endif
-
-#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
-    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
-    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_ARM_VERSION)
-    #undef JSON_HEDLEY_ARM_VERSION
-#endif
-#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
-    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
-#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
-    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
-#endif
-
-#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
-    #undef JSON_HEDLEY_ARM_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_ARM_VERSION)
-    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_IBM_VERSION)
-    #undef JSON_HEDLEY_IBM_VERSION
-#endif
-#if defined(__ibmxl__)
-    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
-#elif defined(__xlC__) && defined(__xlC_ver__)
-    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
-#elif defined(__xlC__)
-    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
-#endif
-
-#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
-    #undef JSON_HEDLEY_IBM_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_IBM_VERSION)
-    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_VERSION)
-    #undef JSON_HEDLEY_TI_VERSION
-#endif
-#if \
-    defined(__TI_COMPILER_VERSION__) && \
-    ( \
-      defined(__TMS470__) || defined(__TI_ARM__) || \
-      defined(__MSP430__) || \
-      defined(__TMS320C2000__) \
-    )
-#if (__TI_COMPILER_VERSION__ >= 16000000)
-    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
-#endif
-#endif
-
-#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
-    #undef JSON_HEDLEY_TI_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_VERSION)
-    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
-    #undef JSON_HEDLEY_TI_CL2000_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
-    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
-    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
-    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL430_VERSION)
-    #undef JSON_HEDLEY_TI_CL430_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
-    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
-    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CL430_VERSION)
-    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
-    #undef JSON_HEDLEY_TI_ARMCL_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
-    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
-    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
-    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
-    #undef JSON_HEDLEY_TI_CL6X_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
-    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
-    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
-    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
-    #undef JSON_HEDLEY_TI_CL7X_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
-    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
-    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
-    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
-    #undef JSON_HEDLEY_TI_CLPRU_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
-    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
-    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
-    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_CRAY_VERSION)
-    #undef JSON_HEDLEY_CRAY_VERSION
-#endif
-#if defined(_CRAYC)
-    #if defined(_RELEASE_PATCHLEVEL)
-        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
-    #else
-        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
-    #endif
-#endif
-
-#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
-    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_CRAY_VERSION)
-    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_IAR_VERSION)
-    #undef JSON_HEDLEY_IAR_VERSION
-#endif
-#if defined(__IAR_SYSTEMS_ICC__)
-    #if __VER__ > 1000
-        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
-    #else
-        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
-    #endif
-#endif
-
-#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
-    #undef JSON_HEDLEY_IAR_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_IAR_VERSION)
-    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TINYC_VERSION)
-    #undef JSON_HEDLEY_TINYC_VERSION
-#endif
-#if defined(__TINYC__)
-    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
-#endif
-
-#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
-    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TINYC_VERSION)
-    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_DMC_VERSION)
-    #undef JSON_HEDLEY_DMC_VERSION
-#endif
-#if defined(__DMC__)
-    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
-#endif
-
-#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
-    #undef JSON_HEDLEY_DMC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_DMC_VERSION)
-    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_COMPCERT_VERSION)
-    #undef JSON_HEDLEY_COMPCERT_VERSION
-#endif
-#if defined(__COMPCERT_VERSION__)
-    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
-#endif
-
-#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
-    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_COMPCERT_VERSION)
-    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_PELLES_VERSION)
-    #undef JSON_HEDLEY_PELLES_VERSION
-#endif
-#if defined(__POCC__)
-    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
-#endif
-
-#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
-    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_PELLES_VERSION)
-    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_VERSION)
-    #undef JSON_HEDLEY_GCC_VERSION
-#endif
-#if \
-    defined(JSON_HEDLEY_GNUC_VERSION) && \
-    !defined(__clang__) && \
-    !defined(JSON_HEDLEY_INTEL_VERSION) && \
-    !defined(JSON_HEDLEY_PGI_VERSION) && \
-    !defined(JSON_HEDLEY_ARM_VERSION) && \
-    !defined(JSON_HEDLEY_TI_VERSION) && \
-    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
-    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
-    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
-    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
-    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
-    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
-    !defined(__COMPCERT__)
-    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
-#endif
-
-#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
-    #undef JSON_HEDLEY_GCC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_GCC_VERSION)
-    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
-    #undef JSON_HEDLEY_HAS_ATTRIBUTE
-#endif
-#if defined(__has_attribute)
-    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
-#else
-    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
-    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
-#endif
-#if defined(__has_attribute)
-    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
-#else
-    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
-    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
-#endif
-#if defined(__has_attribute)
-    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
-#else
-    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
-    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
-#endif
-#if \
-    defined(__has_cpp_attribute) && \
-    defined(__cplusplus) && \
-    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
-    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
-#else
-    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
-    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
-#endif
-#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
-    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
-#elif \
-    !defined(JSON_HEDLEY_PGI_VERSION) && \
-    !defined(JSON_HEDLEY_IAR_VERSION) && \
-    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
-    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
-    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
-#else
-    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
-    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
-#endif
-#if defined(__has_cpp_attribute) && defined(__cplusplus)
-    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
-#else
-    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
-    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
-#endif
-#if defined(__has_cpp_attribute) && defined(__cplusplus)
-    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
-#else
-    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_BUILTIN)
-    #undef JSON_HEDLEY_HAS_BUILTIN
-#endif
-#if defined(__has_builtin)
-    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
-#else
-    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
-    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
-#endif
-#if defined(__has_builtin)
-    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
-#else
-    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
-    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
-#endif
-#if defined(__has_builtin)
-    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
-#else
-    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_FEATURE)
-    #undef JSON_HEDLEY_HAS_FEATURE
-#endif
-#if defined(__has_feature)
-    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
-#else
-    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
-    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
-#endif
-#if defined(__has_feature)
-    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
-#else
-    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
-    #undef JSON_HEDLEY_GCC_HAS_FEATURE
-#endif
-#if defined(__has_feature)
-    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
-#else
-    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_EXTENSION)
-    #undef JSON_HEDLEY_HAS_EXTENSION
-#endif
-#if defined(__has_extension)
-    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
-#else
-    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
-    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
-#endif
-#if defined(__has_extension)
-    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
-#else
-    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
-    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
-#endif
-#if defined(__has_extension)
-    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
-#else
-    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
-    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
-#endif
-#if defined(__has_declspec_attribute)
-    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
-#else
-    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
-    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
-#endif
-#if defined(__has_declspec_attribute)
-    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
-#else
-    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
-    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
-#endif
-#if defined(__has_declspec_attribute)
-    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
-#else
-    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_WARNING)
-    #undef JSON_HEDLEY_HAS_WARNING
-#endif
-#if defined(__has_warning)
-    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
-#else
-    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
-    #undef JSON_HEDLEY_GNUC_HAS_WARNING
-#endif
-#if defined(__has_warning)
-    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
-#else
-    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
-    #undef JSON_HEDLEY_GCC_HAS_WARNING
-#endif
-#if defined(__has_warning)
-    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
-#else
-    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
-   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
-    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
-#endif
-#if defined(__cplusplus)
-#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
-#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
-#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH \
-    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
-    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
-    xpr \
-    JSON_HEDLEY_DIAGNOSTIC_POP
-#    else
-#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH \
-    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
-    xpr \
-    JSON_HEDLEY_DIAGNOSTIC_POP
-#    endif
-#  endif
-#endif
-#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
-#endif
-
-#if defined(JSON_HEDLEY_CONST_CAST)
-    #undef JSON_HEDLEY_CONST_CAST
-#endif
-#if defined(__cplusplus)
-#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
-#elif \
-  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
-  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
-  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
-        JSON_HEDLEY_DIAGNOSTIC_PUSH \
-        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
-        ((T) (expr)); \
-        JSON_HEDLEY_DIAGNOSTIC_POP \
-    }))
-#else
-#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
-#endif
-
-#if defined(JSON_HEDLEY_REINTERPRET_CAST)
-    #undef JSON_HEDLEY_REINTERPRET_CAST
-#endif
-#if defined(__cplusplus)
-    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
-#else
-    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
-#endif
-
-#if defined(JSON_HEDLEY_STATIC_CAST)
-    #undef JSON_HEDLEY_STATIC_CAST
-#endif
-#if defined(__cplusplus)
-    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
-#else
-    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
-#endif
-
-#if defined(JSON_HEDLEY_CPP_CAST)
-    #undef JSON_HEDLEY_CPP_CAST
-#endif
-#if defined(__cplusplus)
-#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
-#    define JSON_HEDLEY_CPP_CAST(T, expr) \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH \
-    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
-    ((T) (expr)) \
-    JSON_HEDLEY_DIAGNOSTIC_POP
-#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
-#    define JSON_HEDLEY_CPP_CAST(T, expr) \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH \
-    _Pragma("diag_suppress=Pe137") \
-    JSON_HEDLEY_DIAGNOSTIC_POP \
-#  else
-#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
-#  endif
-#else
-#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
-#endif
-
-#if \
-    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
-    defined(__clang__) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
-    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
-    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
-    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
-    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
-    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
-    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
-#else
-    #define JSON_HEDLEY_PRAGMA(value)
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
-    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
-#endif
-#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
-    #undef JSON_HEDLEY_DIAGNOSTIC_POP
-#endif
-#if defined(__clang__)
-    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
-    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
-    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
-    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
-    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
-#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
-    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
-#elif \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
-    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
-    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
-#else
-    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
-    #define JSON_HEDLEY_DIAGNOSTIC_POP
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
-    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
-#elif \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
-#else
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
-    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
-#elif \
-    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
-#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
-#else
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
-    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
-#elif \
-    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
-#else
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
-    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
-#else
-    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#endif
-
-#if defined(JSON_HEDLEY_DEPRECATED)
-    #undef JSON_HEDLEY_DEPRECATED
-#endif
-#if defined(JSON_HEDLEY_DEPRECATED_FOR)
-    #undef JSON_HEDLEY_DEPRECATED_FOR
-#endif
-#if JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)
-    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
-    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
-#elif defined(__cplusplus) && (__cplusplus >= 201402L)
-    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
-    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
-#elif \
-    JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
-    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
-    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
-    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
-    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
-#elif \
-    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
-    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
-    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
-#elif \
-    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
-    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)
-    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
-    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
-    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
-    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
-#else
-    #define JSON_HEDLEY_DEPRECATED(since)
-    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
-#endif
-
-#if defined(JSON_HEDLEY_UNAVAILABLE)
-    #undef JSON_HEDLEY_UNAVAILABLE
-#endif
-#if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
-#else
-    #define JSON_HEDLEY_UNAVAILABLE(available_since)
-#endif
-
-#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
-    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
-#endif
-#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
-    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
-#endif
-#if (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
-#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
-#elif \
-    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
-    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
-    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
-#elif defined(_Check_return_) /* SAL */
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
-#else
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT
-    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
-#endif
-
-#if defined(JSON_HEDLEY_SENTINEL)
-    #undef JSON_HEDLEY_SENTINEL
-#endif
-#if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
-    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
-#else
-    #define JSON_HEDLEY_SENTINEL(position)
-#endif
-
-#if defined(JSON_HEDLEY_NO_RETURN)
-    #undef JSON_HEDLEY_NO_RETURN
-#endif
-#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
-    #define JSON_HEDLEY_NO_RETURN __noreturn
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
-#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
-    #define JSON_HEDLEY_NO_RETURN _Noreturn
-#elif defined(__cplusplus) && (__cplusplus >= 201103L)
-    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
-#elif \
-    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
-    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
-    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
-    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
-#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
-    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
-#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
-    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
-    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
-#else
-    #define JSON_HEDLEY_NO_RETURN
-#endif
-
-#if defined(JSON_HEDLEY_NO_ESCAPE)
-    #undef JSON_HEDLEY_NO_ESCAPE
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
-    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
-#else
-    #define JSON_HEDLEY_NO_ESCAPE
-#endif
-
-#if defined(JSON_HEDLEY_UNREACHABLE)
-    #undef JSON_HEDLEY_UNREACHABLE
-#endif
-#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
-    #undef JSON_HEDLEY_UNREACHABLE_RETURN
-#endif
-#if defined(JSON_HEDLEY_ASSUME)
-    #undef JSON_HEDLEY_ASSUME
-#endif
-#if \
-    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
-#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
-    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
-#elif \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
-    #if defined(__cplusplus)
-        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
-    #else
-        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
-    #endif
-#endif
-#if \
-    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
-    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
-    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
-#elif defined(JSON_HEDLEY_ASSUME)
-    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
-#endif
-#if !defined(JSON_HEDLEY_ASSUME)
-    #if defined(JSON_HEDLEY_UNREACHABLE)
-        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
-    #else
-        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
-    #endif
-#endif
-#if defined(JSON_HEDLEY_UNREACHABLE)
-    #if  \
-        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
-        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
-        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
-    #else
-        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
-    #endif
-#else
-    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
-#endif
-#if !defined(JSON_HEDLEY_UNREACHABLE)
-    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
-#endif
-
-JSON_HEDLEY_DIAGNOSTIC_PUSH
-#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
-    #pragma clang diagnostic ignored "-Wpedantic"
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
-    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
-#endif
-#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
-    #if defined(__clang__)
-        #pragma clang diagnostic ignored "-Wvariadic-macros"
-    #elif defined(JSON_HEDLEY_GCC_VERSION)
-        #pragma GCC diagnostic ignored "-Wvariadic-macros"
-    #endif
-#endif
-#if defined(JSON_HEDLEY_NON_NULL)
-    #undef JSON_HEDLEY_NON_NULL
-#endif
-#if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
-    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
-#else
-    #define JSON_HEDLEY_NON_NULL(...)
-#endif
-JSON_HEDLEY_DIAGNOSTIC_POP
-
-#if defined(JSON_HEDLEY_PRINTF_FORMAT)
-    #undef JSON_HEDLEY_PRINTF_FORMAT
-#endif
-#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
-    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
-#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
-    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
-#elif \
-    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
-    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
-    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
-#else
-    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
-#endif
-
-#if defined(JSON_HEDLEY_CONSTEXPR)
-    #undef JSON_HEDLEY_CONSTEXPR
-#endif
-#if defined(__cplusplus)
-    #if __cplusplus >= 201103L
-        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
-    #endif
-#endif
-#if !defined(JSON_HEDLEY_CONSTEXPR)
-    #define JSON_HEDLEY_CONSTEXPR
-#endif
-
-#if defined(JSON_HEDLEY_PREDICT)
-    #undef JSON_HEDLEY_PREDICT
-#endif
-#if defined(JSON_HEDLEY_LIKELY)
-    #undef JSON_HEDLEY_LIKELY
-#endif
-#if defined(JSON_HEDLEY_UNLIKELY)
-    #undef JSON_HEDLEY_UNLIKELY
-#endif
-#if defined(JSON_HEDLEY_UNPREDICTABLE)
-    #undef JSON_HEDLEY_UNPREDICTABLE
-#endif
-#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
-    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
-#endif
-#if \
-  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) || \
-  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
-#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
-#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
-#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
-#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
-#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
-#elif \
-  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) || \
-  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
-  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
-  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
-  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
-  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
-  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
-  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
-  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
-  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
-  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
-#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
-    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
-#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
-    (__extension__ ({ \
-        double hedley_probability_ = (probability); \
-        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
-    }))
-#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
-    (__extension__ ({ \
-        double hedley_probability_ = (probability); \
-        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
-    }))
-#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
-#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
-#else
-#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
-#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
-#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
-#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
-#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
-#endif
-#if !defined(JSON_HEDLEY_UNPREDICTABLE)
-    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
-#endif
-
-#if defined(JSON_HEDLEY_MALLOC)
-    #undef JSON_HEDLEY_MALLOC
-#endif
-#if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
-    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
-    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
-    #define JSON_HEDLEY_MALLOC __declspec(restrict)
-#else
-    #define JSON_HEDLEY_MALLOC
-#endif
-
-#if defined(JSON_HEDLEY_PURE)
-    #undef JSON_HEDLEY_PURE
-#endif
-#if \
-  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
-  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
-  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
-  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
-  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
-  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
-#  define JSON_HEDLEY_PURE __attribute__((__pure__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
-#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
-#elif defined(__cplusplus) && \
-    ( \
-      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
-      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
-      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
-    )
-#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
-#else
-#  define JSON_HEDLEY_PURE
-#endif
-
-#if defined(JSON_HEDLEY_CONST)
-    #undef JSON_HEDLEY_CONST
-#endif
-#if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
-    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
-    #define JSON_HEDLEY_CONST __attribute__((__const__))
-#elif \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
-    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
-#else
-    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
-#endif
-
-#if defined(JSON_HEDLEY_RESTRICT)
-    #undef JSON_HEDLEY_RESTRICT
-#endif
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
-    #define JSON_HEDLEY_RESTRICT restrict
-#elif \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
-    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
-    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
-    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
-    defined(__clang__)
-    #define JSON_HEDLEY_RESTRICT __restrict
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
-    #define JSON_HEDLEY_RESTRICT _Restrict
-#else
-    #define JSON_HEDLEY_RESTRICT
-#endif
-
-#if defined(JSON_HEDLEY_INLINE)
-    #undef JSON_HEDLEY_INLINE
-#endif
-#if \
-    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
-    (defined(__cplusplus) && (__cplusplus >= 199711L))
-    #define JSON_HEDLEY_INLINE inline
-#elif \
-    defined(JSON_HEDLEY_GCC_VERSION) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
-    #define JSON_HEDLEY_INLINE __inline__
-#elif \
-    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
-    #define JSON_HEDLEY_INLINE __inline
-#else
-    #define JSON_HEDLEY_INLINE
-#endif
-
-#if defined(JSON_HEDLEY_ALWAYS_INLINE)
-    #undef JSON_HEDLEY_ALWAYS_INLINE
-#endif
-#if \
-  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
-  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
-  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
-  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
-  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
-#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0)
-#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
-#elif defined(__cplusplus) && \
-    ( \
-      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
-      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
-    )
-#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
-#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
-#else
-#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
-#endif
-
-#if defined(JSON_HEDLEY_NEVER_INLINE)
-    #undef JSON_HEDLEY_NEVER_INLINE
-#endif
-#if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
-    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
-    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
-    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
-    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
-#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
-    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
-    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
-#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
-    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
-    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
-#else
-    #define JSON_HEDLEY_NEVER_INLINE
-#endif
-
-#if defined(JSON_HEDLEY_PRIVATE)
-    #undef JSON_HEDLEY_PRIVATE
-#endif
-#if defined(JSON_HEDLEY_PUBLIC)
-    #undef JSON_HEDLEY_PUBLIC
-#endif
-#if defined(JSON_HEDLEY_IMPORT)
-    #undef JSON_HEDLEY_IMPORT
-#endif
-#if defined(_WIN32) || defined(__CYGWIN__)
-#  define JSON_HEDLEY_PRIVATE
-#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
-#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
-#else
-#  if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
-    ( \
-      defined(__TI_EABI__) && \
-      ( \
-        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
-        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
-      ) \
-    )
-#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
-#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
-#  else
-#    define JSON_HEDLEY_PRIVATE
-#    define JSON_HEDLEY_PUBLIC
-#  endif
-#  define JSON_HEDLEY_IMPORT    extern
-#endif
-
-#if defined(JSON_HEDLEY_NO_THROW)
-    #undef JSON_HEDLEY_NO_THROW
-#endif
-#if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
-#elif \
-    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
-    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
-#else
-    #define JSON_HEDLEY_NO_THROW
-#endif
-
-#if defined(JSON_HEDLEY_FALL_THROUGH)
-    #undef JSON_HEDLEY_FALL_THROUGH
-#endif
-#if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0)
-    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
-#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
-    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
-#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
-    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
-#elif defined(__fallthrough) /* SAL */
-    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
-#else
-    #define JSON_HEDLEY_FALL_THROUGH
-#endif
-
-#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
-    #undef JSON_HEDLEY_RETURNS_NON_NULL
-#endif
-#if \
-    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
-    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
-#elif defined(_Ret_notnull_) /* SAL */
-    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
-#else
-    #define JSON_HEDLEY_RETURNS_NON_NULL
-#endif
-
-#if defined(JSON_HEDLEY_ARRAY_PARAM)
-    #undef JSON_HEDLEY_ARRAY_PARAM
-#endif
-#if \
-    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
-    !defined(__STDC_NO_VLA__) && \
-    !defined(__cplusplus) && \
-    !defined(JSON_HEDLEY_PGI_VERSION) && \
-    !defined(JSON_HEDLEY_TINYC_VERSION)
-    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
-#else
-    #define JSON_HEDLEY_ARRAY_PARAM(name)
-#endif
-
-#if defined(JSON_HEDLEY_IS_CONSTANT)
-    #undef JSON_HEDLEY_IS_CONSTANT
-#endif
-#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
-    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
-#endif
-/* JSON_HEDLEY_IS_CONSTEXPR_ is for
-   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
-#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
-    #undef JSON_HEDLEY_IS_CONSTEXPR_
-#endif
-#if \
-    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
-    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
-    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
-    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
-    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
-#endif
-#if !defined(__cplusplus)
-#  if \
-       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
-       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
-       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
-       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
-       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
-       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
-#if defined(__INTPTR_TYPE__)
-    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
-#else
-    #include <stdint.h>
-    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
-#endif
-#  elif \
-       ( \
-          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
-          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
-          !defined(JSON_HEDLEY_PGI_VERSION) && \
-          !defined(JSON_HEDLEY_IAR_VERSION)) || \
-       JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
-       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
-       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
-       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
-       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
-#if defined(__INTPTR_TYPE__)
-    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
-#else
-    #include <stdint.h>
-    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
-#endif
-#  elif \
-       defined(JSON_HEDLEY_GCC_VERSION) || \
-       defined(JSON_HEDLEY_INTEL_VERSION) || \
-       defined(JSON_HEDLEY_TINYC_VERSION) || \
-       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
-       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
-       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
-       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
-       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
-       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
-       defined(__clang__)
-#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
-        sizeof(void) != \
-        sizeof(*( \
-                  1 ? \
-                  ((void*) ((expr) * 0L) ) : \
-((struct { char v[sizeof(void) * 2]; } *) 1) \
-                ) \
-              ) \
-                                            )
-#  endif
-#endif
-#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
-    #if !defined(JSON_HEDLEY_IS_CONSTANT)
-        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
-    #endif
-    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
-#else
-    #if !defined(JSON_HEDLEY_IS_CONSTANT)
-        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
-    #endif
-    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
-#endif
-
-#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
-    #undef JSON_HEDLEY_BEGIN_C_DECLS
-#endif
-#if defined(JSON_HEDLEY_END_C_DECLS)
-    #undef JSON_HEDLEY_END_C_DECLS
-#endif
-#if defined(JSON_HEDLEY_C_DECL)
-    #undef JSON_HEDLEY_C_DECL
-#endif
-#if defined(__cplusplus)
-    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
-    #define JSON_HEDLEY_END_C_DECLS }
-    #define JSON_HEDLEY_C_DECL extern "C"
-#else
-    #define JSON_HEDLEY_BEGIN_C_DECLS
-    #define JSON_HEDLEY_END_C_DECLS
-    #define JSON_HEDLEY_C_DECL
-#endif
-
-#if defined(JSON_HEDLEY_STATIC_ASSERT)
-    #undef JSON_HEDLEY_STATIC_ASSERT
-#endif
-#if \
-  !defined(__cplusplus) && ( \
-      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
-      JSON_HEDLEY_HAS_FEATURE(c_static_assert) || \
-      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
-      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
-      defined(_Static_assert) \
-    )
-#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
-#elif \
-  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
-  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0)
-#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
-#else
-#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
-#endif
-
-#if defined(JSON_HEDLEY_NULL)
-    #undef JSON_HEDLEY_NULL
-#endif
-#if defined(__cplusplus)
-    #if __cplusplus >= 201103L
-        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
-    #elif defined(NULL)
-        #define JSON_HEDLEY_NULL NULL
-    #else
-        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
-    #endif
-#elif defined(NULL)
-    #define JSON_HEDLEY_NULL NULL
-#else
-    #define JSON_HEDLEY_NULL ((void*) 0)
-#endif
-
-#if defined(JSON_HEDLEY_MESSAGE)
-    #undef JSON_HEDLEY_MESSAGE
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
-#  define JSON_HEDLEY_MESSAGE(msg) \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH \
-    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
-    JSON_HEDLEY_PRAGMA(message msg) \
-    JSON_HEDLEY_DIAGNOSTIC_POP
-#elif \
-  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
-  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
-#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
-#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
-#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
-#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
-#else
-#  define JSON_HEDLEY_MESSAGE(msg)
-#endif
-
-#if defined(JSON_HEDLEY_WARNING)
-    #undef JSON_HEDLEY_WARNING
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
-#  define JSON_HEDLEY_WARNING(msg) \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH \
-    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
-    JSON_HEDLEY_PRAGMA(clang warning msg) \
-    JSON_HEDLEY_DIAGNOSTIC_POP
-#elif \
-  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
-  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
-  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
-#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
-#else
-#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
-#endif
-
-#if defined(JSON_HEDLEY_REQUIRE)
-    #undef JSON_HEDLEY_REQUIRE
-#endif
-#if defined(JSON_HEDLEY_REQUIRE_MSG)
-    #undef JSON_HEDLEY_REQUIRE_MSG
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
-#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
-#    define JSON_HEDLEY_REQUIRE(expr) \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH \
-    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
-    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
-    JSON_HEDLEY_DIAGNOSTIC_POP
-#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH \
-    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
-    __attribute__((diagnose_if(!(expr), msg, "error"))) \
-    JSON_HEDLEY_DIAGNOSTIC_POP
-#  else
-#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
-#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
-#  endif
-#else
-#  define JSON_HEDLEY_REQUIRE(expr)
-#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
-#endif
-
-#if defined(JSON_HEDLEY_FLAGS)
-    #undef JSON_HEDLEY_FLAGS
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
-    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
-#endif
-
-#if defined(JSON_HEDLEY_FLAGS_CAST)
-    #undef JSON_HEDLEY_FLAGS_CAST
-#endif
-#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
-#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
-        JSON_HEDLEY_DIAGNOSTIC_PUSH \
-        _Pragma("warning(disable:188)") \
-        ((T) (expr)); \
-        JSON_HEDLEY_DIAGNOSTIC_POP \
-    }))
-#else
-#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
-#endif
-
-#if defined(JSON_HEDLEY_EMPTY_BASES)
-    #undef JSON_HEDLEY_EMPTY_BASES
-#endif
-#if JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)
-    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
-#else
-    #define JSON_HEDLEY_EMPTY_BASES
-#endif
-
-/* Remaining macros are deprecated. */
-
-#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
-    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
-#endif
-#if defined(__clang__)
-    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
-#else
-    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
-    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
-    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
-    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
-#endif
-#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
-    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
-    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
-#endif
-#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
-    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
-    #undef JSON_HEDLEY_CLANG_HAS_WARNING
-#endif
-#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
-
-#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
-
-
-// This file contains all internal macro definitions
-// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
-
-// exclude unsupported compilers
-#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
-    #if defined(__clang__)
-        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
-            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
-        #endif
-    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
-        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
-            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
-        #endif
-    #endif
-#endif
-
-// C++ language standard detection
-#if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
-    #define JSON_HAS_CPP_20
-    #define JSON_HAS_CPP_17
-    #define JSON_HAS_CPP_14
-#elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
-    #define JSON_HAS_CPP_17
-    #define JSON_HAS_CPP_14
-#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
-    #define JSON_HAS_CPP_14
-#endif
-
-// disable float-equal warnings on GCC/clang
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-
-// disable documentation warnings on clang
-#if defined(__clang__)
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Wdocumentation"
-#endif
-
-// allow to disable exceptions
-#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
-    #define JSON_THROW(exception) throw exception
-    #define JSON_TRY try
-    #define JSON_CATCH(exception) catch(exception)
-    #define JSON_INTERNAL_CATCH(exception) catch(exception)
-#else
-    #include <cstdlib>
-    #define JSON_THROW(exception) std::abort()
-    #define JSON_TRY if(true)
-    #define JSON_CATCH(exception) if(false)
-    #define JSON_INTERNAL_CATCH(exception) if(false)
-#endif
-
-// override exception macros
-#if defined(JSON_THROW_USER)
-    #undef JSON_THROW
-    #define JSON_THROW JSON_THROW_USER
-#endif
-#if defined(JSON_TRY_USER)
-    #undef JSON_TRY
-    #define JSON_TRY JSON_TRY_USER
-#endif
-#if defined(JSON_CATCH_USER)
-    #undef JSON_CATCH
-    #define JSON_CATCH JSON_CATCH_USER
-    #undef JSON_INTERNAL_CATCH
-    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
-#endif
-#if defined(JSON_INTERNAL_CATCH_USER)
-    #undef JSON_INTERNAL_CATCH
-    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
-#endif
-
-// allow to override assert
-#if !defined(JSON_ASSERT)
-    #include <cassert> // assert
-    #define JSON_ASSERT(x) assert(x)
-#endif
-
-/*!
-@brief macro to briefly define a mapping between an enum and JSON
-@def NLOHMANN_JSON_SERIALIZE_ENUM
-@since version 3.4.0
-*/
-#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
-    template<typename BasicJsonType>                                                            \
-    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
-    {                                                                                           \
-        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
-        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
-        auto it = std::find_if(std::begin(m), std::end(m),                                      \
-                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
-        {                                                                                       \
-            return ej_pair.first == e;                                                          \
-        });                                                                                     \
-        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
-    }                                                                                           \
-    template<typename BasicJsonType>                                                            \
-    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
-    {                                                                                           \
-        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
-        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
-        auto it = std::find_if(std::begin(m), std::end(m),                                      \
-                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
-        {                                                                                       \
-            return ej_pair.second == j;                                                         \
-        });                                                                                     \
-        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
-    }
-
-// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
-// may be removed in the future once the class is split.
-
-#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
-    template<template<typename, typename, typename...> class ObjectType,   \
-             template<typename, typename...> class ArrayType,              \
-             class StringType, class BooleanType, class NumberIntegerType, \
-             class NumberUnsignedType, class NumberFloatType,              \
-             template<typename> class AllocatorType,                       \
-             template<typename, typename = void> class JSONSerializer,     \
-             class BinaryType>
-
-#define NLOHMANN_BASIC_JSON_TPL                                            \
-    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
-    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
-    AllocatorType, JSONSerializer, BinaryType>
-
-// Macros to simplify conversion from/to types
-
-#define NLOHMANN_JSON_EXPAND( x ) x
-#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
-#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
-        NLOHMANN_JSON_PASTE64, \
-        NLOHMANN_JSON_PASTE63, \
-        NLOHMANN_JSON_PASTE62, \
-        NLOHMANN_JSON_PASTE61, \
-        NLOHMANN_JSON_PASTE60, \
-        NLOHMANN_JSON_PASTE59, \
-        NLOHMANN_JSON_PASTE58, \
-        NLOHMANN_JSON_PASTE57, \
-        NLOHMANN_JSON_PASTE56, \
-        NLOHMANN_JSON_PASTE55, \
-        NLOHMANN_JSON_PASTE54, \
-        NLOHMANN_JSON_PASTE53, \
-        NLOHMANN_JSON_PASTE52, \
-        NLOHMANN_JSON_PASTE51, \
-        NLOHMANN_JSON_PASTE50, \
-        NLOHMANN_JSON_PASTE49, \
-        NLOHMANN_JSON_PASTE48, \
-        NLOHMANN_JSON_PASTE47, \
-        NLOHMANN_JSON_PASTE46, \
-        NLOHMANN_JSON_PASTE45, \
-        NLOHMANN_JSON_PASTE44, \
-        NLOHMANN_JSON_PASTE43, \
-        NLOHMANN_JSON_PASTE42, \
-        NLOHMANN_JSON_PASTE41, \
-        NLOHMANN_JSON_PASTE40, \
-        NLOHMANN_JSON_PASTE39, \
-        NLOHMANN_JSON_PASTE38, \
-        NLOHMANN_JSON_PASTE37, \
-        NLOHMANN_JSON_PASTE36, \
-        NLOHMANN_JSON_PASTE35, \
-        NLOHMANN_JSON_PASTE34, \
-        NLOHMANN_JSON_PASTE33, \
-        NLOHMANN_JSON_PASTE32, \
-        NLOHMANN_JSON_PASTE31, \
-        NLOHMANN_JSON_PASTE30, \
-        NLOHMANN_JSON_PASTE29, \
-        NLOHMANN_JSON_PASTE28, \
-        NLOHMANN_JSON_PASTE27, \
-        NLOHMANN_JSON_PASTE26, \
-        NLOHMANN_JSON_PASTE25, \
-        NLOHMANN_JSON_PASTE24, \
-        NLOHMANN_JSON_PASTE23, \
-        NLOHMANN_JSON_PASTE22, \
-        NLOHMANN_JSON_PASTE21, \
-        NLOHMANN_JSON_PASTE20, \
-        NLOHMANN_JSON_PASTE19, \
-        NLOHMANN_JSON_PASTE18, \
-        NLOHMANN_JSON_PASTE17, \
-        NLOHMANN_JSON_PASTE16, \
-        NLOHMANN_JSON_PASTE15, \
-        NLOHMANN_JSON_PASTE14, \
-        NLOHMANN_JSON_PASTE13, \
-        NLOHMANN_JSON_PASTE12, \
-        NLOHMANN_JSON_PASTE11, \
-        NLOHMANN_JSON_PASTE10, \
-        NLOHMANN_JSON_PASTE9, \
-        NLOHMANN_JSON_PASTE8, \
-        NLOHMANN_JSON_PASTE7, \
-        NLOHMANN_JSON_PASTE6, \
-        NLOHMANN_JSON_PASTE5, \
-        NLOHMANN_JSON_PASTE4, \
-        NLOHMANN_JSON_PASTE3, \
-        NLOHMANN_JSON_PASTE2, \
-        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
-#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
-#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
-#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
-#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
-#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
-#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
-#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
-#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
-#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
-#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
-#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
-#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
-#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
-#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
-#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
-#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
-#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
-#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
-#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
-#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
-#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
-#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
-#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
-#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
-#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
-#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
-#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
-#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
-#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
-#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
-#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
-#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
-#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
-#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
-#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
-#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
-#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
-#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
-#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
-#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
-#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
-#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
-#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
-#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
-#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
-#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
-#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
-#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
-#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
-#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
-#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
-#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
-#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
-#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
-#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
-#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
-#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
-#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
-#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
-#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
-#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
-#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
-#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
-
-#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
-#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
-
-/*!
-@brief macro
-@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
-@since version 3.9.0
-*/
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
-    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
-    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
-
-/*!
-@brief macro
-@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
-@since version 3.9.0
-*/
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
-    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
-    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
-
-#ifndef JSON_USE_IMPLICIT_CONVERSIONS
-    #define JSON_USE_IMPLICIT_CONVERSIONS 1
-#endif
-
-#if JSON_USE_IMPLICIT_CONVERSIONS
-    #define JSON_EXPLICIT
-#else
-    #define JSON_EXPLICIT explicit
-#endif
-
-
-namespace nlohmann
-{
-namespace detail
-{
-////////////////
-// exceptions //
-////////////////
-
-/*!
-@brief general exception of the @ref basic_json class
-
-This class is an extension of `std::exception` objects with a member @a id for
-exception ids. It is used as the base class for all exceptions thrown by the
-@ref basic_json class. This class can hence be used as "wildcard" to catch
-exceptions.
-
-Subclasses:
-- @ref parse_error for exceptions indicating a parse error
-- @ref invalid_iterator for exceptions indicating errors with iterators
-- @ref type_error for exceptions indicating executing a member function with
-                  a wrong type
-- @ref out_of_range for exceptions indicating access out of the defined range
-- @ref other_error for exceptions indicating other library errors
-
-@internal
-@note To have nothrow-copy-constructible exceptions, we internally use
-      `std::runtime_error` which can cope with arbitrary-length error messages.
-      Intermediate strings are built with static functions and then passed to
-      the actual constructor.
-@endinternal
-
-@liveexample{The following code shows how arbitrary library exceptions can be
-caught.,exception}
-
-@since version 3.0.0
-*/
-class exception : public std::exception
-{
-  public:
-    /// returns the explanatory string
-    JSON_HEDLEY_RETURNS_NON_NULL
-    const char* what() const noexcept override
-    {
-        return m.what();
-    }
-
-    /// the id of the exception
-    const int id;
-
-  protected:
-    JSON_HEDLEY_NON_NULL(3)
-    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
-
-    static std::string name(const std::string& ename, int id_)
-    {
-        return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
-    }
-
-  private:
-    /// an exception object as storage for error messages
-    std::runtime_error m;
-};
-
-/*!
-@brief exception indicating a parse error
-
-This exception is thrown by the library when a parse error occurs. Parse errors
-can occur during the deserialization of JSON text, CBOR, MessagePack, as well
-as when using JSON Patch.
-
-Member @a byte holds the byte index of the last read character in the input
-file.
-
-Exceptions have ids 1xx.
-
-name / id                      | example message | description
------------------------------- | --------------- | -------------------------
-json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position.
-json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.
-json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.
-json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects.
-json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors.
-json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number without a leading `0`.
-json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character.
-json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences.
-json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number.
-json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
-json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
-json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
-json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).
-json.exception.parse_error.115 | parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A | A UBJSON high-precision number could not be parsed.
-
-@note For an input with n bytes, 1 is the index of the first character and n+1
-      is the index of the terminating null byte or the end of file. This also
-      holds true when reading a byte vector (CBOR or MessagePack).
-
-@liveexample{The following code shows how a `parse_error` exception can be
-caught.,parse_error}
-
-@sa - @ref exception for the base class of the library exceptions
-@sa - @ref invalid_iterator for exceptions indicating errors with iterators
-@sa - @ref type_error for exceptions indicating executing a member function with
-                    a wrong type
-@sa - @ref out_of_range for exceptions indicating access out of the defined range
-@sa - @ref other_error for exceptions indicating other library errors
-
-@since version 3.0.0
-*/
-class parse_error : public exception
-{
-  public:
-    /*!
-    @brief create a parse error exception
-    @param[in] id_       the id of the exception
-    @param[in] pos       the position where the error occurred (or with
-                         chars_read_total=0 if the position cannot be
-                         determined)
-    @param[in] what_arg  the explanatory string
-    @return parse_error object
-    */
-    static parse_error create(int id_, const position_t& pos, const std::string& what_arg)
-    {
-        std::string w = exception::name("parse_error", id_) + "parse error" +
-                        position_string(pos) + ": " + what_arg;
-        return parse_error(id_, pos.chars_read_total, w.c_str());
-    }
-
-    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
-    {
-        std::string w = exception::name("parse_error", id_) + "parse error" +
-                        (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
-                        ": " + what_arg;
-        return parse_error(id_, byte_, w.c_str());
-    }
-
-    /*!
-    @brief byte index of the parse error
-
-    The byte index of the last read character in the input file.
-
-    @note For an input with n bytes, 1 is the index of the first character and
-          n+1 is the index of the terminating null byte or the end of file.
-          This also holds true when reading a byte vector (CBOR or MessagePack).
-    */
-    const std::size_t byte;
-
-  private:
-    parse_error(int id_, std::size_t byte_, const char* what_arg)
-        : exception(id_, what_arg), byte(byte_) {}
-
-    static std::string position_string(const position_t& pos)
-    {
-        return " at line " + std::to_string(pos.lines_read + 1) +
-               ", column " + std::to_string(pos.chars_read_current_line);
-    }
-};
-
-/*!
-@brief exception indicating errors with iterators
-
-This exception is thrown if iterators passed to a library function do not match
-the expected semantics.
-
-Exceptions have ids 2xx.
-
-name / id                           | example message | description
------------------------------------ | --------------- | -------------------------
-json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
-json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.
-json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.
-json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid.
-json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.
-json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.
-json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.
-json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
-json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
-json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
-json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to.
-json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container.
-json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered.
-json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin().
-
-@liveexample{The following code shows how an `invalid_iterator` exception can be
-caught.,invalid_iterator}
-
-@sa - @ref exception for the base class of the library exceptions
-@sa - @ref parse_error for exceptions indicating a parse error
-@sa - @ref type_error for exceptions indicating executing a member function with
-                    a wrong type
-@sa - @ref out_of_range for exceptions indicating access out of the defined range
-@sa - @ref other_error for exceptions indicating other library errors
-
-@since version 3.0.0
-*/
-class invalid_iterator : public exception
-{
-  public:
-    static invalid_iterator create(int id_, const std::string& what_arg)
-    {
-        std::string w = exception::name("invalid_iterator", id_) + what_arg;
-        return invalid_iterator(id_, w.c_str());
-    }
-
-  private:
-    JSON_HEDLEY_NON_NULL(3)
-    invalid_iterator(int id_, const char* what_arg)
-        : exception(id_, what_arg) {}
-};
-
-/*!
-@brief exception indicating executing a member function with a wrong type
-
-This exception is thrown in case of a type error; that is, a library function is
-executed on a JSON value whose type does not match the expected semantics.
-
-Exceptions have ids 3xx.
-
-name / id                     | example message | description
------------------------------ | --------------- | -------------------------
-json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.
-json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.
-json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t &.
-json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types.
-json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types.
-json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types.
-json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types.
-json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types.
-json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types.
-json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types.
-json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types.
-json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types.
-json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined.
-json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.
-json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.
-json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |
-json.exception.type_error.317 | JSON value cannot be serialized to requested format | The dynamic type of the object cannot be represented in the requested serialization format (e.g. a raw `true` or `null` JSON object cannot be serialized to BSON) |
-
-@liveexample{The following code shows how a `type_error` exception can be
-caught.,type_error}
-
-@sa - @ref exception for the base class of the library exceptions
-@sa - @ref parse_error for exceptions indicating a parse error
-@sa - @ref invalid_iterator for exceptions indicating errors with iterators
-@sa - @ref out_of_range for exceptions indicating access out of the defined range
-@sa - @ref other_error for exceptions indicating other library errors
-
-@since version 3.0.0
-*/
-class type_error : public exception
-{
-  public:
-    static type_error create(int id_, const std::string& what_arg)
-    {
-        std::string w = exception::name("type_error", id_) + what_arg;
-        return type_error(id_, w.c_str());
-    }
-
-  private:
-    JSON_HEDLEY_NON_NULL(3)
-    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
-};
-
-/*!
-@brief exception indicating access out of the defined range
-
-This exception is thrown in case a library function is called on an input
-parameter that exceeds the expected range, for instance in case of array
-indices or nonexisting object keys.
-
-Exceptions have ids 4xx.
-
-name / id                       | example message | description
-------------------------------- | --------------- | -------------------------
-json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1.
-json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.
-json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object.
-json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
-json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
-json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
-json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. (until version 3.8.0) |
-json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
-json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |
-
-@liveexample{The following code shows how an `out_of_range` exception can be
-caught.,out_of_range}
-
-@sa - @ref exception for the base class of the library exceptions
-@sa - @ref parse_error for exceptions indicating a parse error
-@sa - @ref invalid_iterator for exceptions indicating errors with iterators
-@sa - @ref type_error for exceptions indicating executing a member function with
-                    a wrong type
-@sa - @ref other_error for exceptions indicating other library errors
-
-@since version 3.0.0
-*/
-class out_of_range : public exception
-{
-  public:
-    static out_of_range create(int id_, const std::string& what_arg)
-    {
-        std::string w = exception::name("out_of_range", id_) + what_arg;
-        return out_of_range(id_, w.c_str());
-    }
-
-  private:
-    JSON_HEDLEY_NON_NULL(3)
-    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
-};
-
-/*!
-@brief exception indicating other library errors
-
-This exception is thrown in case of errors that cannot be classified with the
-other exception types.
-
-Exceptions have ids 5xx.
-
-name / id                      | example message | description
------------------------------- | --------------- | -------------------------
-json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed.
-
-@sa - @ref exception for the base class of the library exceptions
-@sa - @ref parse_error for exceptions indicating a parse error
-@sa - @ref invalid_iterator for exceptions indicating errors with iterators
-@sa - @ref type_error for exceptions indicating executing a member function with
-                    a wrong type
-@sa - @ref out_of_range for exceptions indicating access out of the defined range
-
-@liveexample{The following code shows how an `other_error` exception can be
-caught.,other_error}
-
-@since version 3.0.0
-*/
-class other_error : public exception
-{
-  public:
-    static other_error create(int id_, const std::string& what_arg)
-    {
-        std::string w = exception::name("other_error", id_) + what_arg;
-        return other_error(id_, w.c_str());
-    }
-
-  private:
-    JSON_HEDLEY_NON_NULL(3)
-    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-
-#include <cstddef> // size_t
-#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
-
-namespace nlohmann
-{
-namespace detail
-{
-// alias templates to reduce boilerplate
-template<bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-template<typename T>
-using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
-// implementation of C++14 index_sequence and affiliates
-// source: https://stackoverflow.com/a/32223343
-template<std::size_t... Ints>
-struct index_sequence
-{
-    using type = index_sequence;
-    using value_type = std::size_t;
-    static constexpr std::size_t size() noexcept
-    {
-        return sizeof...(Ints);
-    }
-};
-
-template<class Sequence1, class Sequence2>
-struct merge_and_renumber;
-
-template<std::size_t... I1, std::size_t... I2>
-struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
-        : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
-
-template<std::size_t N>
-struct make_index_sequence
-    : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
-      typename make_index_sequence < N - N / 2 >::type > {};
-
-template<> struct make_index_sequence<0> : index_sequence<> {};
-template<> struct make_index_sequence<1> : index_sequence<0> {};
-
-template<typename... Ts>
-using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-
-// dispatch utility (taken from ranges-v3)
-template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
-template<> struct priority_tag<0> {};
-
-// taken from ranges-v3
-template<typename T>
-struct static_const
-{
-    static constexpr T value{};
-};
-
-template<typename T>
-constexpr T static_const<T>::value;
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-
-#include <limits> // numeric_limits
-#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
-#include <utility> // declval
-
-// #include <nlohmann/detail/iterators/iterator_traits.hpp>
-
-
-#include <iterator> // random_access_iterator_tag
-
-// #include <nlohmann/detail/meta/void_t.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-template<typename ...Ts> struct make_void
-{
-    using type = void;
-};
-template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
-} // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-template<typename It, typename = void>
-struct iterator_types {};
-
-template<typename It>
-struct iterator_types <
-    It,
-    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
-    typename It::reference, typename It::iterator_category >>
-{
-    using difference_type = typename It::difference_type;
-    using value_type = typename It::value_type;
-    using pointer = typename It::pointer;
-    using reference = typename It::reference;
-    using iterator_category = typename It::iterator_category;
-};
-
-// This is required as some compilers implement std::iterator_traits in a way that
-// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
-template<typename T, typename = void>
-struct iterator_traits
-{
-};
-
-template<typename T>
-struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
-            : iterator_types<T>
-{
-};
-
-template<typename T>
-struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
-{
-    using iterator_category = std::random_access_iterator_tag;
-    using value_type = T;
-    using difference_type = ptrdiff_t;
-    using pointer = T*;
-    using reference = T&;
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/detected.hpp>
-
-
-#include <type_traits>
-
-// #include <nlohmann/detail/meta/void_t.hpp>
-
-
-// https://en.cppreference.com/w/cpp/experimental/is_detected
-namespace nlohmann
-{
-namespace detail
-{
-struct nonesuch
-{
-    nonesuch() = delete;
-    ~nonesuch() = delete;
-    nonesuch(nonesuch const&) = delete;
-    nonesuch(nonesuch const&&) = delete;
-    void operator=(nonesuch const&) = delete;
-    void operator=(nonesuch&&) = delete;
-};
-
-template<class Default,
-         class AlwaysVoid,
-         template<class...> class Op,
-         class... Args>
-struct detector
-{
-    using value_t = std::false_type;
-    using type = Default;
-};
-
-template<class Default, template<class...> class Op, class... Args>
-struct detector<Default, void_t<Op<Args...>>, Op, Args...>
-{
-    using value_t = std::true_type;
-    using type = Op<Args...>;
-};
-
-template<template<class...> class Op, class... Args>
-using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
-
-template<template<class...> class Op, class... Args>
-using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
-
-template<class Default, template<class...> class Op, class... Args>
-using detected_or = detector<Default, void, Op, Args...>;
-
-template<class Default, template<class...> class Op, class... Args>
-using detected_or_t = typename detected_or<Default, Op, Args...>::type;
-
-template<class Expected, template<class...> class Op, class... Args>
-using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
-
-template<class To, template<class...> class Op, class... Args>
-using is_detected_convertible =
-    std::is_convertible<detected_t<Op, Args...>, To>;
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/json_fwd.hpp>
-#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
-#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
-
-#include <cstdint> // int64_t, uint64_t
-#include <map> // map
-#include <memory> // allocator
-#include <string> // string
-#include <vector> // vector
-
-/*!
-@brief namespace for Niels Lohmann
-@see https://github.com/nlohmann
-@since version 1.0.0
-*/
-namespace nlohmann
-{
-/*!
-@brief default JSONSerializer template argument
-
-This serializer ignores the template arguments and uses ADL
-([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
-for serialization.
-*/
-template<typename T = void, typename SFINAE = void>
-struct adl_serializer;
-
-template<template<typename U, typename V, typename... Args> class ObjectType =
-         std::map,
-         template<typename U, typename... Args> class ArrayType = std::vector,
-         class StringType = std::string, class BooleanType = bool,
-         class NumberIntegerType = std::int64_t,
-         class NumberUnsignedType = std::uint64_t,
-         class NumberFloatType = double,
-         template<typename U> class AllocatorType = std::allocator,
-         template<typename T, typename SFINAE = void> class JSONSerializer =
-         adl_serializer,
-         class BinaryType = std::vector<std::uint8_t>>
-class basic_json;
-
-/*!
-@brief JSON Pointer
-
-A JSON pointer defines a string syntax for identifying a specific value
-within a JSON document. It can be used with functions `at` and
-`operator[]`. Furthermore, JSON pointers are the base for JSON patches.
-
-@sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
-
-@since version 2.0.0
-*/
-template<typename BasicJsonType>
-class json_pointer;
-
-/*!
-@brief default JSON class
-
-This type is the default specialization of the @ref basic_json class which
-uses the standard template types.
-
-@since version 1.0.0
-*/
-using json = basic_json<>;
-
-template<class Key, class T, class IgnoredLess, class Allocator>
-struct ordered_map;
-
-/*!
-@brief ordered JSON class
-
-This type preserves the insertion order of object keys.
-
-@since version 3.9.0
-*/
-using ordered_json = basic_json<nlohmann::ordered_map>;
-
-}  // namespace nlohmann
-
-#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
-
-
-namespace nlohmann
-{
-/*!
-@brief detail namespace with internal helper functions
-
-This namespace collects functions that should not be exposed,
-implementations of some @ref basic_json methods, and meta-programming helpers.
-
-@since version 2.1.0
-*/
-namespace detail
-{
-/////////////
-// helpers //
-/////////////
-
-// Note to maintainers:
-//
-// Every trait in this file expects a non CV-qualified type.
-// The only exceptions are in the 'aliases for detected' section
-// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
-//
-// In this case, T has to be properly CV-qualified to constraint the function arguments
-// (e.g. to_json(BasicJsonType&, const T&))
-
-template<typename> struct is_basic_json : std::false_type {};
-
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
-
-//////////////////////
-// json_ref helpers //
-//////////////////////
-
-template<typename>
-class json_ref;
-
-template<typename>
-struct is_json_ref : std::false_type {};
-
-template<typename T>
-struct is_json_ref<json_ref<T>> : std::true_type {};
-
-//////////////////////////
-// aliases for detected //
-//////////////////////////
-
-template<typename T>
-using mapped_type_t = typename T::mapped_type;
-
-template<typename T>
-using key_type_t = typename T::key_type;
-
-template<typename T>
-using value_type_t = typename T::value_type;
-
-template<typename T>
-using difference_type_t = typename T::difference_type;
-
-template<typename T>
-using pointer_t = typename T::pointer;
-
-template<typename T>
-using reference_t = typename T::reference;
-
-template<typename T>
-using iterator_category_t = typename T::iterator_category;
-
-template<typename T>
-using iterator_t = typename T::iterator;
-
-template<typename T, typename... Args>
-using to_json_function = decltype(T::to_json(std::declval<Args>()...));
-
-template<typename T, typename... Args>
-using from_json_function = decltype(T::from_json(std::declval<Args>()...));
-
-template<typename T, typename U>
-using get_template_function = decltype(std::declval<T>().template get<U>());
-
-// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
-template<typename BasicJsonType, typename T, typename = void>
-struct has_from_json : std::false_type {};
-
-// trait checking if j.get<T> is valid
-// use this trait instead of std::is_constructible or std::is_convertible,
-// both rely on, or make use of implicit conversions, and thus fail when T
-// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
-template <typename BasicJsonType, typename T>
-struct is_getable
-{
-    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
-};
-
-template<typename BasicJsonType, typename T>
-struct has_from_json < BasicJsonType, T,
-           enable_if_t < !is_basic_json<T>::value >>
-{
-    using serializer = typename BasicJsonType::template json_serializer<T, void>;
-
-    static constexpr bool value =
-        is_detected_exact<void, from_json_function, serializer,
-        const BasicJsonType&, T&>::value;
-};
-
-// This trait checks if JSONSerializer<T>::from_json(json const&) exists
-// this overload is used for non-default-constructible user-defined-types
-template<typename BasicJsonType, typename T, typename = void>
-struct has_non_default_from_json : std::false_type {};
-
-template<typename BasicJsonType, typename T>
-struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
-{
-    using serializer = typename BasicJsonType::template json_serializer<T, void>;
-
-    static constexpr bool value =
-        is_detected_exact<T, from_json_function, serializer,
-        const BasicJsonType&>::value;
-};
-
-// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
-// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
-template<typename BasicJsonType, typename T, typename = void>
-struct has_to_json : std::false_type {};
-
-template<typename BasicJsonType, typename T>
-struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
-{
-    using serializer = typename BasicJsonType::template json_serializer<T, void>;
-
-    static constexpr bool value =
-        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
-        T>::value;
-};
-
-
-///////////////////
-// is_ functions //
-///////////////////
-
-template<typename T, typename = void>
-struct is_iterator_traits : std::false_type {};
-
-template<typename T>
-struct is_iterator_traits<iterator_traits<T>>
-{
-  private:
-    using traits = iterator_traits<T>;
-
-  public:
-    static constexpr auto value =
-        is_detected<value_type_t, traits>::value &&
-        is_detected<difference_type_t, traits>::value &&
-        is_detected<pointer_t, traits>::value &&
-        is_detected<iterator_category_t, traits>::value &&
-        is_detected<reference_t, traits>::value;
-};
-
-// source: https://stackoverflow.com/a/37193089/4116453
-
-template<typename T, typename = void>
-struct is_complete_type : std::false_type {};
-
-template<typename T>
-struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
-
-template<typename BasicJsonType, typename CompatibleObjectType,
-         typename = void>
-struct is_compatible_object_type_impl : std::false_type {};
-
-template<typename BasicJsonType, typename CompatibleObjectType>
-struct is_compatible_object_type_impl <
-    BasicJsonType, CompatibleObjectType,
-    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
-    is_detected<key_type_t, CompatibleObjectType>::value >>
-{
-
-    using object_t = typename BasicJsonType::object_t;
-
-    // macOS's is_constructible does not play well with nonesuch...
-    static constexpr bool value =
-        std::is_constructible<typename object_t::key_type,
-        typename CompatibleObjectType::key_type>::value &&
-        std::is_constructible<typename object_t::mapped_type,
-        typename CompatibleObjectType::mapped_type>::value;
-};
-
-template<typename BasicJsonType, typename CompatibleObjectType>
-struct is_compatible_object_type
-    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
-
-template<typename BasicJsonType, typename ConstructibleObjectType,
-         typename = void>
-struct is_constructible_object_type_impl : std::false_type {};
-
-template<typename BasicJsonType, typename ConstructibleObjectType>
-struct is_constructible_object_type_impl <
-    BasicJsonType, ConstructibleObjectType,
-    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
-    is_detected<key_type_t, ConstructibleObjectType>::value >>
-{
-    using object_t = typename BasicJsonType::object_t;
-
-    static constexpr bool value =
-        (std::is_default_constructible<ConstructibleObjectType>::value &&
-         (std::is_move_assignable<ConstructibleObjectType>::value ||
-          std::is_copy_assignable<ConstructibleObjectType>::value) &&
-         (std::is_constructible<typename ConstructibleObjectType::key_type,
-          typename object_t::key_type>::value &&
-          std::is_same <
-          typename object_t::mapped_type,
-          typename ConstructibleObjectType::mapped_type >::value)) ||
-        (has_from_json<BasicJsonType,
-         typename ConstructibleObjectType::mapped_type>::value ||
-         has_non_default_from_json <
-         BasicJsonType,
-         typename ConstructibleObjectType::mapped_type >::value);
-};
-
-template<typename BasicJsonType, typename ConstructibleObjectType>
-struct is_constructible_object_type
-    : is_constructible_object_type_impl<BasicJsonType,
-      ConstructibleObjectType> {};
-
-template<typename BasicJsonType, typename CompatibleStringType,
-         typename = void>
-struct is_compatible_string_type_impl : std::false_type {};
-
-template<typename BasicJsonType, typename CompatibleStringType>
-struct is_compatible_string_type_impl <
-    BasicJsonType, CompatibleStringType,
-    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
-    value_type_t, CompatibleStringType>::value >>
-{
-    static constexpr auto value =
-        std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
-};
-
-template<typename BasicJsonType, typename ConstructibleStringType>
-struct is_compatible_string_type
-    : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
-
-template<typename BasicJsonType, typename ConstructibleStringType,
-         typename = void>
-struct is_constructible_string_type_impl : std::false_type {};
-
-template<typename BasicJsonType, typename ConstructibleStringType>
-struct is_constructible_string_type_impl <
-    BasicJsonType, ConstructibleStringType,
-    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
-    value_type_t, ConstructibleStringType>::value >>
-{
-    static constexpr auto value =
-        std::is_constructible<ConstructibleStringType,
-        typename BasicJsonType::string_t>::value;
-};
-
-template<typename BasicJsonType, typename ConstructibleStringType>
-struct is_constructible_string_type
-    : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
-
-template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
-struct is_compatible_array_type_impl : std::false_type {};
-
-template<typename BasicJsonType, typename CompatibleArrayType>
-struct is_compatible_array_type_impl <
-    BasicJsonType, CompatibleArrayType,
-    enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
-    is_detected<iterator_t, CompatibleArrayType>::value&&
-// This is needed because json_reverse_iterator has a ::iterator type...
-// Therefore it is detected as a CompatibleArrayType.
-// The real fix would be to have an Iterable concept.
-    !is_iterator_traits <
-    iterator_traits<CompatibleArrayType >>::value >>
-{
-    static constexpr bool value =
-        std::is_constructible<BasicJsonType,
-        typename CompatibleArrayType::value_type>::value;
-};
-
-template<typename BasicJsonType, typename CompatibleArrayType>
-struct is_compatible_array_type
-    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
-
-template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
-struct is_constructible_array_type_impl : std::false_type {};
-
-template<typename BasicJsonType, typename ConstructibleArrayType>
-struct is_constructible_array_type_impl <
-    BasicJsonType, ConstructibleArrayType,
-    enable_if_t<std::is_same<ConstructibleArrayType,
-    typename BasicJsonType::value_type>::value >>
-            : std::true_type {};
-
-template<typename BasicJsonType, typename ConstructibleArrayType>
-struct is_constructible_array_type_impl <
-    BasicJsonType, ConstructibleArrayType,
-    enable_if_t < !std::is_same<ConstructibleArrayType,
-    typename BasicJsonType::value_type>::value&&
-    std::is_default_constructible<ConstructibleArrayType>::value&&
-(std::is_move_assignable<ConstructibleArrayType>::value ||
- std::is_copy_assignable<ConstructibleArrayType>::value)&&
-is_detected<value_type_t, ConstructibleArrayType>::value&&
-is_detected<iterator_t, ConstructibleArrayType>::value&&
-is_complete_type <
-detected_t<value_type_t, ConstructibleArrayType >>::value >>
-{
-    static constexpr bool value =
-        // This is needed because json_reverse_iterator has a ::iterator type,
-        // furthermore, std::back_insert_iterator (and other iterators) have a
-        // base class `iterator`... Therefore it is detected as a
-        // ConstructibleArrayType. The real fix would be to have an Iterable
-        // concept.
-        !is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value &&
-
-        (std::is_same<typename ConstructibleArrayType::value_type,
-         typename BasicJsonType::array_t::value_type>::value ||
-         has_from_json<BasicJsonType,
-         typename ConstructibleArrayType::value_type>::value ||
-         has_non_default_from_json <
-         BasicJsonType, typename ConstructibleArrayType::value_type >::value);
-};
-
-template<typename BasicJsonType, typename ConstructibleArrayType>
-struct is_constructible_array_type
-    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
-
-template<typename RealIntegerType, typename CompatibleNumberIntegerType,
-         typename = void>
-struct is_compatible_integer_type_impl : std::false_type {};
-
-template<typename RealIntegerType, typename CompatibleNumberIntegerType>
-struct is_compatible_integer_type_impl <
-    RealIntegerType, CompatibleNumberIntegerType,
-    enable_if_t < std::is_integral<RealIntegerType>::value&&
-    std::is_integral<CompatibleNumberIntegerType>::value&&
-    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
-{
-    // is there an assert somewhere on overflows?
-    using RealLimits = std::numeric_limits<RealIntegerType>;
-    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
-
-    static constexpr auto value =
-        std::is_constructible<RealIntegerType,
-        CompatibleNumberIntegerType>::value &&
-        CompatibleLimits::is_integer &&
-        RealLimits::is_signed == CompatibleLimits::is_signed;
-};
-
-template<typename RealIntegerType, typename CompatibleNumberIntegerType>
-struct is_compatible_integer_type
-    : is_compatible_integer_type_impl<RealIntegerType,
-      CompatibleNumberIntegerType> {};
-
-template<typename BasicJsonType, typename CompatibleType, typename = void>
-struct is_compatible_type_impl: std::false_type {};
-
-template<typename BasicJsonType, typename CompatibleType>
-struct is_compatible_type_impl <
-    BasicJsonType, CompatibleType,
-    enable_if_t<is_complete_type<CompatibleType>::value >>
-{
-    static constexpr bool value =
-        has_to_json<BasicJsonType, CompatibleType>::value;
-};
-
-template<typename BasicJsonType, typename CompatibleType>
-struct is_compatible_type
-    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
-
-// https://en.cppreference.com/w/cpp/types/conjunction
-template<class...> struct conjunction : std::true_type { };
-template<class B1> struct conjunction<B1> : B1 { };
-template<class B1, class... Bn>
-struct conjunction<B1, Bn...>
-: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
-
-template<typename T1, typename T2>
-struct is_constructible_tuple : std::false_type {};
-
-template<typename T1, typename... Args>
-struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/value_t.hpp>
-
-
-#include <array> // array
-#include <cstddef> // size_t
-#include <cstdint> // uint8_t
-#include <string> // string
-
-namespace nlohmann
-{
-namespace detail
-{
-///////////////////////////
-// JSON type enumeration //
-///////////////////////////
-
-/*!
-@brief the JSON type enumeration
-
-This enumeration collects the different JSON types. It is internally used to
-distinguish the stored values, and the functions @ref basic_json::is_null(),
-@ref basic_json::is_object(), @ref basic_json::is_array(),
-@ref basic_json::is_string(), @ref basic_json::is_boolean(),
-@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
-@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
-@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
-@ref basic_json::is_structured() rely on it.
-
-@note There are three enumeration entries (number_integer, number_unsigned, and
-number_float), because the library distinguishes these three types for numbers:
-@ref basic_json::number_unsigned_t is used for unsigned integers,
-@ref basic_json::number_integer_t is used for signed integers, and
-@ref basic_json::number_float_t is used for floating-point numbers or to
-approximate integers which do not fit in the limits of their respective type.
-
-@sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON
-value with the default value for a given type
-
-@since version 1.0.0
-*/
-enum class value_t : std::uint8_t
-{
-    null,             ///< null value
-    object,           ///< object (unordered set of name/value pairs)
-    array,            ///< array (ordered collection of values)
-    string,           ///< string value
-    boolean,          ///< boolean value
-    number_integer,   ///< number value (signed integer)
-    number_unsigned,  ///< number value (unsigned integer)
-    number_float,     ///< number value (floating-point)
-    binary,           ///< binary array (ordered collection of bytes)
-    discarded         ///< discarded by the parser callback function
-};
-
-/*!
-@brief comparison operator for JSON types
-
-Returns an ordering that is similar to Python:
-- order: null < boolean < number < object < array < string < binary
-- furthermore, each type is not smaller than itself
-- discarded values are not comparable
-- binary is represented as a b"" string in python and directly comparable to a
-  string; however, making a binary array directly comparable with a string would
-  be surprising behavior in a JSON file.
-
-@since version 1.0.0
-*/
-inline bool operator<(const value_t lhs, const value_t rhs) noexcept
-{
-    static constexpr std::array<std::uint8_t, 9> order = {{
-            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
-            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
-            6 /* binary */
-        }
-    };
-
-    const auto l_index = static_cast<std::size_t>(lhs);
-    const auto r_index = static_cast<std::size_t>(rhs);
-    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
-}
-}  // namespace detail
-}  // namespace nlohmann
-
-
-namespace nlohmann
-{
-namespace detail
-{
-template<typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
-    {
-        JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
-    }
-    n = nullptr;
-}
-
-// overloads for basic_json template parameters
-template < typename BasicJsonType, typename ArithmeticType,
-           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
-                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
-                         int > = 0 >
-void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
-{
-    switch (static_cast<value_t>(j))
-    {
-        case value_t::number_unsigned:
-        {
-            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
-            break;
-        }
-        case value_t::number_integer:
-        {
-            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
-            break;
-        }
-        case value_t::number_float:
-        {
-            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
-            break;
-        }
-
-        default:
-            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
-    }
-}
-
-template<typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
-    {
-        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
-    }
-    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
-}
-
-template<typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
-    {
-        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
-    }
-    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
-}
-
-template <
-    typename BasicJsonType, typename ConstructibleStringType,
-    enable_if_t <
-        is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
-        !std::is_same<typename BasicJsonType::string_t,
-                      ConstructibleStringType>::value,
-        int > = 0 >
-void from_json(const BasicJsonType& j, ConstructibleStringType& s)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
-    {
-        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
-    }
-
-    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
-}
-
-template<typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
-{
-    get_arithmetic_value(j, val);
-}
-
-template<typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
-{
-    get_arithmetic_value(j, val);
-}
-
-template<typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
-{
-    get_arithmetic_value(j, val);
-}
-
-template<typename BasicJsonType, typename EnumType,
-         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
-void from_json(const BasicJsonType& j, EnumType& e)
-{
-    typename std::underlying_type<EnumType>::type val;
-    get_arithmetic_value(j, val);
-    e = static_cast<EnumType>(val);
-}
-
-// forward_list doesn't have an insert method
-template<typename BasicJsonType, typename T, typename Allocator,
-         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
-void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
-    {
-        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
-    }
-    l.clear();
-    std::transform(j.rbegin(), j.rend(),
-                   std::front_inserter(l), [](const BasicJsonType & i)
-    {
-        return i.template get<T>();
-    });
-}
-
-// valarray doesn't have an insert method
-template<typename BasicJsonType, typename T,
-         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
-void from_json(const BasicJsonType& j, std::valarray<T>& l)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
-    {
-        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
-    }
-    l.resize(j.size());
-    std::transform(j.begin(), j.end(), std::begin(l),
-                   [](const BasicJsonType & elem)
-    {
-        return elem.template get<T>();
-    });
-}
-
-template<typename BasicJsonType, typename T, std::size_t N>
-auto from_json(const BasicJsonType& j, T (&arr)[N])
--> decltype(j.template get<T>(), void())
-{
-    for (std::size_t i = 0; i < N; ++i)
-    {
-        arr[i] = j.at(i).template get<T>();
-    }
-}
-
-template<typename BasicJsonType>
-void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
-{
-    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
-}
-
-template<typename BasicJsonType, typename T, std::size_t N>
-auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
-                          priority_tag<2> /*unused*/)
--> decltype(j.template get<T>(), void())
-{
-    for (std::size_t i = 0; i < N; ++i)
-    {
-        arr[i] = j.at(i).template get<T>();
-    }
-}
-
-template<typename BasicJsonType, typename ConstructibleArrayType>
-auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
--> decltype(
-    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
-    j.template get<typename ConstructibleArrayType::value_type>(),
-    void())
-{
-    using std::end;
-
-    ConstructibleArrayType ret;
-    ret.reserve(j.size());
-    std::transform(j.begin(), j.end(),
-                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
-    {
-        // get<BasicJsonType>() returns *this, this won't call a from_json
-        // method when value_type is BasicJsonType
-        return i.template get<typename ConstructibleArrayType::value_type>();
-    });
-    arr = std::move(ret);
-}
-
-template<typename BasicJsonType, typename ConstructibleArrayType>
-void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
-                          priority_tag<0> /*unused*/)
-{
-    using std::end;
-
-    ConstructibleArrayType ret;
-    std::transform(
-        j.begin(), j.end(), std::inserter(ret, end(ret)),
-        [](const BasicJsonType & i)
-    {
-        // get<BasicJsonType>() returns *this, this won't call a from_json
-        // method when value_type is BasicJsonType
-        return i.template get<typename ConstructibleArrayType::value_type>();
-    });
-    arr = std::move(ret);
-}
-
-template < typename BasicJsonType, typename ConstructibleArrayType,
-           enable_if_t <
-               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
-               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
-               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
-               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
-               !is_basic_json<ConstructibleArrayType>::value,
-               int > = 0 >
-auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
--> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
-j.template get<typename ConstructibleArrayType::value_type>(),
-void())
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
-    {
-        JSON_THROW(type_error::create(302, "type must be array, but is " +
-                                      std::string(j.type_name())));
-    }
-
-    from_json_array_impl(j, arr, priority_tag<3> {});
-}
-
-template<typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
-    {
-        JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name())));
-    }
-
-    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
-}
-
-template<typename BasicJsonType, typename ConstructibleObjectType,
-         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
-void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
-    {
-        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
-    }
-
-    ConstructibleObjectType ret;
-    auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
-    using value_type = typename ConstructibleObjectType::value_type;
-    std::transform(
-        inner_object->begin(), inner_object->end(),
-        std::inserter(ret, ret.begin()),
-        [](typename BasicJsonType::object_t::value_type const & p)
-    {
-        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
-    });
-    obj = std::move(ret);
-}
-
-// overload for arithmetic types, not chosen for basic_json template arguments
-// (BooleanType, etc..); note: Is it really necessary to provide explicit
-// overloads for boolean_t etc. in case of a custom BooleanType which is not
-// an arithmetic type?
-template < typename BasicJsonType, typename ArithmeticType,
-           enable_if_t <
-               std::is_arithmetic<ArithmeticType>::value&&
-               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
-               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
-               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
-               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
-               int > = 0 >
-void from_json(const BasicJsonType& j, ArithmeticType& val)
-{
-    switch (static_cast<value_t>(j))
-    {
-        case value_t::number_unsigned:
-        {
-            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
-            break;
-        }
-        case value_t::number_integer:
-        {
-            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
-            break;
-        }
-        case value_t::number_float:
-        {
-            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
-            break;
-        }
-        case value_t::boolean:
-        {
-            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
-            break;
-        }
-
-        default:
-            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
-    }
-}
-
-template<typename BasicJsonType, typename A1, typename A2>
-void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
-{
-    p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
-}
-
-template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
-void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)
-{
-    t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
-}
-
-template<typename BasicJsonType, typename... Args>
-void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
-{
-    from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
-}
-
-template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
-           typename = enable_if_t < !std::is_constructible <
-                                        typename BasicJsonType::string_t, Key >::value >>
-void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
-    {
-        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
-    }
-    m.clear();
-    for (const auto& p : j)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
-        {
-            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
-        }
-        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
-    }
-}
-
-template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
-           typename = enable_if_t < !std::is_constructible <
-                                        typename BasicJsonType::string_t, Key >::value >>
-void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
-{
-    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
-    {
-        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
-    }
-    m.clear();
-    for (const auto& p : j)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
-        {
-            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
-        }
-        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
-    }
-}
-
-struct from_json_fn
-{
-    template<typename BasicJsonType, typename T>
-    auto operator()(const BasicJsonType& j, T& val) const
-    noexcept(noexcept(from_json(j, val)))
-    -> decltype(from_json(j, val), void())
-    {
-        return from_json(j, val);
-    }
-};
-}  // namespace detail
-
-/// namespace to hold default `from_json` function
-/// to see why this is required:
-/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
-namespace
-{
-constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
-} // namespace
-} // namespace nlohmann
-
-// #include <nlohmann/detail/conversions/to_json.hpp>
-
-
-#include <algorithm> // copy
-#include <iterator> // begin, end
-#include <string> // string
-#include <tuple> // tuple, get
-#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
-#include <utility> // move, forward, declval, pair
-#include <valarray> // valarray
-#include <vector> // vector
-
-// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
-
-
-#include <cstddef> // size_t
-#include <iterator> // input_iterator_tag
-#include <string> // string, to_string
-#include <tuple> // tuple_size, get, tuple_element
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-template<typename string_type>
-void int_to_string( string_type& target, std::size_t value )
-{
-    // For ADL
-    using std::to_string;
-    target = to_string(value);
-}
-template<typename IteratorType> class iteration_proxy_value
-{
-  public:
-    using difference_type = std::ptrdiff_t;
-    using value_type = iteration_proxy_value;
-    using pointer = value_type * ;
-    using reference = value_type & ;
-    using iterator_category = std::input_iterator_tag;
-    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
-
-  private:
-    /// the iterator
-    IteratorType anchor;
-    /// an index for arrays (used to create key names)
-    std::size_t array_index = 0;
-    /// last stringified array index
-    mutable std::size_t array_index_last = 0;
-    /// a string representation of the array index
-    mutable string_type array_index_str = "0";
-    /// an empty string (to return a reference for primitive values)
-    const string_type empty_str = "";
-
-  public:
-    explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
-
-    /// dereference operator (needed for range-based for)
-    iteration_proxy_value& operator*()
-    {
-        return *this;
-    }
-
-    /// increment operator (needed for range-based for)
-    iteration_proxy_value& operator++()
-    {
-        ++anchor;
-        ++array_index;
-
-        return *this;
-    }
-
-    /// equality operator (needed for InputIterator)
-    bool operator==(const iteration_proxy_value& o) const
-    {
-        return anchor == o.anchor;
-    }
-
-    /// inequality operator (needed for range-based for)
-    bool operator!=(const iteration_proxy_value& o) const
-    {
-        return anchor != o.anchor;
-    }
-
-    /// return key of the iterator
-    const string_type& key() const
-    {
-        JSON_ASSERT(anchor.m_object != nullptr);
-
-        switch (anchor.m_object->type())
-        {
-            // use integer array index as key
-            case value_t::array:
-            {
-                if (array_index != array_index_last)
-                {
-                    int_to_string( array_index_str, array_index );
-                    array_index_last = array_index;
-                }
-                return array_index_str;
-            }
-
-            // use key from the object
-            case value_t::object:
-                return anchor.key();
-
-            // use an empty key for all primitive types
-            default:
-                return empty_str;
-        }
-    }
-
-    /// return value of the iterator
-    typename IteratorType::reference value() const
-    {
-        return anchor.value();
-    }
-};
-
-/// proxy class for the items() function
-template<typename IteratorType> class iteration_proxy
-{
-  private:
-    /// the container to iterate
-    typename IteratorType::reference container;
-
-  public:
-    /// construct iteration proxy from a container
-    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
-        : container(cont) {}
-
-    /// return iterator begin (needed for range-based for)
-    iteration_proxy_value<IteratorType> begin() noexcept
-    {
-        return iteration_proxy_value<IteratorType>(container.begin());
-    }
-
-    /// return iterator end (needed for range-based for)
-    iteration_proxy_value<IteratorType> end() noexcept
-    {
-        return iteration_proxy_value<IteratorType>(container.end());
-    }
-};
-// Structured Bindings Support
-// For further reference see https://blog.tartanllama.xyz/structured-bindings/
-// And see https://github.com/nlohmann/json/pull/1391
-template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
-auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
-{
-    return i.key();
-}
-// Structured Bindings Support
-// For further reference see https://blog.tartanllama.xyz/structured-bindings/
-// And see https://github.com/nlohmann/json/pull/1391
-template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
-auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
-{
-    return i.value();
-}
-}  // namespace detail
-}  // namespace nlohmann
-
-// The Addition to the STD Namespace is required to add
-// Structured Bindings Support to the iteration_proxy_value class
-// For further reference see https://blog.tartanllama.xyz/structured-bindings/
-// And see https://github.com/nlohmann/json/pull/1391
-namespace std
-{
-#if defined(__clang__)
-    // Fix: https://github.com/nlohmann/json/issues/1401
-    #pragma clang diagnostic push
-    #pragma clang diagnostic ignored "-Wmismatched-tags"
-#endif
-template<typename IteratorType>
-class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
-            : public std::integral_constant<std::size_t, 2> {};
-
-template<std::size_t N, typename IteratorType>
-class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
-{
-  public:
-    using type = decltype(
-                     get<N>(std::declval <
-                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
-};
-#if defined(__clang__)
-    #pragma clang diagnostic pop
-#endif
-} // namespace std
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-//////////////////
-// constructors //
-//////////////////
-
-template<value_t> struct external_constructor;
-
-template<>
-struct external_constructor<value_t::boolean>
-{
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
-    {
-        j.m_type = value_t::boolean;
-        j.m_value = b;
-        j.assert_invariant();
-    }
-};
-
-template<>
-struct external_constructor<value_t::string>
-{
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
-    {
-        j.m_type = value_t::string;
-        j.m_value = s;
-        j.assert_invariant();
-    }
-
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
-    {
-        j.m_type = value_t::string;
-        j.m_value = std::move(s);
-        j.assert_invariant();
-    }
-
-    template < typename BasicJsonType, typename CompatibleStringType,
-               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
-                             int > = 0 >
-    static void construct(BasicJsonType& j, const CompatibleStringType& str)
-    {
-        j.m_type = value_t::string;
-        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
-        j.assert_invariant();
-    }
-};
-
-template<>
-struct external_constructor<value_t::binary>
-{
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
-    {
-        j.m_type = value_t::binary;
-        typename BasicJsonType::binary_t value{b};
-        j.m_value = value;
-        j.assert_invariant();
-    }
-
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
-    {
-        j.m_type = value_t::binary;
-        typename BasicJsonType::binary_t value{std::move(b)};
-        j.m_value = value;
-        j.assert_invariant();
-    }
-};
-
-template<>
-struct external_constructor<value_t::number_float>
-{
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
-    {
-        j.m_type = value_t::number_float;
-        j.m_value = val;
-        j.assert_invariant();
-    }
-};
-
-template<>
-struct external_constructor<value_t::number_unsigned>
-{
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
-    {
-        j.m_type = value_t::number_unsigned;
-        j.m_value = val;
-        j.assert_invariant();
-    }
-};
-
-template<>
-struct external_constructor<value_t::number_integer>
-{
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
-    {
-        j.m_type = value_t::number_integer;
-        j.m_value = val;
-        j.assert_invariant();
-    }
-};
-
-template<>
-struct external_constructor<value_t::array>
-{
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
-    {
-        j.m_type = value_t::array;
-        j.m_value = arr;
-        j.assert_invariant();
-    }
-
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
-    {
-        j.m_type = value_t::array;
-        j.m_value = std::move(arr);
-        j.assert_invariant();
-    }
-
-    template < typename BasicJsonType, typename CompatibleArrayType,
-               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
-                             int > = 0 >
-    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
-    {
-        using std::begin;
-        using std::end;
-        j.m_type = value_t::array;
-        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
-        j.assert_invariant();
-    }
-
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
-    {
-        j.m_type = value_t::array;
-        j.m_value = value_t::array;
-        j.m_value.array->reserve(arr.size());
-        for (const bool x : arr)
-        {
-            j.m_value.array->push_back(x);
-        }
-        j.assert_invariant();
-    }
-
-    template<typename BasicJsonType, typename T,
-             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
-    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
-    {
-        j.m_type = value_t::array;
-        j.m_value = value_t::array;
-        j.m_value.array->resize(arr.size());
-        if (arr.size() > 0)
-        {
-            std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
-        }
-        j.assert_invariant();
-    }
-};
-
-template<>
-struct external_constructor<value_t::object>
-{
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
-    {
-        j.m_type = value_t::object;
-        j.m_value = obj;
-        j.assert_invariant();
-    }
-
-    template<typename BasicJsonType>
-    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
-    {
-        j.m_type = value_t::object;
-        j.m_value = std::move(obj);
-        j.assert_invariant();
-    }
-
-    template < typename BasicJsonType, typename CompatibleObjectType,
-               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
-    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
-    {
-        using std::begin;
-        using std::end;
-
-        j.m_type = value_t::object;
-        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
-        j.assert_invariant();
-    }
-};
-
-/////////////
-// to_json //
-/////////////
-
-template<typename BasicJsonType, typename T,
-         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
-void to_json(BasicJsonType& j, T b) noexcept
-{
-    external_constructor<value_t::boolean>::construct(j, b);
-}
-
-template<typename BasicJsonType, typename CompatibleString,
-         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
-void to_json(BasicJsonType& j, const CompatibleString& s)
-{
-    external_constructor<value_t::string>::construct(j, s);
-}
-
-template<typename BasicJsonType>
-void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
-{
-    external_constructor<value_t::string>::construct(j, std::move(s));
-}
-
-template<typename BasicJsonType, typename FloatType,
-         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
-void to_json(BasicJsonType& j, FloatType val) noexcept
-{
-    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
-}
-
-template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
-         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
-void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
-{
-    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
-}
-
-template<typename BasicJsonType, typename CompatibleNumberIntegerType,
-         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
-void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
-{
-    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
-}
-
-template<typename BasicJsonType, typename EnumType,
-         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
-void to_json(BasicJsonType& j, EnumType e) noexcept
-{
-    using underlying_type = typename std::underlying_type<EnumType>::type;
-    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
-}
-
-template<typename BasicJsonType>
-void to_json(BasicJsonType& j, const std::vector<bool>& e)
-{
-    external_constructor<value_t::array>::construct(j, e);
-}
-
-template < typename BasicJsonType, typename CompatibleArrayType,
-           enable_if_t < is_compatible_array_type<BasicJsonType,
-                         CompatibleArrayType>::value&&
-                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
-                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
-                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
-                         !is_basic_json<CompatibleArrayType>::value,
-                         int > = 0 >
-void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
-{
-    external_constructor<value_t::array>::construct(j, arr);
-}
-
-template<typename BasicJsonType>
-void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
-{
-    external_constructor<value_t::binary>::construct(j, bin);
-}
-
-template<typename BasicJsonType, typename T,
-         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
-void to_json(BasicJsonType& j, const std::valarray<T>& arr)
-{
-    external_constructor<value_t::array>::construct(j, std::move(arr));
-}
-
-template<typename BasicJsonType>
-void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
-{
-    external_constructor<value_t::array>::construct(j, std::move(arr));
-}
-
-template < typename BasicJsonType, typename CompatibleObjectType,
-           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
-void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
-{
-    external_constructor<value_t::object>::construct(j, obj);
-}
-
-template<typename BasicJsonType>
-void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
-{
-    external_constructor<value_t::object>::construct(j, std::move(obj));
-}
-
-template <
-    typename BasicJsonType, typename T, std::size_t N,
-    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
-                  const T(&)[N]>::value,
-                  int > = 0 >
-void to_json(BasicJsonType& j, const T(&arr)[N])
-{
-    external_constructor<value_t::array>::construct(j, arr);
-}
-
-template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
-void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
-{
-    j = { p.first, p.second };
-}
-
-// for https://github.com/nlohmann/json/pull/1134
-template<typename BasicJsonType, typename T,
-         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
-void to_json(BasicJsonType& j, const T& b)
-{
-    j = { {b.key(), b.value()} };
-}
-
-template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
-void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
-{
-    j = { std::get<Idx>(t)... };
-}
-
-template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
-void to_json(BasicJsonType& j, const T& t)
-{
-    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
-}
-
-struct to_json_fn
-{
-    template<typename BasicJsonType, typename T>
-    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
-    -> decltype(to_json(j, std::forward<T>(val)), void())
-    {
-        return to_json(j, std::forward<T>(val));
-    }
-};
-}  // namespace detail
-
-/// namespace to hold default `to_json` function
-namespace
-{
-constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
-} // namespace
-} // namespace nlohmann
-
-
-namespace nlohmann
-{
-
-template<typename, typename>
-struct adl_serializer
-{
-    /*!
-    @brief convert a JSON value to any value type
-
-    This function is usually called by the `get()` function of the
-    @ref basic_json class (either explicit or via conversion operators).
-
-    @param[in] j        JSON value to read from
-    @param[in,out] val  value to write to
-    */
-    template<typename BasicJsonType, typename ValueType>
-    static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(
-        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
-    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
-    {
-        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
-    }
-
-    /*!
-    @brief convert any value type to a JSON value
-
-    This function is usually called by the constructors of the @ref basic_json
-    class.
-
-    @param[in,out] j  JSON value to write to
-    @param[in] val    value to read from
-    */
-    template<typename BasicJsonType, typename ValueType>
-    static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
-        noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
-    -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())
-    {
-        ::nlohmann::to_json(j, std::forward<ValueType>(val));
-    }
-};
-
-}  // namespace nlohmann
-
-// #include <nlohmann/byte_container_with_subtype.hpp>
-
-
-#include <cstdint> // uint8_t
-#include <tuple> // tie
-#include <utility> // move
-
-namespace nlohmann
-{
-
-/*!
-@brief an internal type for a backed binary type
-
-This type extends the template parameter @a BinaryType provided to `basic_json`
-with a subtype used by BSON and MessagePack. This type exists so that the user
-does not have to specify a type themselves with a specific naming scheme in
-order to override the binary type.
-
-@tparam BinaryType container to store bytes (`std::vector<std::uint8_t>` by
-                   default)
-
-@since version 3.8.0
-*/
-template<typename BinaryType>
-class byte_container_with_subtype : public BinaryType
-{
-  public:
-    /// the type of the underlying container
-    using container_type = BinaryType;
-
-    byte_container_with_subtype() noexcept(noexcept(container_type()))
-        : container_type()
-    {}
-
-    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
-        : container_type(b)
-    {}
-
-    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
-        : container_type(std::move(b))
-    {}
-
-    byte_container_with_subtype(const container_type& b, std::uint8_t subtype) noexcept(noexcept(container_type(b)))
-        : container_type(b)
-        , m_subtype(subtype)
-        , m_has_subtype(true)
-    {}
-
-    byte_container_with_subtype(container_type&& b, std::uint8_t subtype) noexcept(noexcept(container_type(std::move(b))))
-        : container_type(std::move(b))
-        , m_subtype(subtype)
-        , m_has_subtype(true)
-    {}
-
-    bool operator==(const byte_container_with_subtype& rhs) const
-    {
-        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
-               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
-    }
-
-    bool operator!=(const byte_container_with_subtype& rhs) const
-    {
-        return !(rhs == *this);
-    }
-
-    /*!
-    @brief sets the binary subtype
-
-    Sets the binary subtype of the value, also flags a binary JSON value as
-    having a subtype, which has implications for serialization.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @sa @ref subtype() -- return the binary subtype
-    @sa @ref clear_subtype() -- clears the binary subtype
-    @sa @ref has_subtype() -- returns whether or not the binary value has a
-    subtype
-
-    @since version 3.8.0
-    */
-    void set_subtype(std::uint8_t subtype) noexcept
-    {
-        m_subtype = subtype;
-        m_has_subtype = true;
-    }
-
-    /*!
-    @brief return the binary subtype
-
-    Returns the numerical subtype of the value if it has a subtype. If it does
-    not have a subtype, this function will return size_t(-1) as a sentinel
-    value.
-
-    @return the numerical subtype of the binary value
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @sa @ref set_subtype() -- sets the binary subtype
-    @sa @ref clear_subtype() -- clears the binary subtype
-    @sa @ref has_subtype() -- returns whether or not the binary value has a
-    subtype
-
-    @since version 3.8.0
-    */
-    constexpr std::uint8_t subtype() const noexcept
-    {
-        return m_subtype;
-    }
-
-    /*!
-    @brief return whether the value has a subtype
-
-    @return whether the value has a subtype
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @sa @ref subtype() -- return the binary subtype
-    @sa @ref set_subtype() -- sets the binary subtype
-    @sa @ref clear_subtype() -- clears the binary subtype
-
-    @since version 3.8.0
-    */
-    constexpr bool has_subtype() const noexcept
-    {
-        return m_has_subtype;
-    }
-
-    /*!
-    @brief clears the binary subtype
-
-    Clears the binary subtype and flags the value as not having a subtype, which
-    has implications for serialization; for instance MessagePack will prefer the
-    bin family over the ext family.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @sa @ref subtype() -- return the binary subtype
-    @sa @ref set_subtype() -- sets the binary subtype
-    @sa @ref has_subtype() -- returns whether or not the binary value has a
-    subtype
-
-    @since version 3.8.0
-    */
-    void clear_subtype() noexcept
-    {
-        m_subtype = 0;
-        m_has_subtype = false;
-    }
-
-  private:
-    std::uint8_t m_subtype = 0;
-    bool m_has_subtype = false;
-};
-
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/conversions/from_json.hpp>
-
-// #include <nlohmann/detail/conversions/to_json.hpp>
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/hash.hpp>
-
-
-#include <cstddef> // size_t, uint8_t
-#include <functional> // hash
-
-namespace nlohmann
-{
-namespace detail
-{
-
-// boost::hash_combine
-inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
-{
-    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
-    return seed;
-}
-
-/*!
-@brief hash a JSON value
-
-The hash function tries to rely on std::hash where possible. Furthermore, the
-type of the JSON value is taken into account to have different hash values for
-null, 0, 0U, and false, etc.
-
-@tparam BasicJsonType basic_json specialization
-@param j JSON value to hash
-@return hash value of j
-*/
-template<typename BasicJsonType>
-std::size_t hash(const BasicJsonType& j)
-{
-    using string_t = typename BasicJsonType::string_t;
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-
-    const auto type = static_cast<std::size_t>(j.type());
-    switch (j.type())
-    {
-        case BasicJsonType::value_t::null:
-        case BasicJsonType::value_t::discarded:
-        {
-            return combine(type, 0);
-        }
-
-        case BasicJsonType::value_t::object:
-        {
-            auto seed = combine(type, j.size());
-            for (const auto& element : j.items())
-            {
-                const auto h = std::hash<string_t> {}(element.key());
-                seed = combine(seed, h);
-                seed = combine(seed, hash(element.value()));
-            }
-            return seed;
-        }
-
-        case BasicJsonType::value_t::array:
-        {
-            auto seed = combine(type, j.size());
-            for (const auto& element : j)
-            {
-                seed = combine(seed, hash(element));
-            }
-            return seed;
-        }
-
-        case BasicJsonType::value_t::string:
-        {
-            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
-            return combine(type, h);
-        }
-
-        case BasicJsonType::value_t::boolean:
-        {
-            const auto h = std::hash<bool> {}(j.template get<bool>());
-            return combine(type, h);
-        }
-
-        case BasicJsonType::value_t::number_integer:
-        {
-            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
-            return combine(type, h);
-        }
-
-        case nlohmann::detail::value_t::number_unsigned:
-        {
-            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
-            return combine(type, h);
-        }
-
-        case nlohmann::detail::value_t::number_float:
-        {
-            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
-            return combine(type, h);
-        }
-
-        case nlohmann::detail::value_t::binary:
-        {
-            auto seed = combine(type, j.get_binary().size());
-            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
-            seed = combine(seed, h);
-            seed = combine(seed, j.get_binary().subtype());
-            for (const auto byte : j.get_binary())
-            {
-                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
-            }
-            return seed;
-        }
-
-        default: // LCOV_EXCL_LINE
-            JSON_ASSERT(false); // LCOV_EXCL_LINE
-    }
-}
-
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/input/binary_reader.hpp>
-
-
-#include <algorithm> // generate_n
-#include <array> // array
-#include <cmath> // ldexp
-#include <cstddef> // size_t
-#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
-#include <cstdio> // snprintf
-#include <cstring> // memcpy
-#include <iterator> // back_inserter
-#include <limits> // numeric_limits
-#include <string> // char_traits, string
-#include <utility> // make_pair, move
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-
-#include <array> // array
-#include <cstddef> // size_t
-#include <cstdio> //FILE *
-#include <cstring> // strlen
-#include <istream> // istream
-#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
-#include <memory> // shared_ptr, make_shared, addressof
-#include <numeric> // accumulate
-#include <string> // string, char_traits
-#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
-#include <utility> // pair, declval
-
-// #include <nlohmann/detail/iterators/iterator_traits.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-/// the supported input formats
-enum class input_format_t { json, cbor, msgpack, ubjson, bson };
-
-////////////////////
-// input adapters //
-////////////////////
-
-/*!
-Input adapter for stdio file access. This adapter read only 1 byte and do not use any
- buffer. This adapter is a very low level adapter.
-*/
-class file_input_adapter
-{
-  public:
-    using char_type = char;
-
-    JSON_HEDLEY_NON_NULL(2)
-    explicit file_input_adapter(std::FILE* f) noexcept
-        : m_file(f)
-    {}
-
-    // make class move-only
-    file_input_adapter(const file_input_adapter&) = delete;
-    file_input_adapter(file_input_adapter&&) = default;
-    file_input_adapter& operator=(const file_input_adapter&) = delete;
-    file_input_adapter& operator=(file_input_adapter&&) = delete;
-
-    std::char_traits<char>::int_type get_character() noexcept
-    {
-        return std::fgetc(m_file);
-    }
-
-  private:
-    /// the file pointer to read from
-    std::FILE* m_file;
-};
-
-
-/*!
-Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
-beginning of input. Does not support changing the underlying std::streambuf
-in mid-input. Maintains underlying std::istream and std::streambuf to support
-subsequent use of standard std::istream operations to process any input
-characters following those used in parsing the JSON input.  Clears the
-std::istream flags; any input errors (e.g., EOF) will be detected by the first
-subsequent call for input from the std::istream.
-*/
-class input_stream_adapter
-{
-  public:
-    using char_type = char;
-
-    ~input_stream_adapter()
-    {
-        // clear stream flags; we use underlying streambuf I/O, do not
-        // maintain ifstream flags, except eof
-        if (is != nullptr)
-        {
-            is->clear(is->rdstate() & std::ios::eofbit);
-        }
-    }
-
-    explicit input_stream_adapter(std::istream& i)
-        : is(&i), sb(i.rdbuf())
-    {}
-
-    // delete because of pointer members
-    input_stream_adapter(const input_stream_adapter&) = delete;
-    input_stream_adapter& operator=(input_stream_adapter&) = delete;
-    input_stream_adapter& operator=(input_stream_adapter&& rhs) = delete;
-
-    input_stream_adapter(input_stream_adapter&& rhs) noexcept : is(rhs.is), sb(rhs.sb)
-    {
-        rhs.is = nullptr;
-        rhs.sb = nullptr;
-    }
-
-    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
-    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
-    // end up as the same value, eg. 0xFFFFFFFF.
-    std::char_traits<char>::int_type get_character()
-    {
-        auto res = sb->sbumpc();
-        // set eof manually, as we don't use the istream interface.
-        if (JSON_HEDLEY_UNLIKELY(res == EOF))
-        {
-            is->clear(is->rdstate() | std::ios::eofbit);
-        }
-        return res;
-    }
-
-  private:
-    /// the associated input stream
-    std::istream* is = nullptr;
-    std::streambuf* sb = nullptr;
-};
-
-// General-purpose iterator-based adapter. It might not be as fast as
-// theoretically possible for some containers, but it is extremely versatile.
-template<typename IteratorType>
-class iterator_input_adapter
-{
-  public:
-    using char_type = typename std::iterator_traits<IteratorType>::value_type;
-
-    iterator_input_adapter(IteratorType first, IteratorType last)
-        : current(std::move(first)), end(std::move(last)) {}
-
-    typename std::char_traits<char_type>::int_type get_character()
-    {
-        if (JSON_HEDLEY_LIKELY(current != end))
-        {
-            auto result = std::char_traits<char_type>::to_int_type(*current);
-            std::advance(current, 1);
-            return result;
-        }
-        else
-        {
-            return std::char_traits<char_type>::eof();
-        }
-    }
-
-  private:
-    IteratorType current;
-    IteratorType end;
-
-    template<typename BaseInputAdapter, size_t T>
-    friend struct wide_string_input_helper;
-
-    bool empty() const
-    {
-        return current == end;
-    }
-
-};
-
-
-template<typename BaseInputAdapter, size_t T>
-struct wide_string_input_helper;
-
-template<typename BaseInputAdapter>
-struct wide_string_input_helper<BaseInputAdapter, 4>
-{
-    // UTF-32
-    static void fill_buffer(BaseInputAdapter& input,
-                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
-                            size_t& utf8_bytes_index,
-                            size_t& utf8_bytes_filled)
-    {
-        utf8_bytes_index = 0;
-
-        if (JSON_HEDLEY_UNLIKELY(input.empty()))
-        {
-            utf8_bytes[0] = std::char_traits<char>::eof();
-            utf8_bytes_filled = 1;
-        }
-        else
-        {
-            // get the current character
-            const auto wc = input.get_character();
-
-            // UTF-32 to UTF-8 encoding
-            if (wc < 0x80)
-            {
-                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
-                utf8_bytes_filled = 1;
-            }
-            else if (wc <= 0x7FF)
-            {
-                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
-                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-                utf8_bytes_filled = 2;
-            }
-            else if (wc <= 0xFFFF)
-            {
-                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
-                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
-                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-                utf8_bytes_filled = 3;
-            }
-            else if (wc <= 0x10FFFF)
-            {
-                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
-                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
-                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
-                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-                utf8_bytes_filled = 4;
-            }
-            else
-            {
-                // unknown character
-                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
-                utf8_bytes_filled = 1;
-            }
-        }
-    }
-};
-
-template<typename BaseInputAdapter>
-struct wide_string_input_helper<BaseInputAdapter, 2>
-{
-    // UTF-16
-    static void fill_buffer(BaseInputAdapter& input,
-                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
-                            size_t& utf8_bytes_index,
-                            size_t& utf8_bytes_filled)
-    {
-        utf8_bytes_index = 0;
-
-        if (JSON_HEDLEY_UNLIKELY(input.empty()))
-        {
-            utf8_bytes[0] = std::char_traits<char>::eof();
-            utf8_bytes_filled = 1;
-        }
-        else
-        {
-            // get the current character
-            const auto wc = input.get_character();
-
-            // UTF-16 to UTF-8 encoding
-            if (wc < 0x80)
-            {
-                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
-                utf8_bytes_filled = 1;
-            }
-            else if (wc <= 0x7FF)
-            {
-                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
-                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-                utf8_bytes_filled = 2;
-            }
-            else if (0xD800 > wc || wc >= 0xE000)
-            {
-                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
-                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
-                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-                utf8_bytes_filled = 3;
-            }
-            else
-            {
-                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
-                {
-                    const auto wc2 = static_cast<unsigned int>(input.get_character());
-                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
-                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
-                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
-                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
-                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
-                    utf8_bytes_filled = 4;
-                }
-                else
-                {
-                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
-                    utf8_bytes_filled = 1;
-                }
-            }
-        }
-    }
-};
-
-// Wraps another input apdater to convert wide character types into individual bytes.
-template<typename BaseInputAdapter, typename WideCharType>
-class wide_string_input_adapter
-{
-  public:
-    using char_type = char;
-
-    wide_string_input_adapter(BaseInputAdapter base)
-        : base_adapter(base) {}
-
-    typename std::char_traits<char>::int_type get_character() noexcept
-    {
-        // check if buffer needs to be filled
-        if (utf8_bytes_index == utf8_bytes_filled)
-        {
-            fill_buffer<sizeof(WideCharType)>();
-
-            JSON_ASSERT(utf8_bytes_filled > 0);
-            JSON_ASSERT(utf8_bytes_index == 0);
-        }
-
-        // use buffer
-        JSON_ASSERT(utf8_bytes_filled > 0);
-        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
-        return utf8_bytes[utf8_bytes_index++];
-    }
-
-  private:
-    BaseInputAdapter base_adapter;
-
-    template<size_t T>
-    void fill_buffer()
-    {
-        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
-    }
-
-    /// a buffer for UTF-8 bytes
-    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
-
-    /// index to the utf8_codes array for the next valid byte
-    std::size_t utf8_bytes_index = 0;
-    /// number of valid bytes in the utf8_codes array
-    std::size_t utf8_bytes_filled = 0;
-};
-
-
-template<typename IteratorType, typename Enable = void>
-struct iterator_input_adapter_factory
-{
-    using iterator_type = IteratorType;
-    using char_type = typename std::iterator_traits<iterator_type>::value_type;
-    using adapter_type = iterator_input_adapter<iterator_type>;
-
-    static adapter_type create(IteratorType first, IteratorType last)
-    {
-        return adapter_type(std::move(first), std::move(last));
-    }
-};
-
-template<typename T>
-struct is_iterator_of_multibyte
-{
-    using value_type = typename std::iterator_traits<T>::value_type;
-    enum
-    {
-        value = sizeof(value_type) > 1
-    };
-};
-
-template<typename IteratorType>
-struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
-{
-    using iterator_type = IteratorType;
-    using char_type = typename std::iterator_traits<iterator_type>::value_type;
-    using base_adapter_type = iterator_input_adapter<iterator_type>;
-    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
-
-    static adapter_type create(IteratorType first, IteratorType last)
-    {
-        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
-    }
-};
-
-// General purpose iterator-based input
-template<typename IteratorType>
-typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
-{
-    using factory_type = iterator_input_adapter_factory<IteratorType>;
-    return factory_type::create(first, last);
-}
-
-// Convenience shorthand from container to iterator
-template<typename ContainerType>
-auto input_adapter(const ContainerType& container) -> decltype(input_adapter(begin(container), end(container)))
-{
-    // Enable ADL
-    using std::begin;
-    using std::end;
-
-    return input_adapter(begin(container), end(container));
-}
-
-// Special cases with fast paths
-inline file_input_adapter input_adapter(std::FILE* file)
-{
-    return file_input_adapter(file);
-}
-
-inline input_stream_adapter input_adapter(std::istream& stream)
-{
-    return input_stream_adapter(stream);
-}
-
-inline input_stream_adapter input_adapter(std::istream&& stream)
-{
-    return input_stream_adapter(stream);
-}
-
-using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
-
-// Null-delimited strings, and the like.
-template < typename CharT,
-           typename std::enable_if <
-               std::is_pointer<CharT>::value&&
-               !std::is_array<CharT>::value&&
-               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
-               sizeof(typename std::remove_pointer<CharT>::type) == 1,
-               int >::type = 0 >
-contiguous_bytes_input_adapter input_adapter(CharT b)
-{
-    auto length = std::strlen(reinterpret_cast<const char*>(b));
-    const auto* ptr = reinterpret_cast<const char*>(b);
-    return input_adapter(ptr, ptr + length);
-}
-
-template<typename T, std::size_t N>
-auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
-{
-    return input_adapter(array, array + N);
-}
-
-// This class only handles inputs of input_buffer_adapter type.
-// It's required so that expressions like {ptr, len} can be implicitely casted
-// to the correct adapter.
-class span_input_adapter
-{
-  public:
-    template < typename CharT,
-               typename std::enable_if <
-                   std::is_pointer<CharT>::value&&
-                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
-                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
-                   int >::type = 0 >
-    span_input_adapter(CharT b, std::size_t l)
-        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
-
-    template<class IteratorType,
-             typename std::enable_if<
-                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
-                 int>::type = 0>
-    span_input_adapter(IteratorType first, IteratorType last)
-        : ia(input_adapter(first, last)) {}
-
-    contiguous_bytes_input_adapter&& get()
-    {
-        return std::move(ia);
-    }
-
-  private:
-    contiguous_bytes_input_adapter ia;
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/input/json_sax.hpp>
-
-
-#include <cstddef>
-#include <string> // string
-#include <utility> // move
-#include <vector> // vector
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-
-namespace nlohmann
-{
-
-/*!
-@brief SAX interface
-
-This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
-Each function is called in different situations while the input is parsed. The
-boolean return value informs the parser whether to continue processing the
-input.
-*/
-template<typename BasicJsonType>
-struct json_sax
-{
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using string_t = typename BasicJsonType::string_t;
-    using binary_t = typename BasicJsonType::binary_t;
-
-    /*!
-    @brief a null value was read
-    @return whether parsing should proceed
-    */
-    virtual bool null() = 0;
-
-    /*!
-    @brief a boolean value was read
-    @param[in] val  boolean value
-    @return whether parsing should proceed
-    */
-    virtual bool boolean(bool val) = 0;
-
-    /*!
-    @brief an integer number was read
-    @param[in] val  integer value
-    @return whether parsing should proceed
-    */
-    virtual bool number_integer(number_integer_t val) = 0;
-
-    /*!
-    @brief an unsigned integer number was read
-    @param[in] val  unsigned integer value
-    @return whether parsing should proceed
-    */
-    virtual bool number_unsigned(number_unsigned_t val) = 0;
-
-    /*!
-    @brief an floating-point number was read
-    @param[in] val  floating-point value
-    @param[in] s    raw token value
-    @return whether parsing should proceed
-    */
-    virtual bool number_float(number_float_t val, const string_t& s) = 0;
-
-    /*!
-    @brief a string was read
-    @param[in] val  string value
-    @return whether parsing should proceed
-    @note It is safe to move the passed string.
-    */
-    virtual bool string(string_t& val) = 0;
-
-    /*!
-    @brief a binary string was read
-    @param[in] val  binary value
-    @return whether parsing should proceed
-    @note It is safe to move the passed binary.
-    */
-    virtual bool binary(binary_t& val) = 0;
-
-    /*!
-    @brief the beginning of an object was read
-    @param[in] elements  number of object elements or -1 if unknown
-    @return whether parsing should proceed
-    @note binary formats may report the number of elements
-    */
-    virtual bool start_object(std::size_t elements) = 0;
-
-    /*!
-    @brief an object key was read
-    @param[in] val  object key
-    @return whether parsing should proceed
-    @note It is safe to move the passed string.
-    */
-    virtual bool key(string_t& val) = 0;
-
-    /*!
-    @brief the end of an object was read
-    @return whether parsing should proceed
-    */
-    virtual bool end_object() = 0;
-
-    /*!
-    @brief the beginning of an array was read
-    @param[in] elements  number of array elements or -1 if unknown
-    @return whether parsing should proceed
-    @note binary formats may report the number of elements
-    */
-    virtual bool start_array(std::size_t elements) = 0;
-
-    /*!
-    @brief the end of an array was read
-    @return whether parsing should proceed
-    */
-    virtual bool end_array() = 0;
-
-    /*!
-    @brief a parse error occurred
-    @param[in] position    the position in the input where the error occurs
-    @param[in] last_token  the last read token
-    @param[in] ex          an exception object describing the error
-    @return whether parsing should proceed (must return false)
-    */
-    virtual bool parse_error(std::size_t position,
-                             const std::string& last_token,
-                             const detail::exception& ex) = 0;
-
-    virtual ~json_sax() = default;
-};
-
-
-namespace detail
-{
-/*!
-@brief SAX implementation to create a JSON value from SAX events
-
-This class implements the @ref json_sax interface and processes the SAX events
-to create a JSON value which makes it basically a DOM parser. The structure or
-hierarchy of the JSON value is managed by the stack `ref_stack` which contains
-a pointer to the respective array or object for each recursion depth.
-
-After successful parsing, the value that is passed by reference to the
-constructor contains the parsed value.
-
-@tparam BasicJsonType  the JSON type
-*/
-template<typename BasicJsonType>
-class json_sax_dom_parser
-{
-  public:
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using string_t = typename BasicJsonType::string_t;
-    using binary_t = typename BasicJsonType::binary_t;
-
-    /*!
-    @param[in, out] r  reference to a JSON value that is manipulated while
-                       parsing
-    @param[in] allow_exceptions_  whether parse errors yield exceptions
-    */
-    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
-        : root(r), allow_exceptions(allow_exceptions_)
-    {}
-
-    // make class move-only
-    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
-    json_sax_dom_parser(json_sax_dom_parser&&) = default;
-    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
-    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default;
-    ~json_sax_dom_parser() = default;
-
-    bool null()
-    {
-        handle_value(nullptr);
-        return true;
-    }
-
-    bool boolean(bool val)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool number_integer(number_integer_t val)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool number_unsigned(number_unsigned_t val)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool number_float(number_float_t val, const string_t& /*unused*/)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool string(string_t& val)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool binary(binary_t& val)
-    {
-        handle_value(std::move(val));
-        return true;
-    }
-
-    bool start_object(std::size_t len)
-    {
-        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
-
-        if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
-        {
-            JSON_THROW(out_of_range::create(408,
-                                            "excessive object size: " + std::to_string(len)));
-        }
-
-        return true;
-    }
-
-    bool key(string_t& val)
-    {
-        // add null at given key and store the reference for later
-        object_element = &(ref_stack.back()->m_value.object->operator[](val));
-        return true;
-    }
-
-    bool end_object()
-    {
-        ref_stack.pop_back();
-        return true;
-    }
-
-    bool start_array(std::size_t len)
-    {
-        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
-
-        if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
-        {
-            JSON_THROW(out_of_range::create(408,
-                                            "excessive array size: " + std::to_string(len)));
-        }
-
-        return true;
-    }
-
-    bool end_array()
-    {
-        ref_stack.pop_back();
-        return true;
-    }
-
-    template<class Exception>
-    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
-                     const Exception& ex)
-    {
-        errored = true;
-        static_cast<void>(ex);
-        if (allow_exceptions)
-        {
-            JSON_THROW(ex);
-        }
-        return false;
-    }
-
-    constexpr bool is_errored() const
-    {
-        return errored;
-    }
-
-  private:
-    /*!
-    @invariant If the ref stack is empty, then the passed value will be the new
-               root.
-    @invariant If the ref stack contains a value, then it is an array or an
-               object to which we can add elements
-    */
-    template<typename Value>
-    JSON_HEDLEY_RETURNS_NON_NULL
-    BasicJsonType* handle_value(Value&& v)
-    {
-        if (ref_stack.empty())
-        {
-            root = BasicJsonType(std::forward<Value>(v));
-            return &root;
-        }
-
-        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
-
-        if (ref_stack.back()->is_array())
-        {
-            ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
-            return &(ref_stack.back()->m_value.array->back());
-        }
-
-        JSON_ASSERT(ref_stack.back()->is_object());
-        JSON_ASSERT(object_element);
-        *object_element = BasicJsonType(std::forward<Value>(v));
-        return object_element;
-    }
-
-    /// the parsed JSON value
-    BasicJsonType& root;
-    /// stack to model hierarchy of values
-    std::vector<BasicJsonType*> ref_stack {};
-    /// helper to hold the reference for the next object element
-    BasicJsonType* object_element = nullptr;
-    /// whether a syntax error occurred
-    bool errored = false;
-    /// whether to throw exceptions in case of errors
-    const bool allow_exceptions = true;
-};
-
-template<typename BasicJsonType>
-class json_sax_dom_callback_parser
-{
-  public:
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using string_t = typename BasicJsonType::string_t;
-    using binary_t = typename BasicJsonType::binary_t;
-    using parser_callback_t = typename BasicJsonType::parser_callback_t;
-    using parse_event_t = typename BasicJsonType::parse_event_t;
-
-    json_sax_dom_callback_parser(BasicJsonType& r,
-                                 const parser_callback_t cb,
-                                 const bool allow_exceptions_ = true)
-        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
-    {
-        keep_stack.push_back(true);
-    }
-
-    // make class move-only
-    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
-    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default;
-    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
-    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default;
-    ~json_sax_dom_callback_parser() = default;
-
-    bool null()
-    {
-        handle_value(nullptr);
-        return true;
-    }
-
-    bool boolean(bool val)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool number_integer(number_integer_t val)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool number_unsigned(number_unsigned_t val)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool number_float(number_float_t val, const string_t& /*unused*/)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool string(string_t& val)
-    {
-        handle_value(val);
-        return true;
-    }
-
-    bool binary(binary_t& val)
-    {
-        handle_value(std::move(val));
-        return true;
-    }
-
-    bool start_object(std::size_t len)
-    {
-        // check callback for object start
-        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
-        keep_stack.push_back(keep);
-
-        auto val = handle_value(BasicJsonType::value_t::object, true);
-        ref_stack.push_back(val.second);
-
-        // check object limit
-        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
-        {
-            JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
-        }
-
-        return true;
-    }
-
-    bool key(string_t& val)
-    {
-        BasicJsonType k = BasicJsonType(val);
-
-        // check callback for key
-        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
-        key_keep_stack.push_back(keep);
-
-        // add discarded value at given key and store the reference for later
-        if (keep && ref_stack.back())
-        {
-            object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
-        }
-
-        return true;
-    }
-
-    bool end_object()
-    {
-        if (ref_stack.back() && !callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
-        {
-            // discard object
-            *ref_stack.back() = discarded;
-        }
-
-        JSON_ASSERT(!ref_stack.empty());
-        JSON_ASSERT(!keep_stack.empty());
-        ref_stack.pop_back();
-        keep_stack.pop_back();
-
-        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
-        {
-            // remove discarded value
-            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
-            {
-                if (it->is_discarded())
-                {
-                    ref_stack.back()->erase(it);
-                    break;
-                }
-            }
-        }
-
-        return true;
-    }
-
-    bool start_array(std::size_t len)
-    {
-        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
-        keep_stack.push_back(keep);
-
-        auto val = handle_value(BasicJsonType::value_t::array, true);
-        ref_stack.push_back(val.second);
-
-        // check array limit
-        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
-        {
-            JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
-        }
-
-        return true;
-    }
-
-    bool end_array()
-    {
-        bool keep = true;
-
-        if (ref_stack.back())
-        {
-            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
-            if (!keep)
-            {
-                // discard array
-                *ref_stack.back() = discarded;
-            }
-        }
-
-        JSON_ASSERT(!ref_stack.empty());
-        JSON_ASSERT(!keep_stack.empty());
-        ref_stack.pop_back();
-        keep_stack.pop_back();
-
-        // remove discarded value
-        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
-        {
-            ref_stack.back()->m_value.array->pop_back();
-        }
-
-        return true;
-    }
-
-    template<class Exception>
-    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
-                     const Exception& ex)
-    {
-        errored = true;
-        static_cast<void>(ex);
-        if (allow_exceptions)
-        {
-            JSON_THROW(ex);
-        }
-        return false;
-    }
-
-    constexpr bool is_errored() const
-    {
-        return errored;
-    }
-
-  private:
-    /*!
-    @param[in] v  value to add to the JSON value we build during parsing
-    @param[in] skip_callback  whether we should skip calling the callback
-               function; this is required after start_array() and
-               start_object() SAX events, because otherwise we would call the
-               callback function with an empty array or object, respectively.
-
-    @invariant If the ref stack is empty, then the passed value will be the new
-               root.
-    @invariant If the ref stack contains a value, then it is an array or an
-               object to which we can add elements
-
-    @return pair of boolean (whether value should be kept) and pointer (to the
-            passed value in the ref_stack hierarchy; nullptr if not kept)
-    */
-    template<typename Value>
-    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
-    {
-        JSON_ASSERT(!keep_stack.empty());
-
-        // do not handle this value if we know it would be added to a discarded
-        // container
-        if (!keep_stack.back())
-        {
-            return {false, nullptr};
-        }
-
-        // create value
-        auto value = BasicJsonType(std::forward<Value>(v));
-
-        // check callback
-        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
-
-        // do not handle this value if we just learnt it shall be discarded
-        if (!keep)
-        {
-            return {false, nullptr};
-        }
-
-        if (ref_stack.empty())
-        {
-            root = std::move(value);
-            return {true, &root};
-        }
-
-        // skip this value if we already decided to skip the parent
-        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
-        if (!ref_stack.back())
-        {
-            return {false, nullptr};
-        }
-
-        // we now only expect arrays and objects
-        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
-
-        // array
-        if (ref_stack.back()->is_array())
-        {
-            ref_stack.back()->m_value.array->push_back(std::move(value));
-            return {true, &(ref_stack.back()->m_value.array->back())};
-        }
-
-        // object
-        JSON_ASSERT(ref_stack.back()->is_object());
-        // check if we should store an element for the current key
-        JSON_ASSERT(!key_keep_stack.empty());
-        const bool store_element = key_keep_stack.back();
-        key_keep_stack.pop_back();
-
-        if (!store_element)
-        {
-            return {false, nullptr};
-        }
-
-        JSON_ASSERT(object_element);
-        *object_element = std::move(value);
-        return {true, object_element};
-    }
-
-    /// the parsed JSON value
-    BasicJsonType& root;
-    /// stack to model hierarchy of values
-    std::vector<BasicJsonType*> ref_stack {};
-    /// stack to manage which values to keep
-    std::vector<bool> keep_stack {};
-    /// stack to manage which object keys to keep
-    std::vector<bool> key_keep_stack {};
-    /// helper to hold the reference for the next object element
-    BasicJsonType* object_element = nullptr;
-    /// whether a syntax error occurred
-    bool errored = false;
-    /// callback function
-    const parser_callback_t callback = nullptr;
-    /// whether to throw exceptions in case of errors
-    const bool allow_exceptions = true;
-    /// a discarded value for the callback
-    BasicJsonType discarded = BasicJsonType::value_t::discarded;
-};
-
-template<typename BasicJsonType>
-class json_sax_acceptor
-{
-  public:
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using string_t = typename BasicJsonType::string_t;
-    using binary_t = typename BasicJsonType::binary_t;
-
-    bool null()
-    {
-        return true;
-    }
-
-    bool boolean(bool /*unused*/)
-    {
-        return true;
-    }
-
-    bool number_integer(number_integer_t /*unused*/)
-    {
-        return true;
-    }
-
-    bool number_unsigned(number_unsigned_t /*unused*/)
-    {
-        return true;
-    }
-
-    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
-    {
-        return true;
-    }
-
-    bool string(string_t& /*unused*/)
-    {
-        return true;
-    }
-
-    bool binary(binary_t& /*unused*/)
-    {
-        return true;
-    }
-
-    bool start_object(std::size_t /*unused*/ = std::size_t(-1))
-    {
-        return true;
-    }
-
-    bool key(string_t& /*unused*/)
-    {
-        return true;
-    }
-
-    bool end_object()
-    {
-        return true;
-    }
-
-    bool start_array(std::size_t /*unused*/ = std::size_t(-1))
-    {
-        return true;
-    }
-
-    bool end_array()
-    {
-        return true;
-    }
-
-    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
-    {
-        return false;
-    }
-};
-}  // namespace detail
-
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/input/lexer.hpp>
-
-
-#include <array> // array
-#include <clocale> // localeconv
-#include <cstddef> // size_t
-#include <cstdio> // snprintf
-#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
-#include <initializer_list> // initializer_list
-#include <string> // char_traits, string
-#include <utility> // move
-#include <vector> // vector
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-// #include <nlohmann/detail/input/position_t.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-///////////
-// lexer //
-///////////
-
-template<typename BasicJsonType>
-class lexer_base
-{
-  public:
-    /// token types for the parser
-    enum class token_type
-    {
-        uninitialized,    ///< indicating the scanner is uninitialized
-        literal_true,     ///< the `true` literal
-        literal_false,    ///< the `false` literal
-        literal_null,     ///< the `null` literal
-        value_string,     ///< a string -- use get_string() for actual value
-        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
-        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
-        value_float,      ///< an floating point number -- use get_number_float() for actual value
-        begin_array,      ///< the character for array begin `[`
-        begin_object,     ///< the character for object begin `{`
-        end_array,        ///< the character for array end `]`
-        end_object,       ///< the character for object end `}`
-        name_separator,   ///< the name separator `:`
-        value_separator,  ///< the value separator `,`
-        parse_error,      ///< indicating a parse error
-        end_of_input,     ///< indicating the end of the input buffer
-        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
-    };
-
-    /// return name of values of type token_type (only used for errors)
-    JSON_HEDLEY_RETURNS_NON_NULL
-    JSON_HEDLEY_CONST
-    static const char* token_type_name(const token_type t) noexcept
-    {
-        switch (t)
-        {
-            case token_type::uninitialized:
-                return "<uninitialized>";
-            case token_type::literal_true:
-                return "true literal";
-            case token_type::literal_false:
-                return "false literal";
-            case token_type::literal_null:
-                return "null literal";
-            case token_type::value_string:
-                return "string literal";
-            case token_type::value_unsigned:
-            case token_type::value_integer:
-            case token_type::value_float:
-                return "number literal";
-            case token_type::begin_array:
-                return "'['";
-            case token_type::begin_object:
-                return "'{'";
-            case token_type::end_array:
-                return "']'";
-            case token_type::end_object:
-                return "'}'";
-            case token_type::name_separator:
-                return "':'";
-            case token_type::value_separator:
-                return "','";
-            case token_type::parse_error:
-                return "<parse error>";
-            case token_type::end_of_input:
-                return "end of input";
-            case token_type::literal_or_value:
-                return "'[', '{', or a literal";
-            // LCOV_EXCL_START
-            default: // catch non-enum values
-                return "unknown token";
-                // LCOV_EXCL_STOP
-        }
-    }
-};
-/*!
-@brief lexical analysis
-
-This class organizes the lexical analysis during JSON deserialization.
-*/
-template<typename BasicJsonType, typename InputAdapterType>
-class lexer : public lexer_base<BasicJsonType>
-{
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using string_t = typename BasicJsonType::string_t;
-    using char_type = typename InputAdapterType::char_type;
-    using char_int_type = typename std::char_traits<char_type>::int_type;
-
-  public:
-    using token_type = typename lexer_base<BasicJsonType>::token_type;
-
-    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false)
-        : ia(std::move(adapter))
-        , ignore_comments(ignore_comments_)
-        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
-    {}
-
-    // delete because of pointer members
-    lexer(const lexer&) = delete;
-    lexer(lexer&&) = default;
-    lexer& operator=(lexer&) = delete;
-    lexer& operator=(lexer&&) = default;
-    ~lexer() = default;
-
-  private:
-    /////////////////////
-    // locales
-    /////////////////////
-
-    /// return the locale-dependent decimal point
-    JSON_HEDLEY_PURE
-    static char get_decimal_point() noexcept
-    {
-        const auto* loc = localeconv();
-        JSON_ASSERT(loc != nullptr);
-        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
-    }
-
-    /////////////////////
-    // scan functions
-    /////////////////////
-
-    /*!
-    @brief get codepoint from 4 hex characters following `\u`
-
-    For input "\u c1 c2 c3 c4" the codepoint is:
-      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
-    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
-
-    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
-    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
-    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
-    between the ASCII value of the character and the desired integer value.
-
-    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
-            non-hex character)
-    */
-    int get_codepoint()
-    {
-        // this function only makes sense after reading `\u`
-        JSON_ASSERT(current == 'u');
-        int codepoint = 0;
-
-        const auto factors = { 12u, 8u, 4u, 0u };
-        for (const auto factor : factors)
-        {
-            get();
-
-            if (current >= '0' && current <= '9')
-            {
-                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
-            }
-            else if (current >= 'A' && current <= 'F')
-            {
-                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
-            }
-            else if (current >= 'a' && current <= 'f')
-            {
-                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
-            }
-            else
-            {
-                return -1;
-            }
-        }
-
-        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
-        return codepoint;
-    }
-
-    /*!
-    @brief check if the next byte(s) are inside a given range
-
-    Adds the current byte and, for each passed range, reads a new byte and
-    checks if it is inside the range. If a violation was detected, set up an
-    error message and return false. Otherwise, return true.
-
-    @param[in] ranges  list of integers; interpreted as list of pairs of
-                       inclusive lower and upper bound, respectively
-
-    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
-         1, 2, or 3 pairs. This precondition is enforced by an assertion.
-
-    @return true if and only if no range violation was detected
-    */
-    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
-    {
-        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
-        add(current);
-
-        for (auto range = ranges.begin(); range != ranges.end(); ++range)
-        {
-            get();
-            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
-            {
-                add(current);
-            }
-            else
-            {
-                error_message = "invalid string: ill-formed UTF-8 byte";
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /*!
-    @brief scan a string literal
-
-    This function scans a string according to Sect. 7 of RFC 7159. While
-    scanning, bytes are escaped and copied into buffer token_buffer. Then the
-    function returns successfully, token_buffer is *not* null-terminated (as it
-    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
-    string.
-
-    @return token_type::value_string if string could be successfully scanned,
-            token_type::parse_error otherwise
-
-    @note In case of errors, variable error_message contains a textual
-          description.
-    */
-    token_type scan_string()
-    {
-        // reset token_buffer (ignore opening quote)
-        reset();
-
-        // we entered the function by reading an open quote
-        JSON_ASSERT(current == '\"');
-
-        while (true)
-        {
-            // get next character
-            switch (get())
-            {
-                // end of file while parsing string
-                case std::char_traits<char_type>::eof():
-                {
-                    error_message = "invalid string: missing closing quote";
-                    return token_type::parse_error;
-                }
-
-                // closing quote
-                case '\"':
-                {
-                    return token_type::value_string;
-                }
-
-                // escapes
-                case '\\':
-                {
-                    switch (get())
-                    {
-                        // quotation mark
-                        case '\"':
-                            add('\"');
-                            break;
-                        // reverse solidus
-                        case '\\':
-                            add('\\');
-                            break;
-                        // solidus
-                        case '/':
-                            add('/');
-                            break;
-                        // backspace
-                        case 'b':
-                            add('\b');
-                            break;
-                        // form feed
-                        case 'f':
-                            add('\f');
-                            break;
-                        // line feed
-                        case 'n':
-                            add('\n');
-                            break;
-                        // carriage return
-                        case 'r':
-                            add('\r');
-                            break;
-                        // tab
-                        case 't':
-                            add('\t');
-                            break;
-
-                        // unicode escapes
-                        case 'u':
-                        {
-                            const int codepoint1 = get_codepoint();
-                            int codepoint = codepoint1; // start with codepoint1
-
-                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
-                            {
-                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
-                                return token_type::parse_error;
-                            }
-
-                            // check if code point is a high surrogate
-                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
-                            {
-                                // expect next \uxxxx entry
-                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
-                                {
-                                    const int codepoint2 = get_codepoint();
-
-                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
-                                    {
-                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
-                                        return token_type::parse_error;
-                                    }
-
-                                    // check if codepoint2 is a low surrogate
-                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
-                                    {
-                                        // overwrite codepoint
-                                        codepoint = static_cast<int>(
-                                                        // high surrogate occupies the most significant 22 bits
-                                                        (static_cast<unsigned int>(codepoint1) << 10u)
-                                                        // low surrogate occupies the least significant 15 bits
-                                                        + static_cast<unsigned int>(codepoint2)
-                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
-                                                        // in the result so we have to subtract with:
-                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
-                                                        - 0x35FDC00u);
-                                    }
-                                    else
-                                    {
-                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
-                                        return token_type::parse_error;
-                                    }
-                                }
-                                else
-                                {
-                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
-                                    return token_type::parse_error;
-                                }
-                            }
-                            else
-                            {
-                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
-                                {
-                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
-                                    return token_type::parse_error;
-                                }
-                            }
-
-                            // result of the above calculation yields a proper codepoint
-                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
-
-                            // translate codepoint into bytes
-                            if (codepoint < 0x80)
-                            {
-                                // 1-byte characters: 0xxxxxxx (ASCII)
-                                add(static_cast<char_int_type>(codepoint));
-                            }
-                            else if (codepoint <= 0x7FF)
-                            {
-                                // 2-byte characters: 110xxxxx 10xxxxxx
-                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
-                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
-                            }
-                            else if (codepoint <= 0xFFFF)
-                            {
-                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
-                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
-                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
-                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
-                            }
-                            else
-                            {
-                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
-                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
-                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
-                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
-                            }
-
-                            break;
-                        }
-
-                        // other characters after escape
-                        default:
-                            error_message = "invalid string: forbidden character after backslash";
-                            return token_type::parse_error;
-                    }
-
-                    break;
-                }
-
-                // invalid control characters
-                case 0x00:
-                {
-                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
-                    return token_type::parse_error;
-                }
-
-                case 0x01:
-                {
-                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
-                    return token_type::parse_error;
-                }
-
-                case 0x02:
-                {
-                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
-                    return token_type::parse_error;
-                }
-
-                case 0x03:
-                {
-                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
-                    return token_type::parse_error;
-                }
-
-                case 0x04:
-                {
-                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
-                    return token_type::parse_error;
-                }
-
-                case 0x05:
-                {
-                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
-                    return token_type::parse_error;
-                }
-
-                case 0x06:
-                {
-                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
-                    return token_type::parse_error;
-                }
-
-                case 0x07:
-                {
-                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
-                    return token_type::parse_error;
-                }
-
-                case 0x08:
-                {
-                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
-                    return token_type::parse_error;
-                }
-
-                case 0x09:
-                {
-                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
-                    return token_type::parse_error;
-                }
-
-                case 0x0A:
-                {
-                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
-                    return token_type::parse_error;
-                }
-
-                case 0x0B:
-                {
-                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
-                    return token_type::parse_error;
-                }
-
-                case 0x0C:
-                {
-                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
-                    return token_type::parse_error;
-                }
-
-                case 0x0D:
-                {
-                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
-                    return token_type::parse_error;
-                }
-
-                case 0x0E:
-                {
-                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
-                    return token_type::parse_error;
-                }
-
-                case 0x0F:
-                {
-                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
-                    return token_type::parse_error;
-                }
-
-                case 0x10:
-                {
-                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
-                    return token_type::parse_error;
-                }
-
-                case 0x11:
-                {
-                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
-                    return token_type::parse_error;
-                }
-
-                case 0x12:
-                {
-                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
-                    return token_type::parse_error;
-                }
-
-                case 0x13:
-                {
-                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
-                    return token_type::parse_error;
-                }
-
-                case 0x14:
-                {
-                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
-                    return token_type::parse_error;
-                }
-
-                case 0x15:
-                {
-                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
-                    return token_type::parse_error;
-                }
-
-                case 0x16:
-                {
-                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
-                    return token_type::parse_error;
-                }
-
-                case 0x17:
-                {
-                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
-                    return token_type::parse_error;
-                }
-
-                case 0x18:
-                {
-                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
-                    return token_type::parse_error;
-                }
-
-                case 0x19:
-                {
-                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
-                    return token_type::parse_error;
-                }
-
-                case 0x1A:
-                {
-                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
-                    return token_type::parse_error;
-                }
-
-                case 0x1B:
-                {
-                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
-                    return token_type::parse_error;
-                }
-
-                case 0x1C:
-                {
-                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
-                    return token_type::parse_error;
-                }
-
-                case 0x1D:
-                {
-                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
-                    return token_type::parse_error;
-                }
-
-                case 0x1E:
-                {
-                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
-                    return token_type::parse_error;
-                }
-
-                case 0x1F:
-                {
-                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
-                    return token_type::parse_error;
-                }
-
-                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
-                case 0x20:
-                case 0x21:
-                case 0x23:
-                case 0x24:
-                case 0x25:
-                case 0x26:
-                case 0x27:
-                case 0x28:
-                case 0x29:
-                case 0x2A:
-                case 0x2B:
-                case 0x2C:
-                case 0x2D:
-                case 0x2E:
-                case 0x2F:
-                case 0x30:
-                case 0x31:
-                case 0x32:
-                case 0x33:
-                case 0x34:
-                case 0x35:
-                case 0x36:
-                case 0x37:
-                case 0x38:
-                case 0x39:
-                case 0x3A:
-                case 0x3B:
-                case 0x3C:
-                case 0x3D:
-                case 0x3E:
-                case 0x3F:
-                case 0x40:
-                case 0x41:
-                case 0x42:
-                case 0x43:
-                case 0x44:
-                case 0x45:
-                case 0x46:
-                case 0x47:
-                case 0x48:
-                case 0x49:
-                case 0x4A:
-                case 0x4B:
-                case 0x4C:
-                case 0x4D:
-                case 0x4E:
-                case 0x4F:
-                case 0x50:
-                case 0x51:
-                case 0x52:
-                case 0x53:
-                case 0x54:
-                case 0x55:
-                case 0x56:
-                case 0x57:
-                case 0x58:
-                case 0x59:
-                case 0x5A:
-                case 0x5B:
-                case 0x5D:
-                case 0x5E:
-                case 0x5F:
-                case 0x60:
-                case 0x61:
-                case 0x62:
-                case 0x63:
-                case 0x64:
-                case 0x65:
-                case 0x66:
-                case 0x67:
-                case 0x68:
-                case 0x69:
-                case 0x6A:
-                case 0x6B:
-                case 0x6C:
-                case 0x6D:
-                case 0x6E:
-                case 0x6F:
-                case 0x70:
-                case 0x71:
-                case 0x72:
-                case 0x73:
-                case 0x74:
-                case 0x75:
-                case 0x76:
-                case 0x77:
-                case 0x78:
-                case 0x79:
-                case 0x7A:
-                case 0x7B:
-                case 0x7C:
-                case 0x7D:
-                case 0x7E:
-                case 0x7F:
-                {
-                    add(current);
-                    break;
-                }
-
-                // U+0080..U+07FF: bytes C2..DF 80..BF
-                case 0xC2:
-                case 0xC3:
-                case 0xC4:
-                case 0xC5:
-                case 0xC6:
-                case 0xC7:
-                case 0xC8:
-                case 0xC9:
-                case 0xCA:
-                case 0xCB:
-                case 0xCC:
-                case 0xCD:
-                case 0xCE:
-                case 0xCF:
-                case 0xD0:
-                case 0xD1:
-                case 0xD2:
-                case 0xD3:
-                case 0xD4:
-                case 0xD5:
-                case 0xD6:
-                case 0xD7:
-                case 0xD8:
-                case 0xD9:
-                case 0xDA:
-                case 0xDB:
-                case 0xDC:
-                case 0xDD:
-                case 0xDE:
-                case 0xDF:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
-                    {
-                        return token_type::parse_error;
-                    }
-                    break;
-                }
-
-                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
-                case 0xE0:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
-                    {
-                        return token_type::parse_error;
-                    }
-                    break;
-                }
-
-                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
-                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
-                case 0xE1:
-                case 0xE2:
-                case 0xE3:
-                case 0xE4:
-                case 0xE5:
-                case 0xE6:
-                case 0xE7:
-                case 0xE8:
-                case 0xE9:
-                case 0xEA:
-                case 0xEB:
-                case 0xEC:
-                case 0xEE:
-                case 0xEF:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
-                    {
-                        return token_type::parse_error;
-                    }
-                    break;
-                }
-
-                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
-                case 0xED:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
-                    {
-                        return token_type::parse_error;
-                    }
-                    break;
-                }
-
-                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
-                case 0xF0:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
-                    {
-                        return token_type::parse_error;
-                    }
-                    break;
-                }
-
-                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
-                case 0xF1:
-                case 0xF2:
-                case 0xF3:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
-                    {
-                        return token_type::parse_error;
-                    }
-                    break;
-                }
-
-                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
-                case 0xF4:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
-                    {
-                        return token_type::parse_error;
-                    }
-                    break;
-                }
-
-                // remaining bytes (80..C1 and F5..FF) are ill-formed
-                default:
-                {
-                    error_message = "invalid string: ill-formed UTF-8 byte";
-                    return token_type::parse_error;
-                }
-            }
-        }
-    }
-
-    /*!
-     * @brief scan a comment
-     * @return whether comment could be scanned successfully
-     */
-    bool scan_comment()
-    {
-        switch (get())
-        {
-            // single-line comments skip input until a newline or EOF is read
-            case '/':
-            {
-                while (true)
-                {
-                    switch (get())
-                    {
-                        case '\n':
-                        case '\r':
-                        case std::char_traits<char_type>::eof():
-                        case '\0':
-                            return true;
-
-                        default:
-                            break;
-                    }
-                }
-            }
-
-            // multi-line comments skip input until */ is read
-            case '*':
-            {
-                while (true)
-                {
-                    switch (get())
-                    {
-                        case std::char_traits<char_type>::eof():
-                        case '\0':
-                        {
-                            error_message = "invalid comment; missing closing '*/'";
-                            return false;
-                        }
-
-                        case '*':
-                        {
-                            switch (get())
-                            {
-                                case '/':
-                                    return true;
-
-                                default:
-                                {
-                                    unget();
-                                    continue;
-                                }
-                            }
-                        }
-
-                        default:
-                            continue;
-                    }
-                }
-            }
-
-            // unexpected character after reading '/'
-            default:
-            {
-                error_message = "invalid comment; expecting '/' or '*' after '/'";
-                return false;
-            }
-        }
-    }
-
-    JSON_HEDLEY_NON_NULL(2)
-    static void strtof(float& f, const char* str, char** endptr) noexcept
-    {
-        f = std::strtof(str, endptr);
-    }
-
-    JSON_HEDLEY_NON_NULL(2)
-    static void strtof(double& f, const char* str, char** endptr) noexcept
-    {
-        f = std::strtod(str, endptr);
-    }
-
-    JSON_HEDLEY_NON_NULL(2)
-    static void strtof(long double& f, const char* str, char** endptr) noexcept
-    {
-        f = std::strtold(str, endptr);
-    }
-
-    /*!
-    @brief scan a number literal
-
-    This function scans a string according to Sect. 6 of RFC 7159.
-
-    The function is realized with a deterministic finite state machine derived
-    from the grammar described in RFC 7159. Starting in state "init", the
-    input is read and used to determined the next state. Only state "done"
-    accepts the number. State "error" is a trap state to model errors. In the
-    table below, "anything" means any character but the ones listed before.
-
-    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
-    ---------|----------|----------|----------|---------|---------|----------|-----------
-    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
-    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
-    zero     | done     | done     | exponent | done    | done    | decimal1 | done
-    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
-    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
-    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
-    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
-    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
-    any2     | any2     | any2     | done     | done    | done    | done     | done
-
-    The state machine is realized with one label per state (prefixed with
-    "scan_number_") and `goto` statements between them. The state machine
-    contains cycles, but any cycle can be left when EOF is read. Therefore,
-    the function is guaranteed to terminate.
-
-    During scanning, the read bytes are stored in token_buffer. This string is
-    then converted to a signed integer, an unsigned integer, or a
-    floating-point number.
-
-    @return token_type::value_unsigned, token_type::value_integer, or
-            token_type::value_float if number could be successfully scanned,
-            token_type::parse_error otherwise
-
-    @note The scanner is independent of the current locale. Internally, the
-          locale's decimal point is used instead of `.` to work with the
-          locale-dependent converters.
-    */
-    token_type scan_number()  // lgtm [cpp/use-of-goto]
-    {
-        // reset token_buffer to store the number's bytes
-        reset();
-
-        // the type of the parsed number; initially set to unsigned; will be
-        // changed if minus sign, decimal point or exponent is read
-        token_type number_type = token_type::value_unsigned;
-
-        // state (init): we just found out we need to scan a number
-        switch (current)
-        {
-            case '-':
-            {
-                add(current);
-                goto scan_number_minus;
-            }
-
-            case '0':
-            {
-                add(current);
-                goto scan_number_zero;
-            }
-
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-            {
-                add(current);
-                goto scan_number_any1;
-            }
-
-            // all other characters are rejected outside scan_number()
-            default:            // LCOV_EXCL_LINE
-                JSON_ASSERT(false);  // LCOV_EXCL_LINE
-        }
-
-scan_number_minus:
-        // state: we just parsed a leading minus sign
-        number_type = token_type::value_integer;
-        switch (get())
-        {
-            case '0':
-            {
-                add(current);
-                goto scan_number_zero;
-            }
-
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-            {
-                add(current);
-                goto scan_number_any1;
-            }
-
-            default:
-            {
-                error_message = "invalid number; expected digit after '-'";
-                return token_type::parse_error;
-            }
-        }
-
-scan_number_zero:
-        // state: we just parse a zero (maybe with a leading minus sign)
-        switch (get())
-        {
-            case '.':
-            {
-                add(decimal_point_char);
-                goto scan_number_decimal1;
-            }
-
-            case 'e':
-            case 'E':
-            {
-                add(current);
-                goto scan_number_exponent;
-            }
-
-            default:
-                goto scan_number_done;
-        }
-
-scan_number_any1:
-        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
-        switch (get())
-        {
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-            {
-                add(current);
-                goto scan_number_any1;
-            }
-
-            case '.':
-            {
-                add(decimal_point_char);
-                goto scan_number_decimal1;
-            }
-
-            case 'e':
-            case 'E':
-            {
-                add(current);
-                goto scan_number_exponent;
-            }
-
-            default:
-                goto scan_number_done;
-        }
-
-scan_number_decimal1:
-        // state: we just parsed a decimal point
-        number_type = token_type::value_float;
-        switch (get())
-        {
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-            {
-                add(current);
-                goto scan_number_decimal2;
-            }
-
-            default:
-            {
-                error_message = "invalid number; expected digit after '.'";
-                return token_type::parse_error;
-            }
-        }
-
-scan_number_decimal2:
-        // we just parsed at least one number after a decimal point
-        switch (get())
-        {
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-            {
-                add(current);
-                goto scan_number_decimal2;
-            }
-
-            case 'e':
-            case 'E':
-            {
-                add(current);
-                goto scan_number_exponent;
-            }
-
-            default:
-                goto scan_number_done;
-        }
-
-scan_number_exponent:
-        // we just parsed an exponent
-        number_type = token_type::value_float;
-        switch (get())
-        {
-            case '+':
-            case '-':
-            {
-                add(current);
-                goto scan_number_sign;
-            }
-
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-            {
-                add(current);
-                goto scan_number_any2;
-            }
-
-            default:
-            {
-                error_message =
-                    "invalid number; expected '+', '-', or digit after exponent";
-                return token_type::parse_error;
-            }
-        }
-
-scan_number_sign:
-        // we just parsed an exponent sign
-        switch (get())
-        {
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-            {
-                add(current);
-                goto scan_number_any2;
-            }
-
-            default:
-            {
-                error_message = "invalid number; expected digit after exponent sign";
-                return token_type::parse_error;
-            }
-        }
-
-scan_number_any2:
-        // we just parsed a number after the exponent or exponent sign
-        switch (get())
-        {
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-            {
-                add(current);
-                goto scan_number_any2;
-            }
-
-            default:
-                goto scan_number_done;
-        }
-
-scan_number_done:
-        // unget the character after the number (we only read it to know that
-        // we are done scanning a number)
-        unget();
-
-        char* endptr = nullptr;
-        errno = 0;
-
-        // try to parse integers first and fall back to floats
-        if (number_type == token_type::value_unsigned)
-        {
-            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
-
-            // we checked the number format before
-            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
-
-            if (errno == 0)
-            {
-                value_unsigned = static_cast<number_unsigned_t>(x);
-                if (value_unsigned == x)
-                {
-                    return token_type::value_unsigned;
-                }
-            }
-        }
-        else if (number_type == token_type::value_integer)
-        {
-            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
-
-            // we checked the number format before
-            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
-
-            if (errno == 0)
-            {
-                value_integer = static_cast<number_integer_t>(x);
-                if (value_integer == x)
-                {
-                    return token_type::value_integer;
-                }
-            }
-        }
-
-        // this code is reached if we parse a floating-point number or if an
-        // integer conversion above failed
-        strtof(value_float, token_buffer.data(), &endptr);
-
-        // we checked the number format before
-        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
-
-        return token_type::value_float;
-    }
-
-    /*!
-    @param[in] literal_text  the literal text to expect
-    @param[in] length        the length of the passed literal text
-    @param[in] return_type   the token type to return on success
-    */
-    JSON_HEDLEY_NON_NULL(2)
-    token_type scan_literal(const char_type* literal_text, const std::size_t length,
-                            token_type return_type)
-    {
-        JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
-        for (std::size_t i = 1; i < length; ++i)
-        {
-            if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
-            {
-                error_message = "invalid literal";
-                return token_type::parse_error;
-            }
-        }
-        return return_type;
-    }
-
-    /////////////////////
-    // input management
-    /////////////////////
-
-    /// reset token_buffer; current character is beginning of token
-    void reset() noexcept
-    {
-        token_buffer.clear();
-        token_string.clear();
-        token_string.push_back(std::char_traits<char_type>::to_char_type(current));
-    }
-
-    /*
-    @brief get next character from the input
-
-    This function provides the interface to the used input adapter. It does
-    not throw in case the input reached EOF, but returns a
-    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters
-    for use in error messages.
-
-    @return character read from the input
-    */
-    char_int_type get()
-    {
-        ++position.chars_read_total;
-        ++position.chars_read_current_line;
-
-        if (next_unget)
-        {
-            // just reset the next_unget variable and work with current
-            next_unget = false;
-        }
-        else
-        {
-            current = ia.get_character();
-        }
-
-        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
-        {
-            token_string.push_back(std::char_traits<char_type>::to_char_type(current));
-        }
-
-        if (current == '\n')
-        {
-            ++position.lines_read;
-            position.chars_read_current_line = 0;
-        }
-
-        return current;
-    }
-
-    /*!
-    @brief unget current character (read it again on next get)
-
-    We implement unget by setting variable next_unget to true. The input is not
-    changed - we just simulate ungetting by modifying chars_read_total,
-    chars_read_current_line, and token_string. The next call to get() will
-    behave as if the unget character is read again.
-    */
-    void unget()
-    {
-        next_unget = true;
-
-        --position.chars_read_total;
-
-        // in case we "unget" a newline, we have to also decrement the lines_read
-        if (position.chars_read_current_line == 0)
-        {
-            if (position.lines_read > 0)
-            {
-                --position.lines_read;
-            }
-        }
-        else
-        {
-            --position.chars_read_current_line;
-        }
-
-        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
-        {
-            JSON_ASSERT(!token_string.empty());
-            token_string.pop_back();
-        }
-    }
-
-    /// add a character to token_buffer
-    void add(char_int_type c)
-    {
-        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
-    }
-
-  public:
-    /////////////////////
-    // value getters
-    /////////////////////
-
-    /// return integer value
-    constexpr number_integer_t get_number_integer() const noexcept
-    {
-        return value_integer;
-    }
-
-    /// return unsigned integer value
-    constexpr number_unsigned_t get_number_unsigned() const noexcept
-    {
-        return value_unsigned;
-    }
-
-    /// return floating-point value
-    constexpr number_float_t get_number_float() const noexcept
-    {
-        return value_float;
-    }
-
-    /// return current string value (implicitly resets the token; useful only once)
-    string_t& get_string()
-    {
-        return token_buffer;
-    }
-
-    /////////////////////
-    // diagnostics
-    /////////////////////
-
-    /// return position of last read token
-    constexpr position_t get_position() const noexcept
-    {
-        return position;
-    }
-
-    /// return the last read token (for errors only).  Will never contain EOF
-    /// (an arbitrary value that is not a valid char value, often -1), because
-    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
-    std::string get_token_string() const
-    {
-        // escape control characters
-        std::string result;
-        for (const auto c : token_string)
-        {
-            if (static_cast<unsigned char>(c) <= '\x1F')
-            {
-                // escape control characters
-                std::array<char, 9> cs{{}};
-                (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
-                result += cs.data();
-            }
-            else
-            {
-                // add character as is
-                result.push_back(static_cast<std::string::value_type>(c));
-            }
-        }
-
-        return result;
-    }
-
-    /// return syntax error message
-    JSON_HEDLEY_RETURNS_NON_NULL
-    constexpr const char* get_error_message() const noexcept
-    {
-        return error_message;
-    }
-
-    /////////////////////
-    // actual scanner
-    /////////////////////
-
-    /*!
-    @brief skip the UTF-8 byte order mark
-    @return true iff there is no BOM or the correct BOM has been skipped
-    */
-    bool skip_bom()
-    {
-        if (get() == 0xEF)
-        {
-            // check if we completely parse the BOM
-            return get() == 0xBB && get() == 0xBF;
-        }
-
-        // the first character is not the beginning of the BOM; unget it to
-        // process is later
-        unget();
-        return true;
-    }
-
-    void skip_whitespace()
-    {
-        do
-        {
-            get();
-        }
-        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
-    }
-
-    token_type scan()
-    {
-        // initially, skip the BOM
-        if (position.chars_read_total == 0 && !skip_bom())
-        {
-            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
-            return token_type::parse_error;
-        }
-
-        // read next character and ignore whitespace
-        skip_whitespace();
-
-        // ignore comments
-        while (ignore_comments && current == '/')
-        {
-            if (!scan_comment())
-            {
-                return token_type::parse_error;
-            }
-
-            // skip following whitespace
-            skip_whitespace();
-        }
-
-        switch (current)
-        {
-            // structural characters
-            case '[':
-                return token_type::begin_array;
-            case ']':
-                return token_type::end_array;
-            case '{':
-                return token_type::begin_object;
-            case '}':
-                return token_type::end_object;
-            case ':':
-                return token_type::name_separator;
-            case ',':
-                return token_type::value_separator;
-
-            // literals
-            case 't':
-            {
-                std::array<char_type, 4> true_literal = {{'t', 'r', 'u', 'e'}};
-                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
-            }
-            case 'f':
-            {
-                std::array<char_type, 5> false_literal = {{'f', 'a', 'l', 's', 'e'}};
-                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
-            }
-            case 'n':
-            {
-                std::array<char_type, 4> null_literal = {{'n', 'u', 'l', 'l'}};
-                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
-            }
-
-            // string
-            case '\"':
-                return scan_string();
-
-            // number
-            case '-':
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-                return scan_number();
-
-            // end of input (the null byte is needed when parsing from
-            // string literals)
-            case '\0':
-            case std::char_traits<char_type>::eof():
-                return token_type::end_of_input;
-
-            // error
-            default:
-                error_message = "invalid literal";
-                return token_type::parse_error;
-        }
-    }
-
-  private:
-    /// input adapter
-    InputAdapterType ia;
-
-    /// whether comments should be ignored (true) or signaled as errors (false)
-    const bool ignore_comments = false;
-
-    /// the current character
-    char_int_type current = std::char_traits<char_type>::eof();
-
-    /// whether the next get() call should just return current
-    bool next_unget = false;
-
-    /// the start position of the current token
-    position_t position {};
-
-    /// raw input token string (for error messages)
-    std::vector<char_type> token_string {};
-
-    /// buffer for variable-length tokens (numbers, strings)
-    string_t token_buffer {};
-
-    /// a description of occurred lexer errors
-    const char* error_message = "";
-
-    // number values
-    number_integer_t value_integer = 0;
-    number_unsigned_t value_unsigned = 0;
-    number_float_t value_float = 0;
-
-    /// the decimal point
-    const char_int_type decimal_point_char = '.';
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/is_sax.hpp>
-
-
-#include <cstdint> // size_t
-#include <utility> // declval
-#include <string> // string
-
-// #include <nlohmann/detail/meta/detected.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-template<typename T>
-using null_function_t = decltype(std::declval<T&>().null());
-
-template<typename T>
-using boolean_function_t =
-    decltype(std::declval<T&>().boolean(std::declval<bool>()));
-
-template<typename T, typename Integer>
-using number_integer_function_t =
-    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
-
-template<typename T, typename Unsigned>
-using number_unsigned_function_t =
-    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
-
-template<typename T, typename Float, typename String>
-using number_float_function_t = decltype(std::declval<T&>().number_float(
-                                    std::declval<Float>(), std::declval<const String&>()));
-
-template<typename T, typename String>
-using string_function_t =
-    decltype(std::declval<T&>().string(std::declval<String&>()));
-
-template<typename T, typename Binary>
-using binary_function_t =
-    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
-
-template<typename T>
-using start_object_function_t =
-    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
-
-template<typename T, typename String>
-using key_function_t =
-    decltype(std::declval<T&>().key(std::declval<String&>()));
-
-template<typename T>
-using end_object_function_t = decltype(std::declval<T&>().end_object());
-
-template<typename T>
-using start_array_function_t =
-    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
-
-template<typename T>
-using end_array_function_t = decltype(std::declval<T&>().end_array());
-
-template<typename T, typename Exception>
-using parse_error_function_t = decltype(std::declval<T&>().parse_error(
-        std::declval<std::size_t>(), std::declval<const std::string&>(),
-        std::declval<const Exception&>()));
-
-template<typename SAX, typename BasicJsonType>
-struct is_sax
-{
-  private:
-    static_assert(is_basic_json<BasicJsonType>::value,
-                  "BasicJsonType must be of type basic_json<...>");
-
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using string_t = typename BasicJsonType::string_t;
-    using binary_t = typename BasicJsonType::binary_t;
-    using exception_t = typename BasicJsonType::exception;
-
-  public:
-    static constexpr bool value =
-        is_detected_exact<bool, null_function_t, SAX>::value &&
-        is_detected_exact<bool, boolean_function_t, SAX>::value &&
-        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
-        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
-        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
-        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
-        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
-        is_detected_exact<bool, start_object_function_t, SAX>::value &&
-        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
-        is_detected_exact<bool, end_object_function_t, SAX>::value &&
-        is_detected_exact<bool, start_array_function_t, SAX>::value &&
-        is_detected_exact<bool, end_array_function_t, SAX>::value &&
-        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
-};
-
-template<typename SAX, typename BasicJsonType>
-struct is_sax_static_asserts
-{
-  private:
-    static_assert(is_basic_json<BasicJsonType>::value,
-                  "BasicJsonType must be of type basic_json<...>");
-
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using string_t = typename BasicJsonType::string_t;
-    using binary_t = typename BasicJsonType::binary_t;
-    using exception_t = typename BasicJsonType::exception;
-
-  public:
-    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
-                  "Missing/invalid function: bool null()");
-    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
-                  "Missing/invalid function: bool boolean(bool)");
-    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
-                  "Missing/invalid function: bool boolean(bool)");
-    static_assert(
-        is_detected_exact<bool, number_integer_function_t, SAX,
-        number_integer_t>::value,
-        "Missing/invalid function: bool number_integer(number_integer_t)");
-    static_assert(
-        is_detected_exact<bool, number_unsigned_function_t, SAX,
-        number_unsigned_t>::value,
-        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
-    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
-                  number_float_t, string_t>::value,
-                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
-    static_assert(
-        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
-        "Missing/invalid function: bool string(string_t&)");
-    static_assert(
-        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
-        "Missing/invalid function: bool binary(binary_t&)");
-    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
-                  "Missing/invalid function: bool start_object(std::size_t)");
-    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
-                  "Missing/invalid function: bool key(string_t&)");
-    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
-                  "Missing/invalid function: bool end_object()");
-    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
-                  "Missing/invalid function: bool start_array(std::size_t)");
-    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
-                  "Missing/invalid function: bool end_array()");
-    static_assert(
-        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
-        "Missing/invalid function: bool parse_error(std::size_t, const "
-        "std::string&, const exception&)");
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/value_t.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-
-/// how to treat CBOR tags
-enum class cbor_tag_handler_t
-{
-    error,  ///< throw a parse_error exception in case of a tag
-    ignore   ///< ignore tags
-};
-
-/*!
-@brief determine system byte order
-
-@return true if and only if system's byte order is little endian
-
-@note from https://stackoverflow.com/a/1001328/266378
-*/
-static inline bool little_endianess(int num = 1) noexcept
-{
-    return *reinterpret_cast<char*>(&num) == 1;
-}
-
-
-///////////////////
-// binary reader //
-///////////////////
-
-/*!
-@brief deserialization of CBOR, MessagePack, and UBJSON values
-*/
-template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
-class binary_reader
-{
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using string_t = typename BasicJsonType::string_t;
-    using binary_t = typename BasicJsonType::binary_t;
-    using json_sax_t = SAX;
-    using char_type = typename InputAdapterType::char_type;
-    using char_int_type = typename std::char_traits<char_type>::int_type;
-
-  public:
-    /*!
-    @brief create a binary reader
-
-    @param[in] adapter  input adapter to read from
-    */
-    explicit binary_reader(InputAdapterType&& adapter) : ia(std::move(adapter))
-    {
-        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
-    }
-
-    // make class move-only
-    binary_reader(const binary_reader&) = delete;
-    binary_reader(binary_reader&&) = default;
-    binary_reader& operator=(const binary_reader&) = delete;
-    binary_reader& operator=(binary_reader&&) = default;
-    ~binary_reader() = default;
-
-    /*!
-    @param[in] format  the binary format to parse
-    @param[in] sax_    a SAX event processor
-    @param[in] strict  whether to expect the input to be consumed completed
-    @param[in] tag_handler  how to treat CBOR tags
-
-    @return
-    */
-    JSON_HEDLEY_NON_NULL(3)
-    bool sax_parse(const input_format_t format,
-                   json_sax_t* sax_,
-                   const bool strict = true,
-                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-    {
-        sax = sax_;
-        bool result = false;
-
-        switch (format)
-        {
-            case input_format_t::bson:
-                result = parse_bson_internal();
-                break;
-
-            case input_format_t::cbor:
-                result = parse_cbor_internal(true, tag_handler);
-                break;
-
-            case input_format_t::msgpack:
-                result = parse_msgpack_internal();
-                break;
-
-            case input_format_t::ubjson:
-                result = parse_ubjson_internal();
-                break;
-
-            default:            // LCOV_EXCL_LINE
-                JSON_ASSERT(false);  // LCOV_EXCL_LINE
-        }
-
-        // strict mode: next byte must be EOF
-        if (result && strict)
-        {
-            if (format == input_format_t::ubjson)
-            {
-                get_ignore_noop();
-            }
-            else
-            {
-                get();
-            }
-
-            if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
-            {
-                return sax->parse_error(chars_read, get_token_string(),
-                                        parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
-            }
-        }
-
-        return result;
-    }
-
-  private:
-    //////////
-    // BSON //
-    //////////
-
-    /*!
-    @brief Reads in a BSON-object and passes it to the SAX-parser.
-    @return whether a valid BSON-value was passed to the SAX parser
-    */
-    bool parse_bson_internal()
-    {
-        std::int32_t document_size{};
-        get_number<std::int32_t, true>(input_format_t::bson, document_size);
-
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
-        {
-            return false;
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
-        {
-            return false;
-        }
-
-        return sax->end_object();
-    }
-
-    /*!
-    @brief Parses a C-style string from the BSON input.
-    @param[in, out] result  A reference to the string variable where the read
-                            string is to be stored.
-    @return `true` if the \x00-byte indicating the end of the string was
-             encountered before the EOF; false` indicates an unexpected EOF.
-    */
-    bool get_bson_cstr(string_t& result)
-    {
-        auto out = std::back_inserter(result);
-        while (true)
-        {
-            get();
-            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
-            {
-                return false;
-            }
-            if (current == 0x00)
-            {
-                return true;
-            }
-            *out++ = static_cast<typename string_t::value_type>(current);
-        }
-    }
-
-    /*!
-    @brief Parses a zero-terminated string of length @a len from the BSON
-           input.
-    @param[in] len  The length (including the zero-byte at the end) of the
-                    string to be read.
-    @param[in, out] result  A reference to the string variable where the read
-                            string is to be stored.
-    @tparam NumberType The type of the length @a len
-    @pre len >= 1
-    @return `true` if the string was successfully parsed
-    */
-    template<typename NumberType>
-    bool get_bson_string(const NumberType len, string_t& result)
-    {
-        if (JSON_HEDLEY_UNLIKELY(len < 1))
-        {
-            auto last_token = get_token_string();
-            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
-        }
-
-        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
-    }
-
-    /*!
-    @brief Parses a byte array input of length @a len from the BSON input.
-    @param[in] len  The length of the byte array to be read.
-    @param[in, out] result  A reference to the binary variable where the read
-                            array is to be stored.
-    @tparam NumberType The type of the length @a len
-    @pre len >= 0
-    @return `true` if the byte array was successfully parsed
-    */
-    template<typename NumberType>
-    bool get_bson_binary(const NumberType len, binary_t& result)
-    {
-        if (JSON_HEDLEY_UNLIKELY(len < 0))
-        {
-            auto last_token = get_token_string();
-            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary")));
-        }
-
-        // All BSON binary values have a subtype
-        std::uint8_t subtype{};
-        get_number<std::uint8_t>(input_format_t::bson, subtype);
-        result.set_subtype(subtype);
-
-        return get_binary(input_format_t::bson, len, result);
-    }
-
-    /*!
-    @brief Read a BSON document element of the given @a element_type.
-    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
-    @param[in] element_type_parse_position The position in the input stream,
-               where the `element_type` was read.
-    @warning Not all BSON element types are supported yet. An unsupported
-             @a element_type will give rise to a parse_error.114:
-             Unsupported BSON record type 0x...
-    @return whether a valid BSON-object/array was passed to the SAX parser
-    */
-    bool parse_bson_element_internal(const char_int_type element_type,
-                                     const std::size_t element_type_parse_position)
-    {
-        switch (element_type)
-        {
-            case 0x01: // double
-            {
-                double number{};
-                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
-            }
-
-            case 0x02: // string
-            {
-                std::int32_t len{};
-                string_t value;
-                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
-            }
-
-            case 0x03: // object
-            {
-                return parse_bson_internal();
-            }
-
-            case 0x04: // array
-            {
-                return parse_bson_array();
-            }
-
-            case 0x05: // binary
-            {
-                std::int32_t len{};
-                binary_t value;
-                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
-            }
-
-            case 0x08: // boolean
-            {
-                return sax->boolean(get() != 0);
-            }
-
-            case 0x0A: // null
-            {
-                return sax->null();
-            }
-
-            case 0x10: // int32
-            {
-                std::int32_t value{};
-                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
-            }
-
-            case 0x12: // int64
-            {
-                std::int64_t value{};
-                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
-            }
-
-            default: // anything else not supported (yet)
-            {
-                std::array<char, 3> cr{{}};
-                (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
-                return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
-            }
-        }
-    }
-
-    /*!
-    @brief Read a BSON element list (as specified in the BSON-spec)
-
-    The same binary layout is used for objects and arrays, hence it must be
-    indicated with the argument @a is_array which one is expected
-    (true --> array, false --> object).
-
-    @param[in] is_array Determines if the element list being read is to be
-                        treated as an object (@a is_array == false), or as an
-                        array (@a is_array == true).
-    @return whether a valid BSON-object/array was passed to the SAX parser
-    */
-    bool parse_bson_element_list(const bool is_array)
-    {
-        string_t key;
-
-        while (auto element_type = get())
-        {
-            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
-            {
-                return false;
-            }
-
-            const std::size_t element_type_parse_position = chars_read;
-            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
-            {
-                return false;
-            }
-
-            if (!is_array && !sax->key(key))
-            {
-                return false;
-            }
-
-            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
-            {
-                return false;
-            }
-
-            // get_bson_cstr only appends
-            key.clear();
-        }
-
-        return true;
-    }
-
-    /*!
-    @brief Reads an array from the BSON input and passes it to the SAX-parser.
-    @return whether a valid BSON-array was passed to the SAX parser
-    */
-    bool parse_bson_array()
-    {
-        std::int32_t document_size{};
-        get_number<std::int32_t, true>(input_format_t::bson, document_size);
-
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
-        {
-            return false;
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
-        {
-            return false;
-        }
-
-        return sax->end_array();
-    }
-
-    //////////
-    // CBOR //
-    //////////
-
-    /*!
-    @param[in] get_char  whether a new character should be retrieved from the
-                         input (true) or whether the last read character should
-                         be considered instead (false)
-    @param[in] tag_handler how CBOR tags should be treated
-
-    @return whether a valid CBOR value was passed to the SAX parser
-    */
-    bool parse_cbor_internal(const bool get_char,
-                             const cbor_tag_handler_t tag_handler)
-    {
-        switch (get_char ? get() : current)
-        {
-            // EOF
-            case std::char_traits<char_type>::eof():
-                return unexpect_eof(input_format_t::cbor, "value");
-
-            // Integer 0x00..0x17 (0..23)
-            case 0x00:
-            case 0x01:
-            case 0x02:
-            case 0x03:
-            case 0x04:
-            case 0x05:
-            case 0x06:
-            case 0x07:
-            case 0x08:
-            case 0x09:
-            case 0x0A:
-            case 0x0B:
-            case 0x0C:
-            case 0x0D:
-            case 0x0E:
-            case 0x0F:
-            case 0x10:
-            case 0x11:
-            case 0x12:
-            case 0x13:
-            case 0x14:
-            case 0x15:
-            case 0x16:
-            case 0x17:
-                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
-
-            case 0x18: // Unsigned integer (one-byte uint8_t follows)
-            {
-                std::uint8_t number{};
-                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
-            }
-
-            case 0x19: // Unsigned integer (two-byte uint16_t follows)
-            {
-                std::uint16_t number{};
-                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
-            }
-
-            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
-            {
-                std::uint32_t number{};
-                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
-            }
-
-            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
-            {
-                std::uint64_t number{};
-                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
-            }
-
-            // Negative integer -1-0x00..-1-0x17 (-1..-24)
-            case 0x20:
-            case 0x21:
-            case 0x22:
-            case 0x23:
-            case 0x24:
-            case 0x25:
-            case 0x26:
-            case 0x27:
-            case 0x28:
-            case 0x29:
-            case 0x2A:
-            case 0x2B:
-            case 0x2C:
-            case 0x2D:
-            case 0x2E:
-            case 0x2F:
-            case 0x30:
-            case 0x31:
-            case 0x32:
-            case 0x33:
-            case 0x34:
-            case 0x35:
-            case 0x36:
-            case 0x37:
-                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
-
-            case 0x38: // Negative integer (one-byte uint8_t follows)
-            {
-                std::uint8_t number{};
-                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
-            }
-
-            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
-            {
-                std::uint16_t number{};
-                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
-            }
-
-            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
-            {
-                std::uint32_t number{};
-                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
-            }
-
-            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
-            {
-                std::uint64_t number{};
-                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
-                        - static_cast<number_integer_t>(number));
-            }
-
-            // Binary data (0x00..0x17 bytes follow)
-            case 0x40:
-            case 0x41:
-            case 0x42:
-            case 0x43:
-            case 0x44:
-            case 0x45:
-            case 0x46:
-            case 0x47:
-            case 0x48:
-            case 0x49:
-            case 0x4A:
-            case 0x4B:
-            case 0x4C:
-            case 0x4D:
-            case 0x4E:
-            case 0x4F:
-            case 0x50:
-            case 0x51:
-            case 0x52:
-            case 0x53:
-            case 0x54:
-            case 0x55:
-            case 0x56:
-            case 0x57:
-            case 0x58: // Binary data (one-byte uint8_t for n follows)
-            case 0x59: // Binary data (two-byte uint16_t for n follow)
-            case 0x5A: // Binary data (four-byte uint32_t for n follow)
-            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
-            case 0x5F: // Binary data (indefinite length)
-            {
-                binary_t b;
-                return get_cbor_binary(b) && sax->binary(b);
-            }
-
-            // UTF-8 string (0x00..0x17 bytes follow)
-            case 0x60:
-            case 0x61:
-            case 0x62:
-            case 0x63:
-            case 0x64:
-            case 0x65:
-            case 0x66:
-            case 0x67:
-            case 0x68:
-            case 0x69:
-            case 0x6A:
-            case 0x6B:
-            case 0x6C:
-            case 0x6D:
-            case 0x6E:
-            case 0x6F:
-            case 0x70:
-            case 0x71:
-            case 0x72:
-            case 0x73:
-            case 0x74:
-            case 0x75:
-            case 0x76:
-            case 0x77:
-            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
-            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
-            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
-            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
-            case 0x7F: // UTF-8 string (indefinite length)
-            {
-                string_t s;
-                return get_cbor_string(s) && sax->string(s);
-            }
-
-            // array (0x00..0x17 data items follow)
-            case 0x80:
-            case 0x81:
-            case 0x82:
-            case 0x83:
-            case 0x84:
-            case 0x85:
-            case 0x86:
-            case 0x87:
-            case 0x88:
-            case 0x89:
-            case 0x8A:
-            case 0x8B:
-            case 0x8C:
-            case 0x8D:
-            case 0x8E:
-            case 0x8F:
-            case 0x90:
-            case 0x91:
-            case 0x92:
-            case 0x93:
-            case 0x94:
-            case 0x95:
-            case 0x96:
-            case 0x97:
-                return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
-
-            case 0x98: // array (one-byte uint8_t for n follows)
-            {
-                std::uint8_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
-            }
-
-            case 0x99: // array (two-byte uint16_t for n follow)
-            {
-                std::uint16_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
-            }
-
-            case 0x9A: // array (four-byte uint32_t for n follow)
-            {
-                std::uint32_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
-            }
-
-            case 0x9B: // array (eight-byte uint64_t for n follow)
-            {
-                std::uint64_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
-            }
-
-            case 0x9F: // array (indefinite length)
-                return get_cbor_array(std::size_t(-1), tag_handler);
-
-            // map (0x00..0x17 pairs of data items follow)
-            case 0xA0:
-            case 0xA1:
-            case 0xA2:
-            case 0xA3:
-            case 0xA4:
-            case 0xA5:
-            case 0xA6:
-            case 0xA7:
-            case 0xA8:
-            case 0xA9:
-            case 0xAA:
-            case 0xAB:
-            case 0xAC:
-            case 0xAD:
-            case 0xAE:
-            case 0xAF:
-            case 0xB0:
-            case 0xB1:
-            case 0xB2:
-            case 0xB3:
-            case 0xB4:
-            case 0xB5:
-            case 0xB6:
-            case 0xB7:
-                return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
-
-            case 0xB8: // map (one-byte uint8_t for n follows)
-            {
-                std::uint8_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
-            }
-
-            case 0xB9: // map (two-byte uint16_t for n follow)
-            {
-                std::uint16_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
-            }
-
-            case 0xBA: // map (four-byte uint32_t for n follow)
-            {
-                std::uint32_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
-            }
-
-            case 0xBB: // map (eight-byte uint64_t for n follow)
-            {
-                std::uint64_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
-            }
-
-            case 0xBF: // map (indefinite length)
-                return get_cbor_object(std::size_t(-1), tag_handler);
-
-            case 0xC6: // tagged item
-            case 0xC7:
-            case 0xC8:
-            case 0xC9:
-            case 0xCA:
-            case 0xCB:
-            case 0xCC:
-            case 0xCD:
-            case 0xCE:
-            case 0xCF:
-            case 0xD0:
-            case 0xD1:
-            case 0xD2:
-            case 0xD3:
-            case 0xD4:
-            case 0xD8: // tagged item (1 bytes follow)
-            case 0xD9: // tagged item (2 bytes follow)
-            case 0xDA: // tagged item (4 bytes follow)
-            case 0xDB: // tagged item (8 bytes follow)
-            {
-                switch (tag_handler)
-                {
-                    case cbor_tag_handler_t::error:
-                    {
-                        auto last_token = get_token_string();
-                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
-                    }
-
-                    case cbor_tag_handler_t::ignore:
-                    {
-                        switch (current)
-                        {
-                            case 0xD8:
-                            {
-                                std::uint8_t len{};
-                                get_number(input_format_t::cbor, len);
-                                break;
-                            }
-                            case 0xD9:
-                            {
-                                std::uint16_t len{};
-                                get_number(input_format_t::cbor, len);
-                                break;
-                            }
-                            case 0xDA:
-                            {
-                                std::uint32_t len{};
-                                get_number(input_format_t::cbor, len);
-                                break;
-                            }
-                            case 0xDB:
-                            {
-                                std::uint64_t len{};
-                                get_number(input_format_t::cbor, len);
-                                break;
-                            }
-                            default:
-                                break;
-                        }
-                        return parse_cbor_internal(true, tag_handler);
-                    }
-
-                    default:            // LCOV_EXCL_LINE
-                        JSON_ASSERT(false);  // LCOV_EXCL_LINE
-                }
-            }
-
-            case 0xF4: // false
-                return sax->boolean(false);
-
-            case 0xF5: // true
-                return sax->boolean(true);
-
-            case 0xF6: // null
-                return sax->null();
-
-            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
-            {
-                const auto byte1_raw = get();
-                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
-                {
-                    return false;
-                }
-                const auto byte2_raw = get();
-                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
-                {
-                    return false;
-                }
-
-                const auto byte1 = static_cast<unsigned char>(byte1_raw);
-                const auto byte2 = static_cast<unsigned char>(byte2_raw);
-
-                // code from RFC 7049, Appendix D, Figure 3:
-                // As half-precision floating-point numbers were only added
-                // to IEEE 754 in 2008, today's programming platforms often
-                // still only have limited support for them. It is very
-                // easy to include at least decoding support for them even
-                // without such support. An example of a small decoder for
-                // half-precision floating-point numbers in the C language
-                // is shown in Fig. 3.
-                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
-                const double val = [&half]
-                {
-                    const int exp = (half >> 10u) & 0x1Fu;
-                    const unsigned int mant = half & 0x3FFu;
-                    JSON_ASSERT(0 <= exp&& exp <= 32);
-                    JSON_ASSERT(mant <= 1024);
-                    switch (exp)
-                    {
-                        case 0:
-                            return std::ldexp(mant, -24);
-                        case 31:
-                            return (mant == 0)
-                            ? std::numeric_limits<double>::infinity()
-                            : std::numeric_limits<double>::quiet_NaN();
-                        default:
-                            return std::ldexp(mant + 1024, exp - 25);
-                    }
-                }();
-                return sax->number_float((half & 0x8000u) != 0
-                                         ? static_cast<number_float_t>(-val)
-                                         : static_cast<number_float_t>(val), "");
-            }
-
-            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
-            {
-                float number{};
-                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
-            }
-
-            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
-            {
-                double number{};
-                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
-            }
-
-            default: // anything else (0xFF is handled inside the other types)
-            {
-                auto last_token = get_token_string();
-                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
-            }
-        }
-    }
-
-    /*!
-    @brief reads a CBOR string
-
-    This function first reads starting bytes to determine the expected
-    string length and then copies this number of bytes into a string.
-    Additionally, CBOR's strings with indefinite lengths are supported.
-
-    @param[out] result  created string
-
-    @return whether string creation completed
-    */
-    bool get_cbor_string(string_t& result)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
-        {
-            return false;
-        }
-
-        switch (current)
-        {
-            // UTF-8 string (0x00..0x17 bytes follow)
-            case 0x60:
-            case 0x61:
-            case 0x62:
-            case 0x63:
-            case 0x64:
-            case 0x65:
-            case 0x66:
-            case 0x67:
-            case 0x68:
-            case 0x69:
-            case 0x6A:
-            case 0x6B:
-            case 0x6C:
-            case 0x6D:
-            case 0x6E:
-            case 0x6F:
-            case 0x70:
-            case 0x71:
-            case 0x72:
-            case 0x73:
-            case 0x74:
-            case 0x75:
-            case 0x76:
-            case 0x77:
-            {
-                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
-            }
-
-            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
-            {
-                std::uint8_t len{};
-                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
-            }
-
-            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
-            {
-                std::uint16_t len{};
-                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
-            }
-
-            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
-            {
-                std::uint32_t len{};
-                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
-            }
-
-            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
-            {
-                std::uint64_t len{};
-                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
-            }
-
-            case 0x7F: // UTF-8 string (indefinite length)
-            {
-                while (get() != 0xFF)
-                {
-                    string_t chunk;
-                    if (!get_cbor_string(chunk))
-                    {
-                        return false;
-                    }
-                    result.append(chunk);
-                }
-                return true;
-            }
-
-            default:
-            {
-                auto last_token = get_token_string();
-                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string")));
-            }
-        }
-    }
-
-    /*!
-    @brief reads a CBOR byte array
-
-    This function first reads starting bytes to determine the expected
-    byte array length and then copies this number of bytes into the byte array.
-    Additionally, CBOR's byte arrays with indefinite lengths are supported.
-
-    @param[out] result  created byte array
-
-    @return whether byte array creation completed
-    */
-    bool get_cbor_binary(binary_t& result)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
-        {
-            return false;
-        }
-
-        switch (current)
-        {
-            // Binary data (0x00..0x17 bytes follow)
-            case 0x40:
-            case 0x41:
-            case 0x42:
-            case 0x43:
-            case 0x44:
-            case 0x45:
-            case 0x46:
-            case 0x47:
-            case 0x48:
-            case 0x49:
-            case 0x4A:
-            case 0x4B:
-            case 0x4C:
-            case 0x4D:
-            case 0x4E:
-            case 0x4F:
-            case 0x50:
-            case 0x51:
-            case 0x52:
-            case 0x53:
-            case 0x54:
-            case 0x55:
-            case 0x56:
-            case 0x57:
-            {
-                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
-            }
-
-            case 0x58: // Binary data (one-byte uint8_t for n follows)
-            {
-                std::uint8_t len{};
-                return get_number(input_format_t::cbor, len) &&
-                       get_binary(input_format_t::cbor, len, result);
-            }
-
-            case 0x59: // Binary data (two-byte uint16_t for n follow)
-            {
-                std::uint16_t len{};
-                return get_number(input_format_t::cbor, len) &&
-                       get_binary(input_format_t::cbor, len, result);
-            }
-
-            case 0x5A: // Binary data (four-byte uint32_t for n follow)
-            {
-                std::uint32_t len{};
-                return get_number(input_format_t::cbor, len) &&
-                       get_binary(input_format_t::cbor, len, result);
-            }
-
-            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
-            {
-                std::uint64_t len{};
-                return get_number(input_format_t::cbor, len) &&
-                       get_binary(input_format_t::cbor, len, result);
-            }
-
-            case 0x5F: // Binary data (indefinite length)
-            {
-                while (get() != 0xFF)
-                {
-                    binary_t chunk;
-                    if (!get_cbor_binary(chunk))
-                    {
-                        return false;
-                    }
-                    result.insert(result.end(), chunk.begin(), chunk.end());
-                }
-                return true;
-            }
-
-            default:
-            {
-                auto last_token = get_token_string();
-                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary")));
-            }
-        }
-    }
-
-    /*!
-    @param[in] len  the length of the array or std::size_t(-1) for an
-                    array of indefinite size
-    @param[in] tag_handler how CBOR tags should be treated
-    @return whether array creation completed
-    */
-    bool get_cbor_array(const std::size_t len,
-                        const cbor_tag_handler_t tag_handler)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
-        {
-            return false;
-        }
-
-        if (len != std::size_t(-1))
-        {
-            for (std::size_t i = 0; i < len; ++i)
-            {
-                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
-                {
-                    return false;
-                }
-            }
-        }
-        else
-        {
-            while (get() != 0xFF)
-            {
-                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
-                {
-                    return false;
-                }
-            }
-        }
-
-        return sax->end_array();
-    }
-
-    /*!
-    @param[in] len  the length of the object or std::size_t(-1) for an
-                    object of indefinite size
-    @param[in] tag_handler how CBOR tags should be treated
-    @return whether object creation completed
-    */
-    bool get_cbor_object(const std::size_t len,
-                         const cbor_tag_handler_t tag_handler)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
-        {
-            return false;
-        }
-
-        string_t key;
-        if (len != std::size_t(-1))
-        {
-            for (std::size_t i = 0; i < len; ++i)
-            {
-                get();
-                if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
-                {
-                    return false;
-                }
-
-                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
-                {
-                    return false;
-                }
-                key.clear();
-            }
-        }
-        else
-        {
-            while (get() != 0xFF)
-            {
-                if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
-                {
-                    return false;
-                }
-
-                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
-                {
-                    return false;
-                }
-                key.clear();
-            }
-        }
-
-        return sax->end_object();
-    }
-
-    /////////////
-    // MsgPack //
-    /////////////
-
-    /*!
-    @return whether a valid MessagePack value was passed to the SAX parser
-    */
-    bool parse_msgpack_internal()
-    {
-        switch (get())
-        {
-            // EOF
-            case std::char_traits<char_type>::eof():
-                return unexpect_eof(input_format_t::msgpack, "value");
-
-            // positive fixint
-            case 0x00:
-            case 0x01:
-            case 0x02:
-            case 0x03:
-            case 0x04:
-            case 0x05:
-            case 0x06:
-            case 0x07:
-            case 0x08:
-            case 0x09:
-            case 0x0A:
-            case 0x0B:
-            case 0x0C:
-            case 0x0D:
-            case 0x0E:
-            case 0x0F:
-            case 0x10:
-            case 0x11:
-            case 0x12:
-            case 0x13:
-            case 0x14:
-            case 0x15:
-            case 0x16:
-            case 0x17:
-            case 0x18:
-            case 0x19:
-            case 0x1A:
-            case 0x1B:
-            case 0x1C:
-            case 0x1D:
-            case 0x1E:
-            case 0x1F:
-            case 0x20:
-            case 0x21:
-            case 0x22:
-            case 0x23:
-            case 0x24:
-            case 0x25:
-            case 0x26:
-            case 0x27:
-            case 0x28:
-            case 0x29:
-            case 0x2A:
-            case 0x2B:
-            case 0x2C:
-            case 0x2D:
-            case 0x2E:
-            case 0x2F:
-            case 0x30:
-            case 0x31:
-            case 0x32:
-            case 0x33:
-            case 0x34:
-            case 0x35:
-            case 0x36:
-            case 0x37:
-            case 0x38:
-            case 0x39:
-            case 0x3A:
-            case 0x3B:
-            case 0x3C:
-            case 0x3D:
-            case 0x3E:
-            case 0x3F:
-            case 0x40:
-            case 0x41:
-            case 0x42:
-            case 0x43:
-            case 0x44:
-            case 0x45:
-            case 0x46:
-            case 0x47:
-            case 0x48:
-            case 0x49:
-            case 0x4A:
-            case 0x4B:
-            case 0x4C:
-            case 0x4D:
-            case 0x4E:
-            case 0x4F:
-            case 0x50:
-            case 0x51:
-            case 0x52:
-            case 0x53:
-            case 0x54:
-            case 0x55:
-            case 0x56:
-            case 0x57:
-            case 0x58:
-            case 0x59:
-            case 0x5A:
-            case 0x5B:
-            case 0x5C:
-            case 0x5D:
-            case 0x5E:
-            case 0x5F:
-            case 0x60:
-            case 0x61:
-            case 0x62:
-            case 0x63:
-            case 0x64:
-            case 0x65:
-            case 0x66:
-            case 0x67:
-            case 0x68:
-            case 0x69:
-            case 0x6A:
-            case 0x6B:
-            case 0x6C:
-            case 0x6D:
-            case 0x6E:
-            case 0x6F:
-            case 0x70:
-            case 0x71:
-            case 0x72:
-            case 0x73:
-            case 0x74:
-            case 0x75:
-            case 0x76:
-            case 0x77:
-            case 0x78:
-            case 0x79:
-            case 0x7A:
-            case 0x7B:
-            case 0x7C:
-            case 0x7D:
-            case 0x7E:
-            case 0x7F:
-                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
-
-            // fixmap
-            case 0x80:
-            case 0x81:
-            case 0x82:
-            case 0x83:
-            case 0x84:
-            case 0x85:
-            case 0x86:
-            case 0x87:
-            case 0x88:
-            case 0x89:
-            case 0x8A:
-            case 0x8B:
-            case 0x8C:
-            case 0x8D:
-            case 0x8E:
-            case 0x8F:
-                return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
-
-            // fixarray
-            case 0x90:
-            case 0x91:
-            case 0x92:
-            case 0x93:
-            case 0x94:
-            case 0x95:
-            case 0x96:
-            case 0x97:
-            case 0x98:
-            case 0x99:
-            case 0x9A:
-            case 0x9B:
-            case 0x9C:
-            case 0x9D:
-            case 0x9E:
-            case 0x9F:
-                return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
-
-            // fixstr
-            case 0xA0:
-            case 0xA1:
-            case 0xA2:
-            case 0xA3:
-            case 0xA4:
-            case 0xA5:
-            case 0xA6:
-            case 0xA7:
-            case 0xA8:
-            case 0xA9:
-            case 0xAA:
-            case 0xAB:
-            case 0xAC:
-            case 0xAD:
-            case 0xAE:
-            case 0xAF:
-            case 0xB0:
-            case 0xB1:
-            case 0xB2:
-            case 0xB3:
-            case 0xB4:
-            case 0xB5:
-            case 0xB6:
-            case 0xB7:
-            case 0xB8:
-            case 0xB9:
-            case 0xBA:
-            case 0xBB:
-            case 0xBC:
-            case 0xBD:
-            case 0xBE:
-            case 0xBF:
-            case 0xD9: // str 8
-            case 0xDA: // str 16
-            case 0xDB: // str 32
-            {
-                string_t s;
-                return get_msgpack_string(s) && sax->string(s);
-            }
-
-            case 0xC0: // nil
-                return sax->null();
-
-            case 0xC2: // false
-                return sax->boolean(false);
-
-            case 0xC3: // true
-                return sax->boolean(true);
-
-            case 0xC4: // bin 8
-            case 0xC5: // bin 16
-            case 0xC6: // bin 32
-            case 0xC7: // ext 8
-            case 0xC8: // ext 16
-            case 0xC9: // ext 32
-            case 0xD4: // fixext 1
-            case 0xD5: // fixext 2
-            case 0xD6: // fixext 4
-            case 0xD7: // fixext 8
-            case 0xD8: // fixext 16
-            {
-                binary_t b;
-                return get_msgpack_binary(b) && sax->binary(b);
-            }
-
-            case 0xCA: // float 32
-            {
-                float number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
-            }
-
-            case 0xCB: // float 64
-            {
-                double number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
-            }
-
-            case 0xCC: // uint 8
-            {
-                std::uint8_t number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
-            }
-
-            case 0xCD: // uint 16
-            {
-                std::uint16_t number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
-            }
-
-            case 0xCE: // uint 32
-            {
-                std::uint32_t number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
-            }
-
-            case 0xCF: // uint 64
-            {
-                std::uint64_t number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
-            }
-
-            case 0xD0: // int 8
-            {
-                std::int8_t number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
-            }
-
-            case 0xD1: // int 16
-            {
-                std::int16_t number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
-            }
-
-            case 0xD2: // int 32
-            {
-                std::int32_t number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
-            }
-
-            case 0xD3: // int 64
-            {
-                std::int64_t number{};
-                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
-            }
-
-            case 0xDC: // array 16
-            {
-                std::uint16_t len{};
-                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
-            }
-
-            case 0xDD: // array 32
-            {
-                std::uint32_t len{};
-                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
-            }
-
-            case 0xDE: // map 16
-            {
-                std::uint16_t len{};
-                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
-            }
-
-            case 0xDF: // map 32
-            {
-                std::uint32_t len{};
-                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
-            }
-
-            // negative fixint
-            case 0xE0:
-            case 0xE1:
-            case 0xE2:
-            case 0xE3:
-            case 0xE4:
-            case 0xE5:
-            case 0xE6:
-            case 0xE7:
-            case 0xE8:
-            case 0xE9:
-            case 0xEA:
-            case 0xEB:
-            case 0xEC:
-            case 0xED:
-            case 0xEE:
-            case 0xEF:
-            case 0xF0:
-            case 0xF1:
-            case 0xF2:
-            case 0xF3:
-            case 0xF4:
-            case 0xF5:
-            case 0xF6:
-            case 0xF7:
-            case 0xF8:
-            case 0xF9:
-            case 0xFA:
-            case 0xFB:
-            case 0xFC:
-            case 0xFD:
-            case 0xFE:
-            case 0xFF:
-                return sax->number_integer(static_cast<std::int8_t>(current));
-
-            default: // anything else
-            {
-                auto last_token = get_token_string();
-                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value")));
-            }
-        }
-    }
-
-    /*!
-    @brief reads a MessagePack string
-
-    This function first reads starting bytes to determine the expected
-    string length and then copies this number of bytes into a string.
-
-    @param[out] result  created string
-
-    @return whether string creation completed
-    */
-    bool get_msgpack_string(string_t& result)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
-        {
-            return false;
-        }
-
-        switch (current)
-        {
-            // fixstr
-            case 0xA0:
-            case 0xA1:
-            case 0xA2:
-            case 0xA3:
-            case 0xA4:
-            case 0xA5:
-            case 0xA6:
-            case 0xA7:
-            case 0xA8:
-            case 0xA9:
-            case 0xAA:
-            case 0xAB:
-            case 0xAC:
-            case 0xAD:
-            case 0xAE:
-            case 0xAF:
-            case 0xB0:
-            case 0xB1:
-            case 0xB2:
-            case 0xB3:
-            case 0xB4:
-            case 0xB5:
-            case 0xB6:
-            case 0xB7:
-            case 0xB8:
-            case 0xB9:
-            case 0xBA:
-            case 0xBB:
-            case 0xBC:
-            case 0xBD:
-            case 0xBE:
-            case 0xBF:
-            {
-                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
-            }
-
-            case 0xD9: // str 8
-            {
-                std::uint8_t len{};
-                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
-            }
-
-            case 0xDA: // str 16
-            {
-                std::uint16_t len{};
-                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
-            }
-
-            case 0xDB: // str 32
-            {
-                std::uint32_t len{};
-                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
-            }
-
-            default:
-            {
-                auto last_token = get_token_string();
-                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string")));
-            }
-        }
-    }
-
-    /*!
-    @brief reads a MessagePack byte array
-
-    This function first reads starting bytes to determine the expected
-    byte array length and then copies this number of bytes into a byte array.
-
-    @param[out] result  created byte array
-
-    @return whether byte array creation completed
-    */
-    bool get_msgpack_binary(binary_t& result)
-    {
-        // helper function to set the subtype
-        auto assign_and_return_true = [&result](std::int8_t subtype)
-        {
-            result.set_subtype(static_cast<std::uint8_t>(subtype));
-            return true;
-        };
-
-        switch (current)
-        {
-            case 0xC4: // bin 8
-            {
-                std::uint8_t len{};
-                return get_number(input_format_t::msgpack, len) &&
-                       get_binary(input_format_t::msgpack, len, result);
-            }
-
-            case 0xC5: // bin 16
-            {
-                std::uint16_t len{};
-                return get_number(input_format_t::msgpack, len) &&
-                       get_binary(input_format_t::msgpack, len, result);
-            }
-
-            case 0xC6: // bin 32
-            {
-                std::uint32_t len{};
-                return get_number(input_format_t::msgpack, len) &&
-                       get_binary(input_format_t::msgpack, len, result);
-            }
-
-            case 0xC7: // ext 8
-            {
-                std::uint8_t len{};
-                std::int8_t subtype{};
-                return get_number(input_format_t::msgpack, len) &&
-                       get_number(input_format_t::msgpack, subtype) &&
-                       get_binary(input_format_t::msgpack, len, result) &&
-                       assign_and_return_true(subtype);
-            }
-
-            case 0xC8: // ext 16
-            {
-                std::uint16_t len{};
-                std::int8_t subtype{};
-                return get_number(input_format_t::msgpack, len) &&
-                       get_number(input_format_t::msgpack, subtype) &&
-                       get_binary(input_format_t::msgpack, len, result) &&
-                       assign_and_return_true(subtype);
-            }
-
-            case 0xC9: // ext 32
-            {
-                std::uint32_t len{};
-                std::int8_t subtype{};
-                return get_number(input_format_t::msgpack, len) &&
-                       get_number(input_format_t::msgpack, subtype) &&
-                       get_binary(input_format_t::msgpack, len, result) &&
-                       assign_and_return_true(subtype);
-            }
-
-            case 0xD4: // fixext 1
-            {
-                std::int8_t subtype{};
-                return get_number(input_format_t::msgpack, subtype) &&
-                       get_binary(input_format_t::msgpack, 1, result) &&
-                       assign_and_return_true(subtype);
-            }
-
-            case 0xD5: // fixext 2
-            {
-                std::int8_t subtype{};
-                return get_number(input_format_t::msgpack, subtype) &&
-                       get_binary(input_format_t::msgpack, 2, result) &&
-                       assign_and_return_true(subtype);
-            }
-
-            case 0xD6: // fixext 4
-            {
-                std::int8_t subtype{};
-                return get_number(input_format_t::msgpack, subtype) &&
-                       get_binary(input_format_t::msgpack, 4, result) &&
-                       assign_and_return_true(subtype);
-            }
-
-            case 0xD7: // fixext 8
-            {
-                std::int8_t subtype{};
-                return get_number(input_format_t::msgpack, subtype) &&
-                       get_binary(input_format_t::msgpack, 8, result) &&
-                       assign_and_return_true(subtype);
-            }
-
-            case 0xD8: // fixext 16
-            {
-                std::int8_t subtype{};
-                return get_number(input_format_t::msgpack, subtype) &&
-                       get_binary(input_format_t::msgpack, 16, result) &&
-                       assign_and_return_true(subtype);
-            }
-
-            default:           // LCOV_EXCL_LINE
-                return false;  // LCOV_EXCL_LINE
-        }
-    }
-
-    /*!
-    @param[in] len  the length of the array
-    @return whether array creation completed
-    */
-    bool get_msgpack_array(const std::size_t len)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
-        {
-            return false;
-        }
-
-        for (std::size_t i = 0; i < len; ++i)
-        {
-            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
-            {
-                return false;
-            }
-        }
-
-        return sax->end_array();
-    }
-
-    /*!
-    @param[in] len  the length of the object
-    @return whether object creation completed
-    */
-    bool get_msgpack_object(const std::size_t len)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
-        {
-            return false;
-        }
-
-        string_t key;
-        for (std::size_t i = 0; i < len; ++i)
-        {
-            get();
-            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
-            {
-                return false;
-            }
-
-            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
-            {
-                return false;
-            }
-            key.clear();
-        }
-
-        return sax->end_object();
-    }
-
-    ////////////
-    // UBJSON //
-    ////////////
-
-    /*!
-    @param[in] get_char  whether a new character should be retrieved from the
-                         input (true, default) or whether the last read
-                         character should be considered instead
-
-    @return whether a valid UBJSON value was passed to the SAX parser
-    */
-    bool parse_ubjson_internal(const bool get_char = true)
-    {
-        return get_ubjson_value(get_char ? get_ignore_noop() : current);
-    }
-
-    /*!
-    @brief reads a UBJSON string
-
-    This function is either called after reading the 'S' byte explicitly
-    indicating a string, or in case of an object key where the 'S' byte can be
-    left out.
-
-    @param[out] result   created string
-    @param[in] get_char  whether a new character should be retrieved from the
-                         input (true, default) or whether the last read
-                         character should be considered instead
-
-    @return whether string creation completed
-    */
-    bool get_ubjson_string(string_t& result, const bool get_char = true)
-    {
-        if (get_char)
-        {
-            get();  // TODO(niels): may we ignore N here?
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
-        {
-            return false;
-        }
-
-        switch (current)
-        {
-            case 'U':
-            {
-                std::uint8_t len{};
-                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
-            }
-
-            case 'i':
-            {
-                std::int8_t len{};
-                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
-            }
-
-            case 'I':
-            {
-                std::int16_t len{};
-                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
-            }
-
-            case 'l':
-            {
-                std::int32_t len{};
-                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
-            }
-
-            case 'L':
-            {
-                std::int64_t len{};
-                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
-            }
-
-            default:
-                auto last_token = get_token_string();
-                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string")));
-        }
-    }
-
-    /*!
-    @param[out] result  determined size
-    @return whether size determination completed
-    */
-    bool get_ubjson_size_value(std::size_t& result)
-    {
-        switch (get_ignore_noop())
-        {
-            case 'U':
-            {
-                std::uint8_t number{};
-                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
-                {
-                    return false;
-                }
-                result = static_cast<std::size_t>(number);
-                return true;
-            }
-
-            case 'i':
-            {
-                std::int8_t number{};
-                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
-                {
-                    return false;
-                }
-                result = static_cast<std::size_t>(number);
-                return true;
-            }
-
-            case 'I':
-            {
-                std::int16_t number{};
-                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
-                {
-                    return false;
-                }
-                result = static_cast<std::size_t>(number);
-                return true;
-            }
-
-            case 'l':
-            {
-                std::int32_t number{};
-                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
-                {
-                    return false;
-                }
-                result = static_cast<std::size_t>(number);
-                return true;
-            }
-
-            case 'L':
-            {
-                std::int64_t number{};
-                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
-                {
-                    return false;
-                }
-                result = static_cast<std::size_t>(number);
-                return true;
-            }
-
-            default:
-            {
-                auto last_token = get_token_string();
-                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size")));
-            }
-        }
-    }
-
-    /*!
-    @brief determine the type and size for a container
-
-    In the optimized UBJSON format, a type and a size can be provided to allow
-    for a more compact representation.
-
-    @param[out] result  pair of the size and the type
-
-    @return whether pair creation completed
-    */
-    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
-    {
-        result.first = string_t::npos; // size
-        result.second = 0; // type
-
-        get_ignore_noop();
-
-        if (current == '$')
-        {
-            result.second = get();  // must not ignore 'N', because 'N' maybe the type
-            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
-            {
-                return false;
-            }
-
-            get_ignore_noop();
-            if (JSON_HEDLEY_UNLIKELY(current != '#'))
-            {
-                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
-                {
-                    return false;
-                }
-                auto last_token = get_token_string();
-                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size")));
-            }
-
-            return get_ubjson_size_value(result.first);
-        }
-
-        if (current == '#')
-        {
-            return get_ubjson_size_value(result.first);
-        }
-
-        return true;
-    }
-
-    /*!
-    @param prefix  the previously read or set type prefix
-    @return whether value creation completed
-    */
-    bool get_ubjson_value(const char_int_type prefix)
-    {
-        switch (prefix)
-        {
-            case std::char_traits<char_type>::eof():  // EOF
-                return unexpect_eof(input_format_t::ubjson, "value");
-
-            case 'T':  // true
-                return sax->boolean(true);
-            case 'F':  // false
-                return sax->boolean(false);
-
-            case 'Z':  // null
-                return sax->null();
-
-            case 'U':
-            {
-                std::uint8_t number{};
-                return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
-            }
-
-            case 'i':
-            {
-                std::int8_t number{};
-                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
-            }
-
-            case 'I':
-            {
-                std::int16_t number{};
-                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
-            }
-
-            case 'l':
-            {
-                std::int32_t number{};
-                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
-            }
-
-            case 'L':
-            {
-                std::int64_t number{};
-                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
-            }
-
-            case 'd':
-            {
-                float number{};
-                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
-            }
-
-            case 'D':
-            {
-                double number{};
-                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
-            }
-
-            case 'H':
-            {
-                return get_ubjson_high_precision_number();
-            }
-
-            case 'C':  // char
-            {
-                get();
-                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
-                {
-                    return false;
-                }
-                if (JSON_HEDLEY_UNLIKELY(current > 127))
-                {
-                    auto last_token = get_token_string();
-                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
-                }
-                string_t s(1, static_cast<typename string_t::value_type>(current));
-                return sax->string(s);
-            }
-
-            case 'S':  // string
-            {
-                string_t s;
-                return get_ubjson_string(s) && sax->string(s);
-            }
-
-            case '[':  // array
-                return get_ubjson_array();
-
-            case '{':  // object
-                return get_ubjson_object();
-
-            default: // anything else
-            {
-                auto last_token = get_token_string();
-                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value")));
-            }
-        }
-    }
-
-    /*!
-    @return whether array creation completed
-    */
-    bool get_ubjson_array()
-    {
-        std::pair<std::size_t, char_int_type> size_and_type;
-        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
-        {
-            return false;
-        }
-
-        if (size_and_type.first != string_t::npos)
-        {
-            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
-            {
-                return false;
-            }
-
-            if (size_and_type.second != 0)
-            {
-                if (size_and_type.second != 'N')
-                {
-                    for (std::size_t i = 0; i < size_and_type.first; ++i)
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
-                        {
-                            return false;
-                        }
-                    }
-                }
-            }
-            else
-            {
-                for (std::size_t i = 0; i < size_and_type.first; ++i)
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
-                    {
-                        return false;
-                    }
-                }
-            }
-        }
-        else
-        {
-            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
-            {
-                return false;
-            }
-
-            while (current != ']')
-            {
-                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
-                {
-                    return false;
-                }
-                get_ignore_noop();
-            }
-        }
-
-        return sax->end_array();
-    }
-
-    /*!
-    @return whether object creation completed
-    */
-    bool get_ubjson_object()
-    {
-        std::pair<std::size_t, char_int_type> size_and_type;
-        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
-        {
-            return false;
-        }
-
-        string_t key;
-        if (size_and_type.first != string_t::npos)
-        {
-            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
-            {
-                return false;
-            }
-
-            if (size_and_type.second != 0)
-            {
-                for (std::size_t i = 0; i < size_and_type.first; ++i)
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
-                    {
-                        return false;
-                    }
-                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
-                    {
-                        return false;
-                    }
-                    key.clear();
-                }
-            }
-            else
-            {
-                for (std::size_t i = 0; i < size_and_type.first; ++i)
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
-                    {
-                        return false;
-                    }
-                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
-                    {
-                        return false;
-                    }
-                    key.clear();
-                }
-            }
-        }
-        else
-        {
-            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
-            {
-                return false;
-            }
-
-            while (current != '}')
-            {
-                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
-                {
-                    return false;
-                }
-                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
-                {
-                    return false;
-                }
-                get_ignore_noop();
-                key.clear();
-            }
-        }
-
-        return sax->end_object();
-    }
-
-    // Note, no reader for UBJSON binary types is implemented because they do
-    // not exist
-
-    bool get_ubjson_high_precision_number()
-    {
-        // get size of following number string
-        std::size_t size{};
-        auto res = get_ubjson_size_value(size);
-        if (JSON_HEDLEY_UNLIKELY(!res))
-        {
-            return res;
-        }
-
-        // get number string
-        std::vector<char> number_vector;
-        for (std::size_t i = 0; i < size; ++i)
-        {
-            get();
-            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
-            {
-                return false;
-            }
-            number_vector.push_back(static_cast<char>(current));
-        }
-
-        // parse number string
-        auto number_ia = detail::input_adapter(std::forward<decltype(number_vector)>(number_vector));
-        auto number_lexer = detail::lexer<BasicJsonType, decltype(number_ia)>(std::move(number_ia), false);
-        const auto result_number = number_lexer.scan();
-        const auto number_string = number_lexer.get_token_string();
-        const auto result_remainder = number_lexer.scan();
-
-        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
-
-        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
-        {
-            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
-        }
-
-        switch (result_number)
-        {
-            case token_type::value_integer:
-                return sax->number_integer(number_lexer.get_number_integer());
-            case token_type::value_unsigned:
-                return sax->number_unsigned(number_lexer.get_number_unsigned());
-            case token_type::value_float:
-                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
-            default:
-                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
-        }
-    }
-
-    ///////////////////////
-    // Utility functions //
-    ///////////////////////
-
-    /*!
-    @brief get next character from the input
-
-    This function provides the interface to the used input adapter. It does
-    not throw in case the input reached EOF, but returns a -'ve valued
-    `std::char_traits<char_type>::eof()` in that case.
-
-    @return character read from the input
-    */
-    char_int_type get()
-    {
-        ++chars_read;
-        return current = ia.get_character();
-    }
-
-    /*!
-    @return character read from the input after ignoring all 'N' entries
-    */
-    char_int_type get_ignore_noop()
-    {
-        do
-        {
-            get();
-        }
-        while (current == 'N');
-
-        return current;
-    }
-
-    /*
-    @brief read a number from the input
-
-    @tparam NumberType the type of the number
-    @param[in] format   the current format (for diagnostics)
-    @param[out] result  number of type @a NumberType
-
-    @return whether conversion completed
-
-    @note This function needs to respect the system's endianess, because
-          bytes in CBOR, MessagePack, and UBJSON are stored in network order
-          (big endian) and therefore need reordering on little endian systems.
-    */
-    template<typename NumberType, bool InputIsLittleEndian = false>
-    bool get_number(const input_format_t format, NumberType& result)
-    {
-        // step 1: read input into array with system's byte order
-        std::array<std::uint8_t, sizeof(NumberType)> vec;
-        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
-        {
-            get();
-            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
-            {
-                return false;
-            }
-
-            // reverse byte order prior to conversion if necessary
-            if (is_little_endian != InputIsLittleEndian)
-            {
-                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
-            }
-            else
-            {
-                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
-            }
-        }
-
-        // step 2: convert array into number of type T and return
-        std::memcpy(&result, vec.data(), sizeof(NumberType));
-        return true;
-    }
-
-    /*!
-    @brief create a string by reading characters from the input
-
-    @tparam NumberType the type of the number
-    @param[in] format the current format (for diagnostics)
-    @param[in] len number of characters to read
-    @param[out] result string created by reading @a len bytes
-
-    @return whether string creation completed
-
-    @note We can not reserve @a len bytes for the result, because @a len
-          may be too large. Usually, @ref unexpect_eof() detects the end of
-          the input before we run out of string memory.
-    */
-    template<typename NumberType>
-    bool get_string(const input_format_t format,
-                    const NumberType len,
-                    string_t& result)
-    {
-        bool success = true;
-        for (NumberType i = 0; i < len; i++)
-        {
-            get();
-            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
-            {
-                success = false;
-                break;
-            }
-            result.push_back(static_cast<typename string_t::value_type>(current));
-        };
-        return success;
-    }
-
-    /*!
-    @brief create a byte array by reading bytes from the input
-
-    @tparam NumberType the type of the number
-    @param[in] format the current format (for diagnostics)
-    @param[in] len number of bytes to read
-    @param[out] result byte array created by reading @a len bytes
-
-    @return whether byte array creation completed
-
-    @note We can not reserve @a len bytes for the result, because @a len
-          may be too large. Usually, @ref unexpect_eof() detects the end of
-          the input before we run out of memory.
-    */
-    template<typename NumberType>
-    bool get_binary(const input_format_t format,
-                    const NumberType len,
-                    binary_t& result)
-    {
-        bool success = true;
-        for (NumberType i = 0; i < len; i++)
-        {
-            get();
-            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
-            {
-                success = false;
-                break;
-            }
-            result.push_back(static_cast<std::uint8_t>(current));
-        }
-        return success;
-    }
-
-    /*!
-    @param[in] format   the current format (for diagnostics)
-    @param[in] context  further context information (for diagnostics)
-    @return whether the last read character is not EOF
-    */
-    JSON_HEDLEY_NON_NULL(3)
-    bool unexpect_eof(const input_format_t format, const char* context) const
-    {
-        if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
-        {
-            return sax->parse_error(chars_read, "<end of file>",
-                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
-        }
-        return true;
-    }
-
-    /*!
-    @return a string representation of the last read byte
-    */
-    std::string get_token_string() const
-    {
-        std::array<char, 3> cr{{}};
-        (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
-        return std::string{cr.data()};
-    }
-
-    /*!
-    @param[in] format   the current format
-    @param[in] detail   a detailed error message
-    @param[in] context  further context information
-    @return a message string to use in the parse_error exceptions
-    */
-    std::string exception_message(const input_format_t format,
-                                  const std::string& detail,
-                                  const std::string& context) const
-    {
-        std::string error_msg = "syntax error while parsing ";
-
-        switch (format)
-        {
-            case input_format_t::cbor:
-                error_msg += "CBOR";
-                break;
-
-            case input_format_t::msgpack:
-                error_msg += "MessagePack";
-                break;
-
-            case input_format_t::ubjson:
-                error_msg += "UBJSON";
-                break;
-
-            case input_format_t::bson:
-                error_msg += "BSON";
-                break;
-
-            default:            // LCOV_EXCL_LINE
-                JSON_ASSERT(false);  // LCOV_EXCL_LINE
-        }
-
-        return error_msg + " " + context + ": " + detail;
-    }
-
-  private:
-    /// input adapter
-    InputAdapterType ia;
-
-    /// the current character
-    char_int_type current = std::char_traits<char_type>::eof();
-
-    /// the number of characters read
-    std::size_t chars_read = 0;
-
-    /// whether we can assume little endianess
-    const bool is_little_endian = little_endianess();
-
-    /// the SAX parser
-    json_sax_t* sax = nullptr;
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-// #include <nlohmann/detail/input/lexer.hpp>
-
-// #include <nlohmann/detail/input/parser.hpp>
-
-
-#include <cmath> // isfinite
-#include <cstdint> // uint8_t
-#include <functional> // function
-#include <string> // string
-#include <utility> // move
-#include <vector> // vector
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-// #include <nlohmann/detail/input/json_sax.hpp>
-
-// #include <nlohmann/detail/input/lexer.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/is_sax.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-////////////
-// parser //
-////////////
-
-enum class parse_event_t : uint8_t
-{
-    /// the parser read `{` and started to process a JSON object
-    object_start,
-    /// the parser read `}` and finished processing a JSON object
-    object_end,
-    /// the parser read `[` and started to process a JSON array
-    array_start,
-    /// the parser read `]` and finished processing a JSON array
-    array_end,
-    /// the parser read a key of a value in an object
-    key,
-    /// the parser finished reading a JSON value
-    value
-};
-
-template<typename BasicJsonType>
-using parser_callback_t =
-    std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
-
-/*!
-@brief syntax analysis
-
-This class implements a recursive descent parser.
-*/
-template<typename BasicJsonType, typename InputAdapterType>
-class parser
-{
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using string_t = typename BasicJsonType::string_t;
-    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
-    using token_type = typename lexer_t::token_type;
-
-  public:
-    /// a parser reading from an input adapter
-    explicit parser(InputAdapterType&& adapter,
-                    const parser_callback_t<BasicJsonType> cb = nullptr,
-                    const bool allow_exceptions_ = true,
-                    const bool skip_comments = false)
-        : callback(cb)
-        , m_lexer(std::move(adapter), skip_comments)
-        , allow_exceptions(allow_exceptions_)
-    {
-        // read first token
-        get_token();
-    }
-
-    /*!
-    @brief public parser interface
-
-    @param[in] strict      whether to expect the last token to be EOF
-    @param[in,out] result  parsed JSON value
-
-    @throw parse_error.101 in case of an unexpected token
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-    */
-    void parse(const bool strict, BasicJsonType& result)
-    {
-        if (callback)
-        {
-            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
-            sax_parse_internal(&sdp);
-            result.assert_invariant();
-
-            // in strict mode, input must be completely read
-            if (strict && (get_token() != token_type::end_of_input))
-            {
-                sdp.parse_error(m_lexer.get_position(),
-                                m_lexer.get_token_string(),
-                                parse_error::create(101, m_lexer.get_position(),
-                                                    exception_message(token_type::end_of_input, "value")));
-            }
-
-            // in case of an error, return discarded value
-            if (sdp.is_errored())
-            {
-                result = value_t::discarded;
-                return;
-            }
-
-            // set top-level value to null if it was discarded by the callback
-            // function
-            if (result.is_discarded())
-            {
-                result = nullptr;
-            }
-        }
-        else
-        {
-            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
-            sax_parse_internal(&sdp);
-            result.assert_invariant();
-
-            // in strict mode, input must be completely read
-            if (strict && (get_token() != token_type::end_of_input))
-            {
-                sdp.parse_error(m_lexer.get_position(),
-                                m_lexer.get_token_string(),
-                                parse_error::create(101, m_lexer.get_position(),
-                                                    exception_message(token_type::end_of_input, "value")));
-            }
-
-            // in case of an error, return discarded value
-            if (sdp.is_errored())
-            {
-                result = value_t::discarded;
-                return;
-            }
-        }
-    }
-
-    /*!
-    @brief public accept interface
-
-    @param[in] strict  whether to expect the last token to be EOF
-    @return whether the input is a proper JSON text
-    */
-    bool accept(const bool strict = true)
-    {
-        json_sax_acceptor<BasicJsonType> sax_acceptor;
-        return sax_parse(&sax_acceptor, strict);
-    }
-
-    template<typename SAX>
-    JSON_HEDLEY_NON_NULL(2)
-    bool sax_parse(SAX* sax, const bool strict = true)
-    {
-        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
-        const bool result = sax_parse_internal(sax);
-
-        // strict mode: next byte must be EOF
-        if (result && strict && (get_token() != token_type::end_of_input))
-        {
-            return sax->parse_error(m_lexer.get_position(),
-                                    m_lexer.get_token_string(),
-                                    parse_error::create(101, m_lexer.get_position(),
-                                            exception_message(token_type::end_of_input, "value")));
-        }
-
-        return result;
-    }
-
-  private:
-    template<typename SAX>
-    JSON_HEDLEY_NON_NULL(2)
-    bool sax_parse_internal(SAX* sax)
-    {
-        // stack to remember the hierarchy of structured values we are parsing
-        // true = array; false = object
-        std::vector<bool> states;
-        // value to avoid a goto (see comment where set to true)
-        bool skip_to_state_evaluation = false;
-
-        while (true)
-        {
-            if (!skip_to_state_evaluation)
-            {
-                // invariant: get_token() was called before each iteration
-                switch (last_token)
-                {
-                    case token_type::begin_object:
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
-                        {
-                            return false;
-                        }
-
-                        // closing } -> we are done
-                        if (get_token() == token_type::end_object)
-                        {
-                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
-                            {
-                                return false;
-                            }
-                            break;
-                        }
-
-                        // parse key
-                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
-                        {
-                            return sax->parse_error(m_lexer.get_position(),
-                                                    m_lexer.get_token_string(),
-                                                    parse_error::create(101, m_lexer.get_position(),
-                                                            exception_message(token_type::value_string, "object key")));
-                        }
-                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
-                        {
-                            return false;
-                        }
-
-                        // parse separator (:)
-                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
-                        {
-                            return sax->parse_error(m_lexer.get_position(),
-                                                    m_lexer.get_token_string(),
-                                                    parse_error::create(101, m_lexer.get_position(),
-                                                            exception_message(token_type::name_separator, "object separator")));
-                        }
-
-                        // remember we are now inside an object
-                        states.push_back(false);
-
-                        // parse values
-                        get_token();
-                        continue;
-                    }
-
-                    case token_type::begin_array:
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
-                        {
-                            return false;
-                        }
-
-                        // closing ] -> we are done
-                        if (get_token() == token_type::end_array)
-                        {
-                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
-                            {
-                                return false;
-                            }
-                            break;
-                        }
-
-                        // remember we are now inside an array
-                        states.push_back(true);
-
-                        // parse values (no need to call get_token)
-                        continue;
-                    }
-
-                    case token_type::value_float:
-                    {
-                        const auto res = m_lexer.get_number_float();
-
-                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
-                        {
-                            return sax->parse_error(m_lexer.get_position(),
-                                                    m_lexer.get_token_string(),
-                                                    out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
-                        }
-
-                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
-                        {
-                            return false;
-                        }
-
-                        break;
-                    }
-
-                    case token_type::literal_false:
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
-                        {
-                            return false;
-                        }
-                        break;
-                    }
-
-                    case token_type::literal_null:
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
-                        {
-                            return false;
-                        }
-                        break;
-                    }
-
-                    case token_type::literal_true:
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
-                        {
-                            return false;
-                        }
-                        break;
-                    }
-
-                    case token_type::value_integer:
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
-                        {
-                            return false;
-                        }
-                        break;
-                    }
-
-                    case token_type::value_string:
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
-                        {
-                            return false;
-                        }
-                        break;
-                    }
-
-                    case token_type::value_unsigned:
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
-                        {
-                            return false;
-                        }
-                        break;
-                    }
-
-                    case token_type::parse_error:
-                    {
-                        // using "uninitialized" to avoid "expected" message
-                        return sax->parse_error(m_lexer.get_position(),
-                                                m_lexer.get_token_string(),
-                                                parse_error::create(101, m_lexer.get_position(),
-                                                        exception_message(token_type::uninitialized, "value")));
-                    }
-
-                    default: // the last token was unexpected
-                    {
-                        return sax->parse_error(m_lexer.get_position(),
-                                                m_lexer.get_token_string(),
-                                                parse_error::create(101, m_lexer.get_position(),
-                                                        exception_message(token_type::literal_or_value, "value")));
-                    }
-                }
-            }
-            else
-            {
-                skip_to_state_evaluation = false;
-            }
-
-            // we reached this line after we successfully parsed a value
-            if (states.empty())
-            {
-                // empty stack: we reached the end of the hierarchy: done
-                return true;
-            }
-
-            if (states.back())  // array
-            {
-                // comma -> next value
-                if (get_token() == token_type::value_separator)
-                {
-                    // parse a new value
-                    get_token();
-                    continue;
-                }
-
-                // closing ]
-                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
-                    {
-                        return false;
-                    }
-
-                    // We are done with this array. Before we can parse a
-                    // new value, we need to evaluate the new state first.
-                    // By setting skip_to_state_evaluation to false, we
-                    // are effectively jumping to the beginning of this if.
-                    JSON_ASSERT(!states.empty());
-                    states.pop_back();
-                    skip_to_state_evaluation = true;
-                    continue;
-                }
-
-                return sax->parse_error(m_lexer.get_position(),
-                                        m_lexer.get_token_string(),
-                                        parse_error::create(101, m_lexer.get_position(),
-                                                exception_message(token_type::end_array, "array")));
-            }
-            else  // object
-            {
-                // comma -> next value
-                if (get_token() == token_type::value_separator)
-                {
-                    // parse key
-                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
-                    {
-                        return sax->parse_error(m_lexer.get_position(),
-                                                m_lexer.get_token_string(),
-                                                parse_error::create(101, m_lexer.get_position(),
-                                                        exception_message(token_type::value_string, "object key")));
-                    }
-
-                    if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
-                    {
-                        return false;
-                    }
-
-                    // parse separator (:)
-                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
-                    {
-                        return sax->parse_error(m_lexer.get_position(),
-                                                m_lexer.get_token_string(),
-                                                parse_error::create(101, m_lexer.get_position(),
-                                                        exception_message(token_type::name_separator, "object separator")));
-                    }
-
-                    // parse values
-                    get_token();
-                    continue;
-                }
-
-                // closing }
-                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
-                {
-                    if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
-                    {
-                        return false;
-                    }
-
-                    // We are done with this object. Before we can parse a
-                    // new value, we need to evaluate the new state first.
-                    // By setting skip_to_state_evaluation to false, we
-                    // are effectively jumping to the beginning of this if.
-                    JSON_ASSERT(!states.empty());
-                    states.pop_back();
-                    skip_to_state_evaluation = true;
-                    continue;
-                }
-
-                return sax->parse_error(m_lexer.get_position(),
-                                        m_lexer.get_token_string(),
-                                        parse_error::create(101, m_lexer.get_position(),
-                                                exception_message(token_type::end_object, "object")));
-            }
-        }
-    }
-
-    /// get next token from lexer
-    token_type get_token()
-    {
-        return last_token = m_lexer.scan();
-    }
-
-    std::string exception_message(const token_type expected, const std::string& context)
-    {
-        std::string error_msg = "syntax error ";
-
-        if (!context.empty())
-        {
-            error_msg += "while parsing " + context + " ";
-        }
-
-        error_msg += "- ";
-
-        if (last_token == token_type::parse_error)
-        {
-            error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
-                         m_lexer.get_token_string() + "'";
-        }
-        else
-        {
-            error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
-        }
-
-        if (expected != token_type::uninitialized)
-        {
-            error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
-        }
-
-        return error_msg;
-    }
-
-  private:
-    /// callback function
-    const parser_callback_t<BasicJsonType> callback = nullptr;
-    /// the type of the last read token
-    token_type last_token = token_type::uninitialized;
-    /// the lexer
-    lexer_t m_lexer;
-    /// whether to throw exceptions in case of errors
-    const bool allow_exceptions = true;
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/iterators/internal_iterator.hpp>
-
-
-// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
-
-
-#include <cstddef> // ptrdiff_t
-#include <limits>  // numeric_limits
-
-namespace nlohmann
-{
-namespace detail
-{
-/*
-@brief an iterator for primitive JSON types
-
-This class models an iterator for primitive JSON types (boolean, number,
-string). It's only purpose is to allow the iterator/const_iterator classes
-to "iterate" over primitive values. Internally, the iterator is modeled by
-a `difference_type` variable. Value begin_value (`0`) models the begin,
-end_value (`1`) models past the end.
-*/
-class primitive_iterator_t
-{
-  private:
-    using difference_type = std::ptrdiff_t;
-    static constexpr difference_type begin_value = 0;
-    static constexpr difference_type end_value = begin_value + 1;
-
-    /// iterator as signed integer type
-    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
-
-  public:
-    constexpr difference_type get_value() const noexcept
-    {
-        return m_it;
-    }
-
-    /// set iterator to a defined beginning
-    void set_begin() noexcept
-    {
-        m_it = begin_value;
-    }
-
-    /// set iterator to a defined past the end
-    void set_end() noexcept
-    {
-        m_it = end_value;
-    }
-
-    /// return whether the iterator can be dereferenced
-    constexpr bool is_begin() const noexcept
-    {
-        return m_it == begin_value;
-    }
-
-    /// return whether the iterator is at end
-    constexpr bool is_end() const noexcept
-    {
-        return m_it == end_value;
-    }
-
-    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-    {
-        return lhs.m_it == rhs.m_it;
-    }
-
-    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-    {
-        return lhs.m_it < rhs.m_it;
-    }
-
-    primitive_iterator_t operator+(difference_type n) noexcept
-    {
-        auto result = *this;
-        result += n;
-        return result;
-    }
-
-    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-    {
-        return lhs.m_it - rhs.m_it;
-    }
-
-    primitive_iterator_t& operator++() noexcept
-    {
-        ++m_it;
-        return *this;
-    }
-
-    primitive_iterator_t const operator++(int) noexcept
-    {
-        auto result = *this;
-        ++m_it;
-        return result;
-    }
-
-    primitive_iterator_t& operator--() noexcept
-    {
-        --m_it;
-        return *this;
-    }
-
-    primitive_iterator_t const operator--(int) noexcept
-    {
-        auto result = *this;
-        --m_it;
-        return result;
-    }
-
-    primitive_iterator_t& operator+=(difference_type n) noexcept
-    {
-        m_it += n;
-        return *this;
-    }
-
-    primitive_iterator_t& operator-=(difference_type n) noexcept
-    {
-        m_it -= n;
-        return *this;
-    }
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-
-namespace nlohmann
-{
-namespace detail
-{
-/*!
-@brief an iterator value
-
-@note This structure could easily be a union, but MSVC currently does not allow
-unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
-*/
-template<typename BasicJsonType> struct internal_iterator
-{
-    /// iterator for JSON objects
-    typename BasicJsonType::object_t::iterator object_iterator {};
-    /// iterator for JSON arrays
-    typename BasicJsonType::array_t::iterator array_iterator {};
-    /// generic iterator for all other types
-    primitive_iterator_t primitive_iterator {};
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/iterators/iter_impl.hpp>
-
-
-#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
-#include <type_traits> // conditional, is_const, remove_const
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/iterators/internal_iterator.hpp>
-
-// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-// forward declare, to be able to friend it later on
-template<typename IteratorType> class iteration_proxy;
-template<typename IteratorType> class iteration_proxy_value;
-
-/*!
-@brief a template for a bidirectional iterator for the @ref basic_json class
-This class implements a both iterators (iterator and const_iterator) for the
-@ref basic_json class.
-@note An iterator is called *initialized* when a pointer to a JSON value has
-      been set (e.g., by a constructor or a copy assignment). If the iterator is
-      default-constructed, it is *uninitialized* and most methods are undefined.
-      **The library uses assertions to detect calls on uninitialized iterators.**
-@requirement The class satisfies the following concept requirements:
--
-[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
-  The iterator that can be moved can be moved in both directions (i.e.
-  incremented and decremented).
-@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
-       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
-*/
-template<typename BasicJsonType>
-class iter_impl
-{
-    /// allow basic_json to access private members
-    friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
-    friend BasicJsonType;
-    friend iteration_proxy<iter_impl>;
-    friend iteration_proxy_value<iter_impl>;
-
-    using object_t = typename BasicJsonType::object_t;
-    using array_t = typename BasicJsonType::array_t;
-    // make sure BasicJsonType is basic_json or const basic_json
-    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
-                  "iter_impl only accepts (const) basic_json");
-
-  public:
-
-    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
-    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
-    /// A user-defined iterator should provide publicly accessible typedefs named
-    /// iterator_category, value_type, difference_type, pointer, and reference.
-    /// Note that value_type is required to be non-const, even for constant iterators.
-    using iterator_category = std::bidirectional_iterator_tag;
-
-    /// the type of the values when the iterator is dereferenced
-    using value_type = typename BasicJsonType::value_type;
-    /// a type to represent differences between iterators
-    using difference_type = typename BasicJsonType::difference_type;
-    /// defines a pointer to the type iterated over (value_type)
-    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
-          typename BasicJsonType::const_pointer,
-          typename BasicJsonType::pointer>::type;
-    /// defines a reference to the type iterated over (value_type)
-    using reference =
-        typename std::conditional<std::is_const<BasicJsonType>::value,
-        typename BasicJsonType::const_reference,
-        typename BasicJsonType::reference>::type;
-
-    /// default constructor
-    iter_impl() = default;
-
-    /*!
-    @brief constructor for a given JSON instance
-    @param[in] object  pointer to a JSON object for this iterator
-    @pre object != nullptr
-    @post The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    explicit iter_impl(pointer object) noexcept : m_object(object)
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-            {
-                m_it.object_iterator = typename object_t::iterator();
-                break;
-            }
-
-            case value_t::array:
-            {
-                m_it.array_iterator = typename array_t::iterator();
-                break;
-            }
-
-            default:
-            {
-                m_it.primitive_iterator = primitive_iterator_t();
-                break;
-            }
-        }
-    }
-
-    /*!
-    @note The conventional copy constructor and copy assignment are implicitly
-          defined. Combined with the following converting constructor and
-          assignment, they support: (1) copy from iterator to iterator, (2)
-          copy from const iterator to const iterator, and (3) conversion from
-          iterator to const iterator. However conversion from const iterator
-          to iterator is not defined.
-    */
-
-    /*!
-    @brief const copy constructor
-    @param[in] other const iterator to copy from
-    @note This copy constructor had to be defined explicitly to circumvent a bug
-          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
-          information refer to: https://github.com/nlohmann/json/issues/1608
-    */
-    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
-        : m_object(other.m_object), m_it(other.m_it)
-    {}
-
-    /*!
-    @brief converting assignment
-    @param[in] other const iterator to copy from
-    @return const/non-const iterator
-    @note It is not checked whether @a other is initialized.
-    */
-    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
-    {
-        m_object = other.m_object;
-        m_it = other.m_it;
-        return *this;
-    }
-
-    /*!
-    @brief converting constructor
-    @param[in] other  non-const iterator to copy from
-    @note It is not checked whether @a other is initialized.
-    */
-    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
-        : m_object(other.m_object), m_it(other.m_it)
-    {}
-
-    /*!
-    @brief converting assignment
-    @param[in] other  non-const iterator to copy from
-    @return const/non-const iterator
-    @note It is not checked whether @a other is initialized.
-    */
-    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
-    {
-        m_object = other.m_object;
-        m_it = other.m_it;
-        return *this;
-    }
-
-  private:
-    /*!
-    @brief set the iterator to the first value
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    void set_begin() noexcept
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-            {
-                m_it.object_iterator = m_object->m_value.object->begin();
-                break;
-            }
-
-            case value_t::array:
-            {
-                m_it.array_iterator = m_object->m_value.array->begin();
-                break;
-            }
-
-            case value_t::null:
-            {
-                // set to end so begin()==end() is true: null is empty
-                m_it.primitive_iterator.set_end();
-                break;
-            }
-
-            default:
-            {
-                m_it.primitive_iterator.set_begin();
-                break;
-            }
-        }
-    }
-
-    /*!
-    @brief set the iterator past the last value
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    void set_end() noexcept
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-            {
-                m_it.object_iterator = m_object->m_value.object->end();
-                break;
-            }
-
-            case value_t::array:
-            {
-                m_it.array_iterator = m_object->m_value.array->end();
-                break;
-            }
-
-            default:
-            {
-                m_it.primitive_iterator.set_end();
-                break;
-            }
-        }
-    }
-
-  public:
-    /*!
-    @brief return a reference to the value pointed to by the iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    reference operator*() const
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-            {
-                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
-                return m_it.object_iterator->second;
-            }
-
-            case value_t::array:
-            {
-                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
-                return *m_it.array_iterator;
-            }
-
-            case value_t::null:
-                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-
-            default:
-            {
-                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
-                {
-                    return *m_object;
-                }
-
-                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-            }
-        }
-    }
-
-    /*!
-    @brief dereference the iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    pointer operator->() const
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-            {
-                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
-                return &(m_it.object_iterator->second);
-            }
-
-            case value_t::array:
-            {
-                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
-                return &*m_it.array_iterator;
-            }
-
-            default:
-            {
-                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
-                {
-                    return m_object;
-                }
-
-                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-            }
-        }
-    }
-
-    /*!
-    @brief post-increment (it++)
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    iter_impl const operator++(int)
-    {
-        auto result = *this;
-        ++(*this);
-        return result;
-    }
-
-    /*!
-    @brief pre-increment (++it)
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    iter_impl& operator++()
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-            {
-                std::advance(m_it.object_iterator, 1);
-                break;
-            }
-
-            case value_t::array:
-            {
-                std::advance(m_it.array_iterator, 1);
-                break;
-            }
-
-            default:
-            {
-                ++m_it.primitive_iterator;
-                break;
-            }
-        }
-
-        return *this;
-    }
-
-    /*!
-    @brief post-decrement (it--)
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    iter_impl const operator--(int)
-    {
-        auto result = *this;
-        --(*this);
-        return result;
-    }
-
-    /*!
-    @brief pre-decrement (--it)
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    iter_impl& operator--()
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-            {
-                std::advance(m_it.object_iterator, -1);
-                break;
-            }
-
-            case value_t::array:
-            {
-                std::advance(m_it.array_iterator, -1);
-                break;
-            }
-
-            default:
-            {
-                --m_it.primitive_iterator;
-                break;
-            }
-        }
-
-        return *this;
-    }
-
-    /*!
-    @brief  comparison: equal
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    bool operator==(const iter_impl& other) const
-    {
-        // if objects are not the same, the comparison is undefined
-        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
-        {
-            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
-        }
-
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-                return (m_it.object_iterator == other.m_it.object_iterator);
-
-            case value_t::array:
-                return (m_it.array_iterator == other.m_it.array_iterator);
-
-            default:
-                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
-        }
-    }
-
-    /*!
-    @brief  comparison: not equal
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    bool operator!=(const iter_impl& other) const
-    {
-        return !operator==(other);
-    }
-
-    /*!
-    @brief  comparison: smaller
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    bool operator<(const iter_impl& other) const
-    {
-        // if objects are not the same, the comparison is undefined
-        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
-        {
-            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
-        }
-
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
-
-            case value_t::array:
-                return (m_it.array_iterator < other.m_it.array_iterator);
-
-            default:
-                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
-        }
-    }
-
-    /*!
-    @brief  comparison: less than or equal
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    bool operator<=(const iter_impl& other) const
-    {
-        return !other.operator < (*this);
-    }
-
-    /*!
-    @brief  comparison: greater than
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    bool operator>(const iter_impl& other) const
-    {
-        return !operator<=(other);
-    }
-
-    /*!
-    @brief  comparison: greater than or equal
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    bool operator>=(const iter_impl& other) const
-    {
-        return !operator<(other);
-    }
-
-    /*!
-    @brief  add to iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    iter_impl& operator+=(difference_type i)
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
-
-            case value_t::array:
-            {
-                std::advance(m_it.array_iterator, i);
-                break;
-            }
-
-            default:
-            {
-                m_it.primitive_iterator += i;
-                break;
-            }
-        }
-
-        return *this;
-    }
-
-    /*!
-    @brief  subtract from iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    iter_impl& operator-=(difference_type i)
-    {
-        return operator+=(-i);
-    }
-
-    /*!
-    @brief  add to iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    iter_impl operator+(difference_type i) const
-    {
-        auto result = *this;
-        result += i;
-        return result;
-    }
-
-    /*!
-    @brief  addition of distance and iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    friend iter_impl operator+(difference_type i, const iter_impl& it)
-    {
-        auto result = it;
-        result += i;
-        return result;
-    }
-
-    /*!
-    @brief  subtract from iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    iter_impl operator-(difference_type i) const
-    {
-        auto result = *this;
-        result -= i;
-        return result;
-    }
-
-    /*!
-    @brief  return difference
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    difference_type operator-(const iter_impl& other) const
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
-
-            case value_t::array:
-                return m_it.array_iterator - other.m_it.array_iterator;
-
-            default:
-                return m_it.primitive_iterator - other.m_it.primitive_iterator;
-        }
-    }
-
-    /*!
-    @brief  access to successor
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    reference operator[](difference_type n) const
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        switch (m_object->m_type)
-        {
-            case value_t::object:
-                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
-
-            case value_t::array:
-                return *std::next(m_it.array_iterator, n);
-
-            case value_t::null:
-                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-
-            default:
-            {
-                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
-                {
-                    return *m_object;
-                }
-
-                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-            }
-        }
-    }
-
-    /*!
-    @brief  return the key of an object iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    const typename object_t::key_type& key() const
-    {
-        JSON_ASSERT(m_object != nullptr);
-
-        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
-        {
-            return m_it.object_iterator->first;
-        }
-
-        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
-    }
-
-    /*!
-    @brief  return the value of an iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-    reference value() const
-    {
-        return operator*();
-    }
-
-  private:
-    /// associated JSON instance
-    pointer m_object = nullptr;
-    /// the actual iterator of the associated instance
-    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
-
-// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
-
-
-#include <cstddef> // ptrdiff_t
-#include <iterator> // reverse_iterator
-#include <utility> // declval
-
-namespace nlohmann
-{
-namespace detail
-{
-//////////////////////
-// reverse_iterator //
-//////////////////////
-
-/*!
-@brief a template for a reverse iterator class
-
-@tparam Base the base iterator type to reverse. Valid types are @ref
-iterator (to create @ref reverse_iterator) and @ref const_iterator (to
-create @ref const_reverse_iterator).
-
-@requirement The class satisfies the following concept requirements:
--
-[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
-  The iterator that can be moved can be moved in both directions (i.e.
-  incremented and decremented).
-- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
-  It is possible to write to the pointed-to element (only if @a Base is
-  @ref iterator).
-
-@since version 1.0.0
-*/
-template<typename Base>
-class json_reverse_iterator : public std::reverse_iterator<Base>
-{
-  public:
-    using difference_type = std::ptrdiff_t;
-    /// shortcut to the reverse iterator adapter
-    using base_iterator = std::reverse_iterator<Base>;
-    /// the reference type for the pointed-to element
-    using reference = typename Base::reference;
-
-    /// create reverse iterator from iterator
-    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
-        : base_iterator(it) {}
-
-    /// create reverse iterator from base class
-    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
-
-    /// post-increment (it++)
-    json_reverse_iterator const operator++(int)
-    {
-        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
-    }
-
-    /// pre-increment (++it)
-    json_reverse_iterator& operator++()
-    {
-        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
-    }
-
-    /// post-decrement (it--)
-    json_reverse_iterator const operator--(int)
-    {
-        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
-    }
-
-    /// pre-decrement (--it)
-    json_reverse_iterator& operator--()
-    {
-        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
-    }
-
-    /// add to iterator
-    json_reverse_iterator& operator+=(difference_type i)
-    {
-        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
-    }
-
-    /// add to iterator
-    json_reverse_iterator operator+(difference_type i) const
-    {
-        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
-    }
-
-    /// subtract from iterator
-    json_reverse_iterator operator-(difference_type i) const
-    {
-        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
-    }
-
-    /// return difference
-    difference_type operator-(const json_reverse_iterator& other) const
-    {
-        return base_iterator(*this) - base_iterator(other);
-    }
-
-    /// access to successor
-    reference operator[](difference_type n) const
-    {
-        return *(this->operator+(n));
-    }
-
-    /// return the key of an object iterator
-    auto key() const -> decltype(std::declval<Base>().key())
-    {
-        auto it = --this->base();
-        return it.key();
-    }
-
-    /// return the value of an iterator
-    reference value() const
-    {
-        auto it = --this->base();
-        return it.operator * ();
-    }
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
-
-// #include <nlohmann/detail/json_pointer.hpp>
-
-
-#include <algorithm> // all_of
-#include <cctype> // isdigit
-#include <limits> // max
-#include <numeric> // accumulate
-#include <string> // string
-#include <utility> // move
-#include <vector> // vector
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-
-namespace nlohmann
-{
-template<typename BasicJsonType>
-class json_pointer
-{
-    // allow basic_json to access private members
-    NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    friend class basic_json;
-
-  public:
-    /*!
-    @brief create JSON pointer
-
-    Create a JSON pointer according to the syntax described in
-    [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).
-
-    @param[in] s  string representing the JSON pointer; if omitted, the empty
-                  string is assumed which references the whole JSON value
-
-    @throw parse_error.107 if the given JSON pointer @a s is nonempty and does
-                           not begin with a slash (`/`); see example below
-
-    @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s is
-    not followed by `0` (representing `~`) or `1` (representing `/`); see
-    example below
-
-    @liveexample{The example shows the construction several valid JSON pointers
-    as well as the exceptional behavior.,json_pointer}
-
-    @since version 2.0.0
-    */
-    explicit json_pointer(const std::string& s = "")
-        : reference_tokens(split(s))
-    {}
-
-    /*!
-    @brief return a string representation of the JSON pointer
-
-    @invariant For each JSON pointer `ptr`, it holds:
-    @code {.cpp}
-    ptr == json_pointer(ptr.to_string());
-    @endcode
-
-    @return a string representation of the JSON pointer
-
-    @liveexample{The example shows the result of `to_string`.,json_pointer__to_string}
-
-    @since version 2.0.0
-    */
-    std::string to_string() const
-    {
-        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
-                               std::string{},
-                               [](const std::string & a, const std::string & b)
-        {
-            return a + "/" + escape(b);
-        });
-    }
-
-    /// @copydoc to_string()
-    operator std::string() const
-    {
-        return to_string();
-    }
-
-    /*!
-    @brief append another JSON pointer at the end of this JSON pointer
-
-    @param[in] ptr  JSON pointer to append
-    @return JSON pointer with @a ptr appended
-
-    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
-
-    @complexity Linear in the length of @a ptr.
-
-    @sa @ref operator/=(std::string) to append a reference token
-    @sa @ref operator/=(std::size_t) to append an array index
-    @sa @ref operator/(const json_pointer&, const json_pointer&) for a binary operator
-
-    @since version 3.6.0
-    */
-    json_pointer& operator/=(const json_pointer& ptr)
-    {
-        reference_tokens.insert(reference_tokens.end(),
-                                ptr.reference_tokens.begin(),
-                                ptr.reference_tokens.end());
-        return *this;
-    }
-
-    /*!
-    @brief append an unescaped reference token at the end of this JSON pointer
-
-    @param[in] token  reference token to append
-    @return JSON pointer with @a token appended without escaping @a token
-
-    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
-
-    @complexity Amortized constant.
-
-    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
-    @sa @ref operator/=(std::size_t) to append an array index
-    @sa @ref operator/(const json_pointer&, std::size_t) for a binary operator
-
-    @since version 3.6.0
-    */
-    json_pointer& operator/=(std::string token)
-    {
-        push_back(std::move(token));
-        return *this;
-    }
-
-    /*!
-    @brief append an array index at the end of this JSON pointer
-
-    @param[in] array_idx  array index to append
-    @return JSON pointer with @a array_idx appended
-
-    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
-
-    @complexity Amortized constant.
-
-    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
-    @sa @ref operator/=(std::string) to append a reference token
-    @sa @ref operator/(const json_pointer&, std::string) for a binary operator
-
-    @since version 3.6.0
-    */
-    json_pointer& operator/=(std::size_t array_idx)
-    {
-        return *this /= std::to_string(array_idx);
-    }
-
-    /*!
-    @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
-
-    @param[in] lhs  JSON pointer
-    @param[in] rhs  JSON pointer
-    @return a new JSON pointer with @a rhs appended to @a lhs
-
-    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
-
-    @complexity Linear in the length of @a lhs and @a rhs.
-
-    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
-
-    @since version 3.6.0
-    */
-    friend json_pointer operator/(const json_pointer& lhs,
-                                  const json_pointer& rhs)
-    {
-        return json_pointer(lhs) /= rhs;
-    }
-
-    /*!
-    @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
-
-    @param[in] ptr  JSON pointer
-    @param[in] token  reference token
-    @return a new JSON pointer with unescaped @a token appended to @a ptr
-
-    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
-
-    @complexity Linear in the length of @a ptr.
-
-    @sa @ref operator/=(std::string) to append a reference token
-
-    @since version 3.6.0
-    */
-    friend json_pointer operator/(const json_pointer& ptr, std::string token)
-    {
-        return json_pointer(ptr) /= std::move(token);
-    }
-
-    /*!
-    @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
-
-    @param[in] ptr  JSON pointer
-    @param[in] array_idx  array index
-    @return a new JSON pointer with @a array_idx appended to @a ptr
-
-    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
-
-    @complexity Linear in the length of @a ptr.
-
-    @sa @ref operator/=(std::size_t) to append an array index
-
-    @since version 3.6.0
-    */
-    friend json_pointer operator/(const json_pointer& ptr, std::size_t array_idx)
-    {
-        return json_pointer(ptr) /= array_idx;
-    }
-
-    /*!
-    @brief returns the parent of this JSON pointer
-
-    @return parent of this JSON pointer; in case this JSON pointer is the root,
-            the root itself is returned
-
-    @complexity Linear in the length of the JSON pointer.
-
-    @liveexample{The example shows the result of `parent_pointer` for different
-    JSON Pointers.,json_pointer__parent_pointer}
-
-    @since version 3.6.0
-    */
-    json_pointer parent_pointer() const
-    {
-        if (empty())
-        {
-            return *this;
-        }
-
-        json_pointer res = *this;
-        res.pop_back();
-        return res;
-    }
-
-    /*!
-    @brief remove last reference token
-
-    @pre not `empty()`
-
-    @liveexample{The example shows the usage of `pop_back`.,json_pointer__pop_back}
-
-    @complexity Constant.
-
-    @throw out_of_range.405 if JSON pointer has no parent
-
-    @since version 3.6.0
-    */
-    void pop_back()
-    {
-        if (JSON_HEDLEY_UNLIKELY(empty()))
-        {
-            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
-        }
-
-        reference_tokens.pop_back();
-    }
-
-    /*!
-    @brief return last reference token
-
-    @pre not `empty()`
-    @return last reference token
-
-    @liveexample{The example shows the usage of `back`.,json_pointer__back}
-
-    @complexity Constant.
-
-    @throw out_of_range.405 if JSON pointer has no parent
-
-    @since version 3.6.0
-    */
-    const std::string& back() const
-    {
-        if (JSON_HEDLEY_UNLIKELY(empty()))
-        {
-            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
-        }
-
-        return reference_tokens.back();
-    }
-
-    /*!
-    @brief append an unescaped token at the end of the reference pointer
-
-    @param[in] token  token to add
-
-    @complexity Amortized constant.
-
-    @liveexample{The example shows the result of `push_back` for different
-    JSON Pointers.,json_pointer__push_back}
-
-    @since version 3.6.0
-    */
-    void push_back(const std::string& token)
-    {
-        reference_tokens.push_back(token);
-    }
-
-    /// @copydoc push_back(const std::string&)
-    void push_back(std::string&& token)
-    {
-        reference_tokens.push_back(std::move(token));
-    }
-
-    /*!
-    @brief return whether pointer points to the root document
-
-    @return true iff the JSON pointer points to the root document
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example shows the result of `empty` for different JSON
-    Pointers.,json_pointer__empty}
-
-    @since version 3.6.0
-    */
-    bool empty() const noexcept
-    {
-        return reference_tokens.empty();
-    }
-
-  private:
-    /*!
-    @param[in] s  reference token to be converted into an array index
-
-    @return integer representation of @a s
-
-    @throw parse_error.106  if an array index begins with '0'
-    @throw parse_error.109  if an array index begins not with a digit
-    @throw out_of_range.404 if string @a s could not be converted to an integer
-    @throw out_of_range.410 if an array index exceeds size_type
-    */
-    static typename BasicJsonType::size_type array_index(const std::string& s)
-    {
-        using size_type = typename BasicJsonType::size_type;
-
-        // error condition (cf. RFC 6901, Sect. 4)
-        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
-        {
-            JSON_THROW(detail::parse_error::create(106, 0,
-                                                   "array index '" + s +
-                                                   "' must not begin with '0'"));
-        }
-
-        // error condition (cf. RFC 6901, Sect. 4)
-        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
-        {
-            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number"));
-        }
-
-        std::size_t processed_chars = 0;
-        unsigned long long res = 0;
-        JSON_TRY
-        {
-            res = std::stoull(s, &processed_chars);
-        }
-        JSON_CATCH(std::out_of_range&)
-        {
-            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
-        }
-
-        // check if the string was completely read
-        if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
-        {
-            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
-        }
-
-        // only triggered on special platforms (like 32bit), see also
-        // https://github.com/nlohmann/json/pull/2203
-        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
-        {
-            JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type")); // LCOV_EXCL_LINE
-        }
-
-        return static_cast<size_type>(res);
-    }
-
-    json_pointer top() const
-    {
-        if (JSON_HEDLEY_UNLIKELY(empty()))
-        {
-            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
-        }
-
-        json_pointer result = *this;
-        result.reference_tokens = {reference_tokens[0]};
-        return result;
-    }
-
-    /*!
-    @brief create and return a reference to the pointed to value
-
-    @complexity Linear in the number of reference tokens.
-
-    @throw parse_error.109 if array index is not a number
-    @throw type_error.313 if value cannot be unflattened
-    */
-    BasicJsonType& get_and_create(BasicJsonType& j) const
-    {
-        auto result = &j;
-
-        // in case no reference tokens exist, return a reference to the JSON value
-        // j which will be overwritten by a primitive value
-        for (const auto& reference_token : reference_tokens)
-        {
-            switch (result->type())
-            {
-                case detail::value_t::null:
-                {
-                    if (reference_token == "0")
-                    {
-                        // start a new array if reference token is 0
-                        result = &result->operator[](0);
-                    }
-                    else
-                    {
-                        // start a new object otherwise
-                        result = &result->operator[](reference_token);
-                    }
-                    break;
-                }
-
-                case detail::value_t::object:
-                {
-                    // create an entry in the object
-                    result = &result->operator[](reference_token);
-                    break;
-                }
-
-                case detail::value_t::array:
-                {
-                    // create an entry in the array
-                    result = &result->operator[](array_index(reference_token));
-                    break;
-                }
-
-                /*
-                The following code is only reached if there exists a reference
-                token _and_ the current value is primitive. In this case, we have
-                an error situation, because primitive values may only occur as
-                single value; that is, with an empty list of reference tokens.
-                */
-                default:
-                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
-            }
-        }
-
-        return *result;
-    }
-
-    /*!
-    @brief return a reference to the pointed to value
-
-    @note This version does not throw if a value is not present, but tries to
-          create nested values instead. For instance, calling this function
-          with pointer `"/this/that"` on a null value is equivalent to calling
-          `operator[]("this").operator[]("that")` on that value, effectively
-          changing the null value to an object.
-
-    @param[in] ptr  a JSON value
-
-    @return reference to the JSON value pointed to by the JSON pointer
-
-    @complexity Linear in the length of the JSON pointer.
-
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-    */
-    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
-    {
-        for (const auto& reference_token : reference_tokens)
-        {
-            // convert null values to arrays or objects before continuing
-            if (ptr->is_null())
-            {
-                // check if reference token is a number
-                const bool nums =
-                    std::all_of(reference_token.begin(), reference_token.end(),
-                                [](const unsigned char x)
-                {
-                    return std::isdigit(x);
-                });
-
-                // change value to array for numbers or "-" or to object otherwise
-                *ptr = (nums || reference_token == "-")
-                       ? detail::value_t::array
-                       : detail::value_t::object;
-            }
-
-            switch (ptr->type())
-            {
-                case detail::value_t::object:
-                {
-                    // use unchecked object access
-                    ptr = &ptr->operator[](reference_token);
-                    break;
-                }
-
-                case detail::value_t::array:
-                {
-                    if (reference_token == "-")
-                    {
-                        // explicitly treat "-" as index beyond the end
-                        ptr = &ptr->operator[](ptr->m_value.array->size());
-                    }
-                    else
-                    {
-                        // convert array index to number; unchecked access
-                        ptr = &ptr->operator[](array_index(reference_token));
-                    }
-                    break;
-                }
-
-                default:
-                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
-            }
-        }
-
-        return *ptr;
-    }
-
-    /*!
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.402  if the array index '-' is used
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-    */
-    BasicJsonType& get_checked(BasicJsonType* ptr) const
-    {
-        for (const auto& reference_token : reference_tokens)
-        {
-            switch (ptr->type())
-            {
-                case detail::value_t::object:
-                {
-                    // note: at performs range check
-                    ptr = &ptr->at(reference_token);
-                    break;
-                }
-
-                case detail::value_t::array:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
-                    {
-                        // "-" always fails the range check
-                        JSON_THROW(detail::out_of_range::create(402,
-                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
-                                                                ") is out of range"));
-                    }
-
-                    // note: at performs range check
-                    ptr = &ptr->at(array_index(reference_token));
-                    break;
-                }
-
-                default:
-                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
-            }
-        }
-
-        return *ptr;
-    }
-
-    /*!
-    @brief return a const reference to the pointed to value
-
-    @param[in] ptr  a JSON value
-
-    @return const reference to the JSON value pointed to by the JSON
-    pointer
-
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.402  if the array index '-' is used
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-    */
-    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
-    {
-        for (const auto& reference_token : reference_tokens)
-        {
-            switch (ptr->type())
-            {
-                case detail::value_t::object:
-                {
-                    // use unchecked object access
-                    ptr = &ptr->operator[](reference_token);
-                    break;
-                }
-
-                case detail::value_t::array:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
-                    {
-                        // "-" cannot be used for const access
-                        JSON_THROW(detail::out_of_range::create(402,
-                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
-                                                                ") is out of range"));
-                    }
-
-                    // use unchecked array access
-                    ptr = &ptr->operator[](array_index(reference_token));
-                    break;
-                }
-
-                default:
-                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
-            }
-        }
-
-        return *ptr;
-    }
-
-    /*!
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.402  if the array index '-' is used
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-    */
-    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
-    {
-        for (const auto& reference_token : reference_tokens)
-        {
-            switch (ptr->type())
-            {
-                case detail::value_t::object:
-                {
-                    // note: at performs range check
-                    ptr = &ptr->at(reference_token);
-                    break;
-                }
-
-                case detail::value_t::array:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
-                    {
-                        // "-" always fails the range check
-                        JSON_THROW(detail::out_of_range::create(402,
-                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
-                                                                ") is out of range"));
-                    }
-
-                    // note: at performs range check
-                    ptr = &ptr->at(array_index(reference_token));
-                    break;
-                }
-
-                default:
-                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
-            }
-        }
-
-        return *ptr;
-    }
-
-    /*!
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    */
-    bool contains(const BasicJsonType* ptr) const
-    {
-        for (const auto& reference_token : reference_tokens)
-        {
-            switch (ptr->type())
-            {
-                case detail::value_t::object:
-                {
-                    if (!ptr->contains(reference_token))
-                    {
-                        // we did not find the key in the object
-                        return false;
-                    }
-
-                    ptr = &ptr->operator[](reference_token);
-                    break;
-                }
-
-                case detail::value_t::array:
-                {
-                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
-                    {
-                        // "-" always fails the range check
-                        return false;
-                    }
-                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
-                    {
-                        // invalid char
-                        return false;
-                    }
-                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
-                    {
-                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
-                        {
-                            // first char should be between '1' and '9'
-                            return false;
-                        }
-                        for (std::size_t i = 1; i < reference_token.size(); i++)
-                        {
-                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
-                            {
-                                // other char should be between '0' and '9'
-                                return false;
-                            }
-                        }
-                    }
-
-                    const auto idx = array_index(reference_token);
-                    if (idx >= ptr->size())
-                    {
-                        // index out of range
-                        return false;
-                    }
-
-                    ptr = &ptr->operator[](idx);
-                    break;
-                }
-
-                default:
-                {
-                    // we do not expect primitive values if there is still a
-                    // reference token to process
-                    return false;
-                }
-            }
-        }
-
-        // no reference token left means we found a primitive value
-        return true;
-    }
-
-    /*!
-    @brief split the string input to reference tokens
-
-    @note This function is only called by the json_pointer constructor.
-          All exceptions below are documented there.
-
-    @throw parse_error.107  if the pointer is not empty or begins with '/'
-    @throw parse_error.108  if character '~' is not followed by '0' or '1'
-    */
-    static std::vector<std::string> split(const std::string& reference_string)
-    {
-        std::vector<std::string> result;
-
-        // special case: empty reference string -> no reference tokens
-        if (reference_string.empty())
-        {
-            return result;
-        }
-
-        // check if nonempty reference string begins with slash
-        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
-        {
-            JSON_THROW(detail::parse_error::create(107, 1,
-                                                   "JSON pointer must be empty or begin with '/' - was: '" +
-                                                   reference_string + "'"));
-        }
-
-        // extract the reference tokens:
-        // - slash: position of the last read slash (or end of string)
-        // - start: position after the previous slash
-        for (
-            // search for the first slash after the first character
-            std::size_t slash = reference_string.find_first_of('/', 1),
-            // set the beginning of the first reference token
-            start = 1;
-            // we can stop if start == 0 (if slash == std::string::npos)
-            start != 0;
-            // set the beginning of the next reference token
-            // (will eventually be 0 if slash == std::string::npos)
-            start = (slash == std::string::npos) ? 0 : slash + 1,
-            // find next slash
-            slash = reference_string.find_first_of('/', start))
-        {
-            // use the text between the beginning of the reference token
-            // (start) and the last slash (slash).
-            auto reference_token = reference_string.substr(start, slash - start);
-
-            // check reference tokens are properly escaped
-            for (std::size_t pos = reference_token.find_first_of('~');
-                    pos != std::string::npos;
-                    pos = reference_token.find_first_of('~', pos + 1))
-            {
-                JSON_ASSERT(reference_token[pos] == '~');
-
-                // ~ must be followed by 0 or 1
-                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
-                                         (reference_token[pos + 1] != '0' &&
-                                          reference_token[pos + 1] != '1')))
-                {
-                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
-                }
-            }
-
-            // finally, store the reference token
-            unescape(reference_token);
-            result.push_back(reference_token);
-        }
-
-        return result;
-    }
-
-    /*!
-    @brief replace all occurrences of a substring by another string
-
-    @param[in,out] s  the string to manipulate; changed so that all
-                   occurrences of @a f are replaced with @a t
-    @param[in]     f  the substring to replace with @a t
-    @param[in]     t  the string to replace @a f
-
-    @pre The search string @a f must not be empty. **This precondition is
-    enforced with an assertion.**
-
-    @since version 2.0.0
-    */
-    static void replace_substring(std::string& s, const std::string& f,
-                                  const std::string& t)
-    {
-        JSON_ASSERT(!f.empty());
-        for (auto pos = s.find(f);                // find first occurrence of f
-                pos != std::string::npos;         // make sure f was found
-                s.replace(pos, f.size(), t),      // replace with t, and
-                pos = s.find(f, pos + t.size()))  // find next occurrence of f
-        {}
-    }
-
-    /// escape "~" to "~0" and "/" to "~1"
-    static std::string escape(std::string s)
-    {
-        replace_substring(s, "~", "~0");
-        replace_substring(s, "/", "~1");
-        return s;
-    }
-
-    /// unescape "~1" to tilde and "~0" to slash (order is important!)
-    static void unescape(std::string& s)
-    {
-        replace_substring(s, "~1", "/");
-        replace_substring(s, "~0", "~");
-    }
-
-    /*!
-    @param[in] reference_string  the reference string to the current value
-    @param[in] value             the value to consider
-    @param[in,out] result        the result object to insert values to
-
-    @note Empty objects or arrays are flattened to `null`.
-    */
-    static void flatten(const std::string& reference_string,
-                        const BasicJsonType& value,
-                        BasicJsonType& result)
-    {
-        switch (value.type())
-        {
-            case detail::value_t::array:
-            {
-                if (value.m_value.array->empty())
-                {
-                    // flatten empty array as null
-                    result[reference_string] = nullptr;
-                }
-                else
-                {
-                    // iterate array and use index as reference string
-                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
-                    {
-                        flatten(reference_string + "/" + std::to_string(i),
-                                value.m_value.array->operator[](i), result);
-                    }
-                }
-                break;
-            }
-
-            case detail::value_t::object:
-            {
-                if (value.m_value.object->empty())
-                {
-                    // flatten empty object as null
-                    result[reference_string] = nullptr;
-                }
-                else
-                {
-                    // iterate object and use keys as reference string
-                    for (const auto& element : *value.m_value.object)
-                    {
-                        flatten(reference_string + "/" + escape(element.first), element.second, result);
-                    }
-                }
-                break;
-            }
-
-            default:
-            {
-                // add primitive value with its reference string
-                result[reference_string] = value;
-                break;
-            }
-        }
-    }
-
-    /*!
-    @param[in] value  flattened JSON
-
-    @return unflattened JSON
-
-    @throw parse_error.109 if array index is not a number
-    @throw type_error.314  if value is not an object
-    @throw type_error.315  if object values are not primitive
-    @throw type_error.313  if value cannot be unflattened
-    */
-    static BasicJsonType
-    unflatten(const BasicJsonType& value)
-    {
-        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
-        {
-            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
-        }
-
-        BasicJsonType result;
-
-        // iterate the JSON object values
-        for (const auto& element : *value.m_value.object)
-        {
-            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
-            {
-                JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
-            }
-
-            // assign value to reference pointed to by JSON pointer; Note that if
-            // the JSON pointer is "" (i.e., points to the whole value), function
-            // get_and_create returns a reference to result itself. An assignment
-            // will then create a primitive value.
-            json_pointer(element.first).get_and_create(result) = element.second;
-        }
-
-        return result;
-    }
-
-    /*!
-    @brief compares two JSON pointers for equality
-
-    @param[in] lhs  JSON pointer to compare
-    @param[in] rhs  JSON pointer to compare
-    @return whether @a lhs is equal to @a rhs
-
-    @complexity Linear in the length of the JSON pointer
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-    */
-    friend bool operator==(json_pointer const& lhs,
-                           json_pointer const& rhs) noexcept
-    {
-        return lhs.reference_tokens == rhs.reference_tokens;
-    }
-
-    /*!
-    @brief compares two JSON pointers for inequality
-
-    @param[in] lhs  JSON pointer to compare
-    @param[in] rhs  JSON pointer to compare
-    @return whether @a lhs is not equal @a rhs
-
-    @complexity Linear in the length of the JSON pointer
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-    */
-    friend bool operator!=(json_pointer const& lhs,
-                           json_pointer const& rhs) noexcept
-    {
-        return !(lhs == rhs);
-    }
-
-    /// the reference tokens
-    std::vector<std::string> reference_tokens;
-};
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/json_ref.hpp>
-
-
-#include <initializer_list>
-#include <utility>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-template<typename BasicJsonType>
-class json_ref
-{
-  public:
-    using value_type = BasicJsonType;
-
-    json_ref(value_type&& value)
-        : owned_value(std::move(value))
-        , value_ref(&owned_value)
-        , is_rvalue(true)
-    {}
-
-    json_ref(const value_type& value)
-        : value_ref(const_cast<value_type*>(&value))
-        , is_rvalue(false)
-    {}
-
-    json_ref(std::initializer_list<json_ref> init)
-        : owned_value(init)
-        , value_ref(&owned_value)
-        , is_rvalue(true)
-    {}
-
-    template <
-        class... Args,
-        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
-    json_ref(Args && ... args)
-        : owned_value(std::forward<Args>(args)...)
-        , value_ref(&owned_value)
-        , is_rvalue(true)
-    {}
-
-    // class should be movable only
-    json_ref(json_ref&&) = default;
-    json_ref(const json_ref&) = delete;
-    json_ref& operator=(const json_ref&) = delete;
-    json_ref& operator=(json_ref&&) = delete;
-    ~json_ref() = default;
-
-    value_type moved_or_copied() const
-    {
-        if (is_rvalue)
-        {
-            return std::move(*value_ref);
-        }
-        return *value_ref;
-    }
-
-    value_type const& operator*() const
-    {
-        return *static_cast<value_type const*>(value_ref);
-    }
-
-    value_type const* operator->() const
-    {
-        return static_cast<value_type const*>(value_ref);
-    }
-
-  private:
-    mutable value_type owned_value = nullptr;
-    value_type* value_ref = nullptr;
-    const bool is_rvalue = true;
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/output/binary_writer.hpp>
-
-
-#include <algorithm> // reverse
-#include <array> // array
-#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
-#include <cstring> // memcpy
-#include <limits> // numeric_limits
-#include <string> // string
-#include <cmath> // isnan, isinf
-
-// #include <nlohmann/detail/input/binary_reader.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/output/output_adapters.hpp>
-
-
-#include <algorithm> // copy
-#include <cstddef> // size_t
-#include <ios> // streamsize
-#include <iterator> // back_inserter
-#include <memory> // shared_ptr, make_shared
-#include <ostream> // basic_ostream
-#include <string> // basic_string
-#include <vector> // vector
-// #include <nlohmann/detail/macro_scope.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-/// abstract output adapter interface
-template<typename CharType> struct output_adapter_protocol
-{
-    virtual void write_character(CharType c) = 0;
-    virtual void write_characters(const CharType* s, std::size_t length) = 0;
-    virtual ~output_adapter_protocol() = default;
-};
-
-/// a type to simplify interfaces
-template<typename CharType>
-using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
-
-/// output adapter for byte vectors
-template<typename CharType>
-class output_vector_adapter : public output_adapter_protocol<CharType>
-{
-  public:
-    explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
-        : v(vec)
-    {}
-
-    void write_character(CharType c) override
-    {
-        v.push_back(c);
-    }
-
-    JSON_HEDLEY_NON_NULL(2)
-    void write_characters(const CharType* s, std::size_t length) override
-    {
-        std::copy(s, s + length, std::back_inserter(v));
-    }
-
-  private:
-    std::vector<CharType>& v;
-};
-
-/// output adapter for output streams
-template<typename CharType>
-class output_stream_adapter : public output_adapter_protocol<CharType>
-{
-  public:
-    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
-        : stream(s)
-    {}
-
-    void write_character(CharType c) override
-    {
-        stream.put(c);
-    }
-
-    JSON_HEDLEY_NON_NULL(2)
-    void write_characters(const CharType* s, std::size_t length) override
-    {
-        stream.write(s, static_cast<std::streamsize>(length));
-    }
-
-  private:
-    std::basic_ostream<CharType>& stream;
-};
-
-/// output adapter for basic_string
-template<typename CharType, typename StringType = std::basic_string<CharType>>
-class output_string_adapter : public output_adapter_protocol<CharType>
-{
-  public:
-    explicit output_string_adapter(StringType& s) noexcept
-        : str(s)
-    {}
-
-    void write_character(CharType c) override
-    {
-        str.push_back(c);
-    }
-
-    JSON_HEDLEY_NON_NULL(2)
-    void write_characters(const CharType* s, std::size_t length) override
-    {
-        str.append(s, length);
-    }
-
-  private:
-    StringType& str;
-};
-
-template<typename CharType, typename StringType = std::basic_string<CharType>>
-class output_adapter
-{
-  public:
-    output_adapter(std::vector<CharType>& vec)
-        : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
-
-    output_adapter(std::basic_ostream<CharType>& s)
-        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
-
-    output_adapter(StringType& s)
-        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
-
-    operator output_adapter_t<CharType>()
-    {
-        return oa;
-    }
-
-  private:
-    output_adapter_t<CharType> oa = nullptr;
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-
-namespace nlohmann
-{
-namespace detail
-{
-///////////////////
-// binary writer //
-///////////////////
-
-/*!
-@brief serialization to CBOR and MessagePack values
-*/
-template<typename BasicJsonType, typename CharType>
-class binary_writer
-{
-    using string_t = typename BasicJsonType::string_t;
-    using binary_t = typename BasicJsonType::binary_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-
-  public:
-    /*!
-    @brief create a binary writer
-
-    @param[in] adapter  output adapter to write to
-    */
-    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
-    {
-        JSON_ASSERT(oa);
-    }
-
-    /*!
-    @param[in] j  JSON value to serialize
-    @pre       j.type() == value_t::object
-    */
-    void write_bson(const BasicJsonType& j)
-    {
-        switch (j.type())
-        {
-            case value_t::object:
-            {
-                write_bson_object(*j.m_value.object);
-                break;
-            }
-
-            default:
-            {
-                JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
-            }
-        }
-    }
-
-    /*!
-    @param[in] j  JSON value to serialize
-    */
-    void write_cbor(const BasicJsonType& j)
-    {
-        switch (j.type())
-        {
-            case value_t::null:
-            {
-                oa->write_character(to_char_type(0xF6));
-                break;
-            }
-
-            case value_t::boolean:
-            {
-                oa->write_character(j.m_value.boolean
-                                    ? to_char_type(0xF5)
-                                    : to_char_type(0xF4));
-                break;
-            }
-
-            case value_t::number_integer:
-            {
-                if (j.m_value.number_integer >= 0)
-                {
-                    // CBOR does not differentiate between positive signed
-                    // integers and unsigned integers. Therefore, we used the
-                    // code from the value_t::number_unsigned case here.
-                    if (j.m_value.number_integer <= 0x17)
-                    {
-                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
-                    {
-                        oa->write_character(to_char_type(0x18));
-                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
-                    {
-                        oa->write_character(to_char_type(0x19));
-                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
-                    {
-                        oa->write_character(to_char_type(0x1A));
-                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
-                    }
-                    else
-                    {
-                        oa->write_character(to_char_type(0x1B));
-                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
-                    }
-                }
-                else
-                {
-                    // The conversions below encode the sign in the first
-                    // byte, and the value is converted to a positive number.
-                    const auto positive_number = -1 - j.m_value.number_integer;
-                    if (j.m_value.number_integer >= -24)
-                    {
-                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
-                    }
-                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
-                    {
-                        oa->write_character(to_char_type(0x38));
-                        write_number(static_cast<std::uint8_t>(positive_number));
-                    }
-                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
-                    {
-                        oa->write_character(to_char_type(0x39));
-                        write_number(static_cast<std::uint16_t>(positive_number));
-                    }
-                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
-                    {
-                        oa->write_character(to_char_type(0x3A));
-                        write_number(static_cast<std::uint32_t>(positive_number));
-                    }
-                    else
-                    {
-                        oa->write_character(to_char_type(0x3B));
-                        write_number(static_cast<std::uint64_t>(positive_number));
-                    }
-                }
-                break;
-            }
-
-            case value_t::number_unsigned:
-            {
-                if (j.m_value.number_unsigned <= 0x17)
-                {
-                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
-                }
-                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x18));
-                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
-                }
-                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x19));
-                    write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
-                }
-                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x1A));
-                    write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
-                }
-                else
-                {
-                    oa->write_character(to_char_type(0x1B));
-                    write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
-                }
-                break;
-            }
-
-            case value_t::number_float:
-            {
-                if (std::isnan(j.m_value.number_float))
-                {
-                    // NaN is 0xf97e00 in CBOR
-                    oa->write_character(to_char_type(0xF9));
-                    oa->write_character(to_char_type(0x7E));
-                    oa->write_character(to_char_type(0x00));
-                }
-                else if (std::isinf(j.m_value.number_float))
-                {
-                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
-                    oa->write_character(to_char_type(0xf9));
-                    oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
-                    oa->write_character(to_char_type(0x00));
-                }
-                else
-                {
-                    write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
-                }
-                break;
-            }
-
-            case value_t::string:
-            {
-                // step 1: write control byte and the string length
-                const auto N = j.m_value.string->size();
-                if (N <= 0x17)
-                {
-                    write_number(static_cast<std::uint8_t>(0x60 + N));
-                }
-                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x78));
-                    write_number(static_cast<std::uint8_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x79));
-                    write_number(static_cast<std::uint16_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x7A));
-                    write_number(static_cast<std::uint32_t>(N));
-                }
-                // LCOV_EXCL_START
-                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x7B));
-                    write_number(static_cast<std::uint64_t>(N));
-                }
-                // LCOV_EXCL_STOP
-
-                // step 2: write the string
-                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
-                    j.m_value.string->size());
-                break;
-            }
-
-            case value_t::array:
-            {
-                // step 1: write control byte and the array size
-                const auto N = j.m_value.array->size();
-                if (N <= 0x17)
-                {
-                    write_number(static_cast<std::uint8_t>(0x80 + N));
-                }
-                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x98));
-                    write_number(static_cast<std::uint8_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x99));
-                    write_number(static_cast<std::uint16_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x9A));
-                    write_number(static_cast<std::uint32_t>(N));
-                }
-                // LCOV_EXCL_START
-                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x9B));
-                    write_number(static_cast<std::uint64_t>(N));
-                }
-                // LCOV_EXCL_STOP
-
-                // step 2: write each element
-                for (const auto& el : *j.m_value.array)
-                {
-                    write_cbor(el);
-                }
-                break;
-            }
-
-            case value_t::binary:
-            {
-                if (j.m_value.binary->has_subtype())
-                {
-                    write_number(static_cast<std::uint8_t>(0xd8));
-                    write_number(j.m_value.binary->subtype());
-                }
-
-                // step 1: write control byte and the binary array size
-                const auto N = j.m_value.binary->size();
-                if (N <= 0x17)
-                {
-                    write_number(static_cast<std::uint8_t>(0x40 + N));
-                }
-                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x58));
-                    write_number(static_cast<std::uint8_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x59));
-                    write_number(static_cast<std::uint16_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x5A));
-                    write_number(static_cast<std::uint32_t>(N));
-                }
-                // LCOV_EXCL_START
-                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
-                {
-                    oa->write_character(to_char_type(0x5B));
-                    write_number(static_cast<std::uint64_t>(N));
-                }
-                // LCOV_EXCL_STOP
-
-                // step 2: write each element
-                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
-                    N);
-
-                break;
-            }
-
-            case value_t::object:
-            {
-                // step 1: write control byte and the object size
-                const auto N = j.m_value.object->size();
-                if (N <= 0x17)
-                {
-                    write_number(static_cast<std::uint8_t>(0xA0 + N));
-                }
-                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
-                {
-                    oa->write_character(to_char_type(0xB8));
-                    write_number(static_cast<std::uint8_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    oa->write_character(to_char_type(0xB9));
-                    write_number(static_cast<std::uint16_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    oa->write_character(to_char_type(0xBA));
-                    write_number(static_cast<std::uint32_t>(N));
-                }
-                // LCOV_EXCL_START
-                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
-                {
-                    oa->write_character(to_char_type(0xBB));
-                    write_number(static_cast<std::uint64_t>(N));
-                }
-                // LCOV_EXCL_STOP
-
-                // step 2: write each element
-                for (const auto& el : *j.m_value.object)
-                {
-                    write_cbor(el.first);
-                    write_cbor(el.second);
-                }
-                break;
-            }
-
-            default:
-                break;
-        }
-    }
-
-    /*!
-    @param[in] j  JSON value to serialize
-    */
-    void write_msgpack(const BasicJsonType& j)
-    {
-        switch (j.type())
-        {
-            case value_t::null: // nil
-            {
-                oa->write_character(to_char_type(0xC0));
-                break;
-            }
-
-            case value_t::boolean: // true and false
-            {
-                oa->write_character(j.m_value.boolean
-                                    ? to_char_type(0xC3)
-                                    : to_char_type(0xC2));
-                break;
-            }
-
-            case value_t::number_integer:
-            {
-                if (j.m_value.number_integer >= 0)
-                {
-                    // MessagePack does not differentiate between positive
-                    // signed integers and unsigned integers. Therefore, we used
-                    // the code from the value_t::number_unsigned case here.
-                    if (j.m_value.number_unsigned < 128)
-                    {
-                        // positive fixnum
-                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
-                    {
-                        // uint 8
-                        oa->write_character(to_char_type(0xCC));
-                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
-                    {
-                        // uint 16
-                        oa->write_character(to_char_type(0xCD));
-                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
-                    {
-                        // uint 32
-                        oa->write_character(to_char_type(0xCE));
-                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
-                    {
-                        // uint 64
-                        oa->write_character(to_char_type(0xCF));
-                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
-                    }
-                }
-                else
-                {
-                    if (j.m_value.number_integer >= -32)
-                    {
-                        // negative fixnum
-                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
-                             j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
-                    {
-                        // int 8
-                        oa->write_character(to_char_type(0xD0));
-                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
-                             j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
-                    {
-                        // int 16
-                        oa->write_character(to_char_type(0xD1));
-                        write_number(static_cast<std::int16_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
-                             j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
-                    {
-                        // int 32
-                        oa->write_character(to_char_type(0xD2));
-                        write_number(static_cast<std::int32_t>(j.m_value.number_integer));
-                    }
-                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
-                             j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
-                    {
-                        // int 64
-                        oa->write_character(to_char_type(0xD3));
-                        write_number(static_cast<std::int64_t>(j.m_value.number_integer));
-                    }
-                }
-                break;
-            }
-
-            case value_t::number_unsigned:
-            {
-                if (j.m_value.number_unsigned < 128)
-                {
-                    // positive fixnum
-                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
-                }
-                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
-                {
-                    // uint 8
-                    oa->write_character(to_char_type(0xCC));
-                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
-                }
-                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    // uint 16
-                    oa->write_character(to_char_type(0xCD));
-                    write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
-                }
-                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    // uint 32
-                    oa->write_character(to_char_type(0xCE));
-                    write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
-                }
-                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
-                {
-                    // uint 64
-                    oa->write_character(to_char_type(0xCF));
-                    write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
-                }
-                break;
-            }
-
-            case value_t::number_float:
-            {
-                write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
-                break;
-            }
-
-            case value_t::string:
-            {
-                // step 1: write control byte and the string length
-                const auto N = j.m_value.string->size();
-                if (N <= 31)
-                {
-                    // fixstr
-                    write_number(static_cast<std::uint8_t>(0xA0 | N));
-                }
-                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
-                {
-                    // str 8
-                    oa->write_character(to_char_type(0xD9));
-                    write_number(static_cast<std::uint8_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    // str 16
-                    oa->write_character(to_char_type(0xDA));
-                    write_number(static_cast<std::uint16_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    // str 32
-                    oa->write_character(to_char_type(0xDB));
-                    write_number(static_cast<std::uint32_t>(N));
-                }
-
-                // step 2: write the string
-                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
-                    j.m_value.string->size());
-                break;
-            }
-
-            case value_t::array:
-            {
-                // step 1: write control byte and the array size
-                const auto N = j.m_value.array->size();
-                if (N <= 15)
-                {
-                    // fixarray
-                    write_number(static_cast<std::uint8_t>(0x90 | N));
-                }
-                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    // array 16
-                    oa->write_character(to_char_type(0xDC));
-                    write_number(static_cast<std::uint16_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    // array 32
-                    oa->write_character(to_char_type(0xDD));
-                    write_number(static_cast<std::uint32_t>(N));
-                }
-
-                // step 2: write each element
-                for (const auto& el : *j.m_value.array)
-                {
-                    write_msgpack(el);
-                }
-                break;
-            }
-
-            case value_t::binary:
-            {
-                // step 0: determine if the binary type has a set subtype to
-                // determine whether or not to use the ext or fixext types
-                const bool use_ext = j.m_value.binary->has_subtype();
-
-                // step 1: write control byte and the byte string length
-                const auto N = j.m_value.binary->size();
-                if (N <= (std::numeric_limits<std::uint8_t>::max)())
-                {
-                    std::uint8_t output_type{};
-                    bool fixed = true;
-                    if (use_ext)
-                    {
-                        switch (N)
-                        {
-                            case 1:
-                                output_type = 0xD4; // fixext 1
-                                break;
-                            case 2:
-                                output_type = 0xD5; // fixext 2
-                                break;
-                            case 4:
-                                output_type = 0xD6; // fixext 4
-                                break;
-                            case 8:
-                                output_type = 0xD7; // fixext 8
-                                break;
-                            case 16:
-                                output_type = 0xD8; // fixext 16
-                                break;
-                            default:
-                                output_type = 0xC7; // ext 8
-                                fixed = false;
-                                break;
-                        }
-
-                    }
-                    else
-                    {
-                        output_type = 0xC4; // bin 8
-                        fixed = false;
-                    }
-
-                    oa->write_character(to_char_type(output_type));
-                    if (!fixed)
-                    {
-                        write_number(static_cast<std::uint8_t>(N));
-                    }
-                }
-                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    std::uint8_t output_type = use_ext
-                                               ? 0xC8 // ext 16
-                                               : 0xC5; // bin 16
-
-                    oa->write_character(to_char_type(output_type));
-                    write_number(static_cast<std::uint16_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    std::uint8_t output_type = use_ext
-                                               ? 0xC9 // ext 32
-                                               : 0xC6; // bin 32
-
-                    oa->write_character(to_char_type(output_type));
-                    write_number(static_cast<std::uint32_t>(N));
-                }
-
-                // step 1.5: if this is an ext type, write the subtype
-                if (use_ext)
-                {
-                    write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
-                }
-
-                // step 2: write the byte string
-                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
-                    N);
-
-                break;
-            }
-
-            case value_t::object:
-            {
-                // step 1: write control byte and the object size
-                const auto N = j.m_value.object->size();
-                if (N <= 15)
-                {
-                    // fixmap
-                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
-                }
-                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
-                {
-                    // map 16
-                    oa->write_character(to_char_type(0xDE));
-                    write_number(static_cast<std::uint16_t>(N));
-                }
-                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
-                {
-                    // map 32
-                    oa->write_character(to_char_type(0xDF));
-                    write_number(static_cast<std::uint32_t>(N));
-                }
-
-                // step 2: write each element
-                for (const auto& el : *j.m_value.object)
-                {
-                    write_msgpack(el.first);
-                    write_msgpack(el.second);
-                }
-                break;
-            }
-
-            default:
-                break;
-        }
-    }
-
-    /*!
-    @param[in] j  JSON value to serialize
-    @param[in] use_count   whether to use '#' prefixes (optimized format)
-    @param[in] use_type    whether to use '$' prefixes (optimized format)
-    @param[in] add_prefix  whether prefixes need to be used for this value
-    */
-    void write_ubjson(const BasicJsonType& j, const bool use_count,
-                      const bool use_type, const bool add_prefix = true)
-    {
-        switch (j.type())
-        {
-            case value_t::null:
-            {
-                if (add_prefix)
-                {
-                    oa->write_character(to_char_type('Z'));
-                }
-                break;
-            }
-
-            case value_t::boolean:
-            {
-                if (add_prefix)
-                {
-                    oa->write_character(j.m_value.boolean
-                                        ? to_char_type('T')
-                                        : to_char_type('F'));
-                }
-                break;
-            }
-
-            case value_t::number_integer:
-            {
-                write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
-                break;
-            }
-
-            case value_t::number_unsigned:
-            {
-                write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
-                break;
-            }
-
-            case value_t::number_float:
-            {
-                write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
-                break;
-            }
-
-            case value_t::string:
-            {
-                if (add_prefix)
-                {
-                    oa->write_character(to_char_type('S'));
-                }
-                write_number_with_ubjson_prefix(j.m_value.string->size(), true);
-                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
-                    j.m_value.string->size());
-                break;
-            }
-
-            case value_t::array:
-            {
-                if (add_prefix)
-                {
-                    oa->write_character(to_char_type('['));
-                }
-
-                bool prefix_required = true;
-                if (use_type && !j.m_value.array->empty())
-                {
-                    JSON_ASSERT(use_count);
-                    const CharType first_prefix = ubjson_prefix(j.front());
-                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
-                                                         [this, first_prefix](const BasicJsonType & v)
-                    {
-                        return ubjson_prefix(v) == first_prefix;
-                    });
-
-                    if (same_prefix)
-                    {
-                        prefix_required = false;
-                        oa->write_character(to_char_type('$'));
-                        oa->write_character(first_prefix);
-                    }
-                }
-
-                if (use_count)
-                {
-                    oa->write_character(to_char_type('#'));
-                    write_number_with_ubjson_prefix(j.m_value.array->size(), true);
-                }
-
-                for (const auto& el : *j.m_value.array)
-                {
-                    write_ubjson(el, use_count, use_type, prefix_required);
-                }
-
-                if (!use_count)
-                {
-                    oa->write_character(to_char_type(']'));
-                }
-
-                break;
-            }
-
-            case value_t::binary:
-            {
-                if (add_prefix)
-                {
-                    oa->write_character(to_char_type('['));
-                }
-
-                if (use_type && !j.m_value.binary->empty())
-                {
-                    JSON_ASSERT(use_count);
-                    oa->write_character(to_char_type('$'));
-                    oa->write_character('U');
-                }
-
-                if (use_count)
-                {
-                    oa->write_character(to_char_type('#'));
-                    write_number_with_ubjson_prefix(j.m_value.binary->size(), true);
-                }
-
-                if (use_type)
-                {
-                    oa->write_characters(
-                        reinterpret_cast<const CharType*>(j.m_value.binary->data()),
-                        j.m_value.binary->size());
-                }
-                else
-                {
-                    for (size_t i = 0; i < j.m_value.binary->size(); ++i)
-                    {
-                        oa->write_character(to_char_type('U'));
-                        oa->write_character(j.m_value.binary->data()[i]);
-                    }
-                }
-
-                if (!use_count)
-                {
-                    oa->write_character(to_char_type(']'));
-                }
-
-                break;
-            }
-
-            case value_t::object:
-            {
-                if (add_prefix)
-                {
-                    oa->write_character(to_char_type('{'));
-                }
-
-                bool prefix_required = true;
-                if (use_type && !j.m_value.object->empty())
-                {
-                    JSON_ASSERT(use_count);
-                    const CharType first_prefix = ubjson_prefix(j.front());
-                    const bool same_prefix = std::all_of(j.begin(), j.end(),
-                                                         [this, first_prefix](const BasicJsonType & v)
-                    {
-                        return ubjson_prefix(v) == first_prefix;
-                    });
-
-                    if (same_prefix)
-                    {
-                        prefix_required = false;
-                        oa->write_character(to_char_type('$'));
-                        oa->write_character(first_prefix);
-                    }
-                }
-
-                if (use_count)
-                {
-                    oa->write_character(to_char_type('#'));
-                    write_number_with_ubjson_prefix(j.m_value.object->size(), true);
-                }
-
-                for (const auto& el : *j.m_value.object)
-                {
-                    write_number_with_ubjson_prefix(el.first.size(), true);
-                    oa->write_characters(
-                        reinterpret_cast<const CharType*>(el.first.c_str()),
-                        el.first.size());
-                    write_ubjson(el.second, use_count, use_type, prefix_required);
-                }
-
-                if (!use_count)
-                {
-                    oa->write_character(to_char_type('}'));
-                }
-
-                break;
-            }
-
-            default:
-                break;
-        }
-    }
-
-  private:
-    //////////
-    // BSON //
-    //////////
-
-    /*!
-    @return The size of a BSON document entry header, including the id marker
-            and the entry name size (and its null-terminator).
-    */
-    static std::size_t calc_bson_entry_header_size(const string_t& name)
-    {
-        const auto it = name.find(static_cast<typename string_t::value_type>(0));
-        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
-        {
-            JSON_THROW(out_of_range::create(409,
-                                            "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
-        }
-
-        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
-    }
-
-    /*!
-    @brief Writes the given @a element_type and @a name to the output adapter
-    */
-    void write_bson_entry_header(const string_t& name,
-                                 const std::uint8_t element_type)
-    {
-        oa->write_character(to_char_type(element_type)); // boolean
-        oa->write_characters(
-            reinterpret_cast<const CharType*>(name.c_str()),
-            name.size() + 1u);
-    }
-
-    /*!
-    @brief Writes a BSON element with key @a name and boolean value @a value
-    */
-    void write_bson_boolean(const string_t& name,
-                            const bool value)
-    {
-        write_bson_entry_header(name, 0x08);
-        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
-    }
-
-    /*!
-    @brief Writes a BSON element with key @a name and double value @a value
-    */
-    void write_bson_double(const string_t& name,
-                           const double value)
-    {
-        write_bson_entry_header(name, 0x01);
-        write_number<double, true>(value);
-    }
-
-    /*!
-    @return The size of the BSON-encoded string in @a value
-    */
-    static std::size_t calc_bson_string_size(const string_t& value)
-    {
-        return sizeof(std::int32_t) + value.size() + 1ul;
-    }
-
-    /*!
-    @brief Writes a BSON element with key @a name and string value @a value
-    */
-    void write_bson_string(const string_t& name,
-                           const string_t& value)
-    {
-        write_bson_entry_header(name, 0x02);
-
-        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
-        oa->write_characters(
-            reinterpret_cast<const CharType*>(value.c_str()),
-            value.size() + 1);
-    }
-
-    /*!
-    @brief Writes a BSON element with key @a name and null value
-    */
-    void write_bson_null(const string_t& name)
-    {
-        write_bson_entry_header(name, 0x0A);
-    }
-
-    /*!
-    @return The size of the BSON-encoded integer @a value
-    */
-    static std::size_t calc_bson_integer_size(const std::int64_t value)
-    {
-        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
-               ? sizeof(std::int32_t)
-               : sizeof(std::int64_t);
-    }
-
-    /*!
-    @brief Writes a BSON element with key @a name and integer @a value
-    */
-    void write_bson_integer(const string_t& name,
-                            const std::int64_t value)
-    {
-        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
-        {
-            write_bson_entry_header(name, 0x10); // int32
-            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
-        }
-        else
-        {
-            write_bson_entry_header(name, 0x12); // int64
-            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
-        }
-    }
-
-    /*!
-    @return The size of the BSON-encoded unsigned integer in @a j
-    */
-    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
-    {
-        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
-               ? sizeof(std::int32_t)
-               : sizeof(std::int64_t);
-    }
-
-    /*!
-    @brief Writes a BSON element with key @a name and unsigned @a value
-    */
-    void write_bson_unsigned(const string_t& name,
-                             const std::uint64_t value)
-    {
-        if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
-        {
-            write_bson_entry_header(name, 0x10 /* int32 */);
-            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
-        }
-        else if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
-        {
-            write_bson_entry_header(name, 0x12 /* int64 */);
-            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
-        }
-        else
-        {
-            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(value) + " cannot be represented by BSON as it does not fit int64"));
-        }
-    }
-
-    /*!
-    @brief Writes a BSON element with key @a name and object @a value
-    */
-    void write_bson_object_entry(const string_t& name,
-                                 const typename BasicJsonType::object_t& value)
-    {
-        write_bson_entry_header(name, 0x03); // object
-        write_bson_object(value);
-    }
-
-    /*!
-    @return The size of the BSON-encoded array @a value
-    */
-    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
-    {
-        std::size_t array_index = 0ul;
-
-        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), std::size_t(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
-        {
-            return result + calc_bson_element_size(std::to_string(array_index++), el);
-        });
-
-        return sizeof(std::int32_t) + embedded_document_size + 1ul;
-    }
-
-    /*!
-    @return The size of the BSON-encoded binary array @a value
-    */
-    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
-    {
-        return sizeof(std::int32_t) + value.size() + 1ul;
-    }
-
-    /*!
-    @brief Writes a BSON element with key @a name and array @a value
-    */
-    void write_bson_array(const string_t& name,
-                          const typename BasicJsonType::array_t& value)
-    {
-        write_bson_entry_header(name, 0x04); // array
-        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
-
-        std::size_t array_index = 0ul;
-
-        for (const auto& el : value)
-        {
-            write_bson_element(std::to_string(array_index++), el);
-        }
-
-        oa->write_character(to_char_type(0x00));
-    }
-
-    /*!
-    @brief Writes a BSON element with key @a name and binary value @a value
-    */
-    void write_bson_binary(const string_t& name,
-                           const binary_t& value)
-    {
-        write_bson_entry_header(name, 0x05);
-
-        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size()));
-        write_number(value.has_subtype() ? value.subtype() : std::uint8_t(0x00));
-
-        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
-    }
-
-    /*!
-    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
-    @return The calculated size for the BSON document entry for @a j with the given @a name.
-    */
-    static std::size_t calc_bson_element_size(const string_t& name,
-            const BasicJsonType& j)
-    {
-        const auto header_size = calc_bson_entry_header_size(name);
-        switch (j.type())
-        {
-            case value_t::object:
-                return header_size + calc_bson_object_size(*j.m_value.object);
-
-            case value_t::array:
-                return header_size + calc_bson_array_size(*j.m_value.array);
-
-            case value_t::binary:
-                return header_size + calc_bson_binary_size(*j.m_value.binary);
-
-            case value_t::boolean:
-                return header_size + 1ul;
-
-            case value_t::number_float:
-                return header_size + 8ul;
-
-            case value_t::number_integer:
-                return header_size + calc_bson_integer_size(j.m_value.number_integer);
-
-            case value_t::number_unsigned:
-                return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
-
-            case value_t::string:
-                return header_size + calc_bson_string_size(*j.m_value.string);
-
-            case value_t::null:
-                return header_size + 0ul;
-
-            // LCOV_EXCL_START
-            default:
-                JSON_ASSERT(false);
-                return 0ul;
-                // LCOV_EXCL_STOP
-        }
-    }
-
-    /*!
-    @brief Serializes the JSON value @a j to BSON and associates it with the
-           key @a name.
-    @param name The name to associate with the JSON entity @a j within the
-                current BSON document
-    @return The size of the BSON entry
-    */
-    void write_bson_element(const string_t& name,
-                            const BasicJsonType& j)
-    {
-        switch (j.type())
-        {
-            case value_t::object:
-                return write_bson_object_entry(name, *j.m_value.object);
-
-            case value_t::array:
-                return write_bson_array(name, *j.m_value.array);
-
-            case value_t::binary:
-                return write_bson_binary(name, *j.m_value.binary);
-
-            case value_t::boolean:
-                return write_bson_boolean(name, j.m_value.boolean);
-
-            case value_t::number_float:
-                return write_bson_double(name, j.m_value.number_float);
-
-            case value_t::number_integer:
-                return write_bson_integer(name, j.m_value.number_integer);
-
-            case value_t::number_unsigned:
-                return write_bson_unsigned(name, j.m_value.number_unsigned);
-
-            case value_t::string:
-                return write_bson_string(name, *j.m_value.string);
-
-            case value_t::null:
-                return write_bson_null(name);
-
-            // LCOV_EXCL_START
-            default:
-                JSON_ASSERT(false);
-                return;
-                // LCOV_EXCL_STOP
-        }
-    }
-
-    /*!
-    @brief Calculates the size of the BSON serialization of the given
-           JSON-object @a j.
-    @param[in] j  JSON value to serialize
-    @pre       j.type() == value_t::object
-    */
-    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
-    {
-        std::size_t document_size = std::accumulate(value.begin(), value.end(), std::size_t(0),
-                                    [](size_t result, const typename BasicJsonType::object_t::value_type & el)
-        {
-            return result += calc_bson_element_size(el.first, el.second);
-        });
-
-        return sizeof(std::int32_t) + document_size + 1ul;
-    }
-
-    /*!
-    @param[in] j  JSON value to serialize
-    @pre       j.type() == value_t::object
-    */
-    void write_bson_object(const typename BasicJsonType::object_t& value)
-    {
-        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
-
-        for (const auto& el : value)
-        {
-            write_bson_element(el.first, el.second);
-        }
-
-        oa->write_character(to_char_type(0x00));
-    }
-
-    //////////
-    // CBOR //
-    //////////
-
-    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
-    {
-        return to_char_type(0xFA);  // Single-Precision Float
-    }
-
-    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
-    {
-        return to_char_type(0xFB);  // Double-Precision Float
-    }
-
-    /////////////
-    // MsgPack //
-    /////////////
-
-    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
-    {
-        return to_char_type(0xCA);  // float 32
-    }
-
-    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
-    {
-        return to_char_type(0xCB);  // float 64
-    }
-
-    ////////////
-    // UBJSON //
-    ////////////
-
-    // UBJSON: write number (floating point)
-    template<typename NumberType, typename std::enable_if<
-                 std::is_floating_point<NumberType>::value, int>::type = 0>
-    void write_number_with_ubjson_prefix(const NumberType n,
-                                         const bool add_prefix)
-    {
-        if (add_prefix)
-        {
-            oa->write_character(get_ubjson_float_prefix(n));
-        }
-        write_number(n);
-    }
-
-    // UBJSON: write number (unsigned integer)
-    template<typename NumberType, typename std::enable_if<
-                 std::is_unsigned<NumberType>::value, int>::type = 0>
-    void write_number_with_ubjson_prefix(const NumberType n,
-                                         const bool add_prefix)
-    {
-        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('i'));  // int8
-            }
-            write_number(static_cast<std::uint8_t>(n));
-        }
-        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('U'));  // uint8
-            }
-            write_number(static_cast<std::uint8_t>(n));
-        }
-        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('I'));  // int16
-            }
-            write_number(static_cast<std::int16_t>(n));
-        }
-        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('l'));  // int32
-            }
-            write_number(static_cast<std::int32_t>(n));
-        }
-        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('L'));  // int64
-            }
-            write_number(static_cast<std::int64_t>(n));
-        }
-        else
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('H'));  // high-precision number
-            }
-
-            const auto number = BasicJsonType(n).dump();
-            write_number_with_ubjson_prefix(number.size(), true);
-            for (std::size_t i = 0; i < number.size(); ++i)
-            {
-                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
-            }
-        }
-    }
-
-    // UBJSON: write number (signed integer)
-    template < typename NumberType, typename std::enable_if <
-                   std::is_signed<NumberType>::value&&
-                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
-    void write_number_with_ubjson_prefix(const NumberType n,
-                                         const bool add_prefix)
-    {
-        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('i'));  // int8
-            }
-            write_number(static_cast<std::int8_t>(n));
-        }
-        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('U'));  // uint8
-            }
-            write_number(static_cast<std::uint8_t>(n));
-        }
-        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('I'));  // int16
-            }
-            write_number(static_cast<std::int16_t>(n));
-        }
-        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('l'));  // int32
-            }
-            write_number(static_cast<std::int32_t>(n));
-        }
-        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('L'));  // int64
-            }
-            write_number(static_cast<std::int64_t>(n));
-        }
-        // LCOV_EXCL_START
-        else
-        {
-            if (add_prefix)
-            {
-                oa->write_character(to_char_type('H'));  // high-precision number
-            }
-
-            const auto number = BasicJsonType(n).dump();
-            write_number_with_ubjson_prefix(number.size(), true);
-            for (std::size_t i = 0; i < number.size(); ++i)
-            {
-                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
-            }
-        }
-        // LCOV_EXCL_STOP
-    }
-
-    /*!
-    @brief determine the type prefix of container values
-    */
-    CharType ubjson_prefix(const BasicJsonType& j) const noexcept
-    {
-        switch (j.type())
-        {
-            case value_t::null:
-                return 'Z';
-
-            case value_t::boolean:
-                return j.m_value.boolean ? 'T' : 'F';
-
-            case value_t::number_integer:
-            {
-                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
-                {
-                    return 'i';
-                }
-                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
-                {
-                    return 'U';
-                }
-                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
-                {
-                    return 'I';
-                }
-                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
-                {
-                    return 'l';
-                }
-                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
-                {
-                    return 'L';
-                }
-                // anything else is treated as high-precision number
-                return 'H'; // LCOV_EXCL_LINE
-            }
-
-            case value_t::number_unsigned:
-            {
-                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
-                {
-                    return 'i';
-                }
-                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
-                {
-                    return 'U';
-                }
-                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
-                {
-                    return 'I';
-                }
-                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
-                {
-                    return 'l';
-                }
-                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
-                {
-                    return 'L';
-                }
-                // anything else is treated as high-precision number
-                return 'H'; // LCOV_EXCL_LINE
-            }
-
-            case value_t::number_float:
-                return get_ubjson_float_prefix(j.m_value.number_float);
-
-            case value_t::string:
-                return 'S';
-
-            case value_t::array: // fallthrough
-            case value_t::binary:
-                return '[';
-
-            case value_t::object:
-                return '{';
-
-            default:  // discarded values
-                return 'N';
-        }
-    }
-
-    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
-    {
-        return 'd';  // float 32
-    }
-
-    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
-    {
-        return 'D';  // float 64
-    }
-
-    ///////////////////////
-    // Utility functions //
-    ///////////////////////
-
-    /*
-    @brief write a number to output input
-    @param[in] n number of type @a NumberType
-    @tparam NumberType the type of the number
-    @tparam OutputIsLittleEndian Set to true if output data is
-                                 required to be little endian
-
-    @note This function needs to respect the system's endianess, because bytes
-          in CBOR, MessagePack, and UBJSON are stored in network order (big
-          endian) and therefore need reordering on little endian systems.
-    */
-    template<typename NumberType, bool OutputIsLittleEndian = false>
-    void write_number(const NumberType n)
-    {
-        // step 1: write number to array of length NumberType
-        std::array<CharType, sizeof(NumberType)> vec;
-        std::memcpy(vec.data(), &n, sizeof(NumberType));
-
-        // step 2: write array to output (with possible reordering)
-        if (is_little_endian != OutputIsLittleEndian)
-        {
-            // reverse byte order prior to conversion if necessary
-            std::reverse(vec.begin(), vec.end());
-        }
-
-        oa->write_characters(vec.data(), sizeof(NumberType));
-    }
-
-    void write_compact_float(const number_float_t n, detail::input_format_t format)
-    {
-        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
-                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
-                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
-        {
-            oa->write_character(format == detail::input_format_t::cbor
-                                ? get_cbor_float_prefix(static_cast<float>(n))
-                                : get_msgpack_float_prefix(static_cast<float>(n)));
-            write_number(static_cast<float>(n));
-        }
-        else
-        {
-            oa->write_character(format == detail::input_format_t::cbor
-                                ? get_cbor_float_prefix(n)
-                                : get_msgpack_float_prefix(n));
-            write_number(n);
-        }
-    }
-
-  public:
-    // The following to_char_type functions are implement the conversion
-    // between uint8_t and CharType. In case CharType is not unsigned,
-    // such a conversion is required to allow values greater than 128.
-    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
-    template < typename C = CharType,
-               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
-    static constexpr CharType to_char_type(std::uint8_t x) noexcept
-    {
-        return *reinterpret_cast<char*>(&x);
-    }
-
-    template < typename C = CharType,
-               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
-    static CharType to_char_type(std::uint8_t x) noexcept
-    {
-        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
-        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
-        CharType result;
-        std::memcpy(&result, &x, sizeof(x));
-        return result;
-    }
-
-    template<typename C = CharType,
-             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
-    static constexpr CharType to_char_type(std::uint8_t x) noexcept
-    {
-        return x;
-    }
-
-    template < typename InputCharType, typename C = CharType,
-               enable_if_t <
-                   std::is_signed<C>::value &&
-                   std::is_signed<char>::value &&
-                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
-                   > * = nullptr >
-    static constexpr CharType to_char_type(InputCharType x) noexcept
-    {
-        return x;
-    }
-
-  private:
-    /// whether we can assume little endianess
-    const bool is_little_endian = little_endianess();
-
-    /// the output
-    output_adapter_t<CharType> oa = nullptr;
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/output/output_adapters.hpp>
-
-// #include <nlohmann/detail/output/serializer.hpp>
-
-
-#include <algorithm> // reverse, remove, fill, find, none_of
-#include <array> // array
-#include <clocale> // localeconv, lconv
-#include <cmath> // labs, isfinite, isnan, signbit
-#include <cstddef> // size_t, ptrdiff_t
-#include <cstdint> // uint8_t
-#include <cstdio> // snprintf
-#include <limits> // numeric_limits
-#include <string> // string, char_traits
-#include <type_traits> // is_same
-#include <utility> // move
-
-// #include <nlohmann/detail/conversions/to_chars.hpp>
-
-
-#include <array> // array
-#include <cmath>   // signbit, isfinite
-#include <cstdint> // intN_t, uintN_t
-#include <cstring> // memcpy, memmove
-#include <limits> // numeric_limits
-#include <type_traits> // conditional
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-
-/*!
-@brief implements the Grisu2 algorithm for binary to decimal floating-point
-conversion.
-
-This implementation is a slightly modified version of the reference
-implementation which may be obtained from
-http://florian.loitsch.com/publications (bench.tar.gz).
-
-The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
-
-For a detailed description of the algorithm see:
-
-[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
-    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
-    Language Design and Implementation, PLDI 2010
-[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
-    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
-    Design and Implementation, PLDI 1996
-*/
-namespace dtoa_impl
-{
-
-template<typename Target, typename Source>
-Target reinterpret_bits(const Source source)
-{
-    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
-
-    Target target;
-    std::memcpy(&target, &source, sizeof(Source));
-    return target;
-}
-
-struct diyfp // f * 2^e
-{
-    static constexpr int kPrecision = 64; // = q
-
-    std::uint64_t f = 0;
-    int e = 0;
-
-    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
-
-    /*!
-    @brief returns x - y
-    @pre x.e == y.e and x.f >= y.f
-    */
-    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
-    {
-        JSON_ASSERT(x.e == y.e);
-        JSON_ASSERT(x.f >= y.f);
-
-        return {x.f - y.f, x.e};
-    }
-
-    /*!
-    @brief returns x * y
-    @note The result is rounded. (Only the upper q bits are returned.)
-    */
-    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
-    {
-        static_assert(kPrecision == 64, "internal error");
-
-        // Computes:
-        //  f = round((x.f * y.f) / 2^q)
-        //  e = x.e + y.e + q
-
-        // Emulate the 64-bit * 64-bit multiplication:
-        //
-        // p = u * v
-        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
-        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
-        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
-        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
-        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
-        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
-        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
-        //
-        // (Since Q might be larger than 2^32 - 1)
-        //
-        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
-        //
-        // (Q_hi + H does not overflow a 64-bit int)
-        //
-        //   = p_lo + 2^64 p_hi
-
-        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
-        const std::uint64_t u_hi = x.f >> 32u;
-        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
-        const std::uint64_t v_hi = y.f >> 32u;
-
-        const std::uint64_t p0 = u_lo * v_lo;
-        const std::uint64_t p1 = u_lo * v_hi;
-        const std::uint64_t p2 = u_hi * v_lo;
-        const std::uint64_t p3 = u_hi * v_hi;
-
-        const std::uint64_t p0_hi = p0 >> 32u;
-        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
-        const std::uint64_t p1_hi = p1 >> 32u;
-        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
-        const std::uint64_t p2_hi = p2 >> 32u;
-
-        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
-
-        // The full product might now be computed as
-        //
-        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
-        // p_lo = p0_lo + (Q << 32)
-        //
-        // But in this particular case here, the full p_lo is not required.
-        // Effectively we only need to add the highest bit in p_lo to p_hi (and
-        // Q_hi + 1 does not overflow).
-
-        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
-
-        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
-
-        return {h, x.e + y.e + 64};
-    }
-
-    /*!
-    @brief normalize x such that the significand is >= 2^(q-1)
-    @pre x.f != 0
-    */
-    static diyfp normalize(diyfp x) noexcept
-    {
-        JSON_ASSERT(x.f != 0);
-
-        while ((x.f >> 63u) == 0)
-        {
-            x.f <<= 1u;
-            x.e--;
-        }
-
-        return x;
-    }
-
-    /*!
-    @brief normalize x such that the result has the exponent E
-    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
-    */
-    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
-    {
-        const int delta = x.e - target_exponent;
-
-        JSON_ASSERT(delta >= 0);
-        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
-
-        return {x.f << delta, target_exponent};
-    }
-};
-
-struct boundaries
-{
-    diyfp w;
-    diyfp minus;
-    diyfp plus;
-};
-
-/*!
-Compute the (normalized) diyfp representing the input number 'value' and its
-boundaries.
-
-@pre value must be finite and positive
-*/
-template<typename FloatType>
-boundaries compute_boundaries(FloatType value)
-{
-    JSON_ASSERT(std::isfinite(value));
-    JSON_ASSERT(value > 0);
-
-    // Convert the IEEE representation into a diyfp.
-    //
-    // If v is denormal:
-    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
-    // If v is normalized:
-    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
-
-    static_assert(std::numeric_limits<FloatType>::is_iec559,
-                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
-
-    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
-    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
-    constexpr int      kMinExp    = 1 - kBias;
-    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
-
-    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
-
-    const std::uint64_t bits = reinterpret_bits<bits_type>(value);
-    const std::uint64_t E = bits >> (kPrecision - 1);
-    const std::uint64_t F = bits & (kHiddenBit - 1);
-
-    const bool is_denormal = E == 0;
-    const diyfp v = is_denormal
-                    ? diyfp(F, kMinExp)
-                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
-
-    // Compute the boundaries m- and m+ of the floating-point value
-    // v = f * 2^e.
-    //
-    // Determine v- and v+, the floating-point predecessor and successor if v,
-    // respectively.
-    //
-    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
-    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
-    //
-    //      v+ = v + 2^e
-    //
-    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
-    // between m- and m+ round to v, regardless of how the input rounding
-    // algorithm breaks ties.
-    //
-    //      ---+-------------+-------------+-------------+-------------+---  (A)
-    //         v-            m-            v             m+            v+
-    //
-    //      -----------------+------+------+-------------+-------------+---  (B)
-    //                       v-     m-     v             m+            v+
-
-    const bool lower_boundary_is_closer = F == 0 && E > 1;
-    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
-    const diyfp m_minus = lower_boundary_is_closer
-                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
-                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
-
-    // Determine the normalized w+ = m+.
-    const diyfp w_plus = diyfp::normalize(m_plus);
-
-    // Determine w- = m- such that e_(w-) = e_(w+).
-    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
-
-    return {diyfp::normalize(v), w_minus, w_plus};
-}
-
-// Given normalized diyfp w, Grisu needs to find a (normalized) cached
-// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
-// within a certain range [alpha, gamma] (Definition 3.2 from [1])
-//
-//      alpha <= e = e_c + e_w + q <= gamma
-//
-// or
-//
-//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
-//                          <= f_c * f_w * 2^gamma
-//
-// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
-//
-//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
-//
-// or
-//
-//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
-//
-// The choice of (alpha,gamma) determines the size of the table and the form of
-// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
-// in practice:
-//
-// The idea is to cut the number c * w = f * 2^e into two parts, which can be
-// processed independently: An integral part p1, and a fractional part p2:
-//
-//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
-//              = (f div 2^-e) + (f mod 2^-e) * 2^e
-//              = p1 + p2 * 2^e
-//
-// The conversion of p1 into decimal form requires a series of divisions and
-// modulos by (a power of) 10. These operations are faster for 32-bit than for
-// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
-// achieved by choosing
-//
-//      -e >= 32   or   e <= -32 := gamma
-//
-// In order to convert the fractional part
-//
-//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
-//
-// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
-// d[-i] are extracted in order:
-//
-//      (10 * p2) div 2^-e = d[-1]
-//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
-//
-// The multiplication by 10 must not overflow. It is sufficient to choose
-//
-//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
-//
-// Since p2 = f mod 2^-e < 2^-e,
-//
-//      -e <= 60   or   e >= -60 := alpha
-
-constexpr int kAlpha = -60;
-constexpr int kGamma = -32;
-
-struct cached_power // c = f * 2^e ~= 10^k
-{
-    std::uint64_t f;
-    int e;
-    int k;
-};
-
-/*!
-For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
-power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
-satisfies (Definition 3.2 from [1])
-
-     alpha <= e_c + e + q <= gamma.
-*/
-inline cached_power get_cached_power_for_binary_exponent(int e)
-{
-    // Now
-    //
-    //      alpha <= e_c + e + q <= gamma                                    (1)
-    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
-    //
-    // and since the c's are normalized, 2^(q-1) <= f_c,
-    //
-    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
-    //      ==> 2^(alpha - e - 1) <= c
-    //
-    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
-    //
-    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
-    //        = ceil( (alpha - e - 1) * log_10(2) )
-    //
-    // From the paper:
-    // "In theory the result of the procedure could be wrong since c is rounded,
-    //  and the computation itself is approximated [...]. In practice, however,
-    //  this simple function is sufficient."
-    //
-    // For IEEE double precision floating-point numbers converted into
-    // normalized diyfp's w = f * 2^e, with q = 64,
-    //
-    //      e >= -1022      (min IEEE exponent)
-    //           -52        (p - 1)
-    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
-    //           -11        (normalize the diyfp)
-    //         = -1137
-    //
-    // and
-    //
-    //      e <= +1023      (max IEEE exponent)
-    //           -52        (p - 1)
-    //           -11        (normalize the diyfp)
-    //         = 960
-    //
-    // This binary exponent range [-1137,960] results in a decimal exponent
-    // range [-307,324]. One does not need to store a cached power for each
-    // k in this range. For each such k it suffices to find a cached power
-    // such that the exponent of the product lies in [alpha,gamma].
-    // This implies that the difference of the decimal exponents of adjacent
-    // table entries must be less than or equal to
-    //
-    //      floor( (gamma - alpha) * log_10(2) ) = 8.
-    //
-    // (A smaller distance gamma-alpha would require a larger table.)
-
-    // NB:
-    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
-
-    constexpr int kCachedPowersMinDecExp = -300;
-    constexpr int kCachedPowersDecStep = 8;
-
-    static constexpr std::array<cached_power, 79> kCachedPowers =
-    {
-        {
-            { 0xAB70FE17C79AC6CA, -1060, -300 },
-            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
-            { 0xBE5691EF416BD60C, -1007, -284 },
-            { 0x8DD01FAD907FFC3C,  -980, -276 },
-            { 0xD3515C2831559A83,  -954, -268 },
-            { 0x9D71AC8FADA6C9B5,  -927, -260 },
-            { 0xEA9C227723EE8BCB,  -901, -252 },
-            { 0xAECC49914078536D,  -874, -244 },
-            { 0x823C12795DB6CE57,  -847, -236 },
-            { 0xC21094364DFB5637,  -821, -228 },
-            { 0x9096EA6F3848984F,  -794, -220 },
-            { 0xD77485CB25823AC7,  -768, -212 },
-            { 0xA086CFCD97BF97F4,  -741, -204 },
-            { 0xEF340A98172AACE5,  -715, -196 },
-            { 0xB23867FB2A35B28E,  -688, -188 },
-            { 0x84C8D4DFD2C63F3B,  -661, -180 },
-            { 0xC5DD44271AD3CDBA,  -635, -172 },
-            { 0x936B9FCEBB25C996,  -608, -164 },
-            { 0xDBAC6C247D62A584,  -582, -156 },
-            { 0xA3AB66580D5FDAF6,  -555, -148 },
-            { 0xF3E2F893DEC3F126,  -529, -140 },
-            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
-            { 0x87625F056C7C4A8B,  -475, -124 },
-            { 0xC9BCFF6034C13053,  -449, -116 },
-            { 0x964E858C91BA2655,  -422, -108 },
-            { 0xDFF9772470297EBD,  -396, -100 },
-            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
-            { 0xF8A95FCF88747D94,  -343,  -84 },
-            { 0xB94470938FA89BCF,  -316,  -76 },
-            { 0x8A08F0F8BF0F156B,  -289,  -68 },
-            { 0xCDB02555653131B6,  -263,  -60 },
-            { 0x993FE2C6D07B7FAC,  -236,  -52 },
-            { 0xE45C10C42A2B3B06,  -210,  -44 },
-            { 0xAA242499697392D3,  -183,  -36 },
-            { 0xFD87B5F28300CA0E,  -157,  -28 },
-            { 0xBCE5086492111AEB,  -130,  -20 },
-            { 0x8CBCCC096F5088CC,  -103,  -12 },
-            { 0xD1B71758E219652C,   -77,   -4 },
-            { 0x9C40000000000000,   -50,    4 },
-            { 0xE8D4A51000000000,   -24,   12 },
-            { 0xAD78EBC5AC620000,     3,   20 },
-            { 0x813F3978F8940984,    30,   28 },
-            { 0xC097CE7BC90715B3,    56,   36 },
-            { 0x8F7E32CE7BEA5C70,    83,   44 },
-            { 0xD5D238A4ABE98068,   109,   52 },
-            { 0x9F4F2726179A2245,   136,   60 },
-            { 0xED63A231D4C4FB27,   162,   68 },
-            { 0xB0DE65388CC8ADA8,   189,   76 },
-            { 0x83C7088E1AAB65DB,   216,   84 },
-            { 0xC45D1DF942711D9A,   242,   92 },
-            { 0x924D692CA61BE758,   269,  100 },
-            { 0xDA01EE641A708DEA,   295,  108 },
-            { 0xA26DA3999AEF774A,   322,  116 },
-            { 0xF209787BB47D6B85,   348,  124 },
-            { 0xB454E4A179DD1877,   375,  132 },
-            { 0x865B86925B9BC5C2,   402,  140 },
-            { 0xC83553C5C8965D3D,   428,  148 },
-            { 0x952AB45CFA97A0B3,   455,  156 },
-            { 0xDE469FBD99A05FE3,   481,  164 },
-            { 0xA59BC234DB398C25,   508,  172 },
-            { 0xF6C69A72A3989F5C,   534,  180 },
-            { 0xB7DCBF5354E9BECE,   561,  188 },
-            { 0x88FCF317F22241E2,   588,  196 },
-            { 0xCC20CE9BD35C78A5,   614,  204 },
-            { 0x98165AF37B2153DF,   641,  212 },
-            { 0xE2A0B5DC971F303A,   667,  220 },
-            { 0xA8D9D1535CE3B396,   694,  228 },
-            { 0xFB9B7CD9A4A7443C,   720,  236 },
-            { 0xBB764C4CA7A44410,   747,  244 },
-            { 0x8BAB8EEFB6409C1A,   774,  252 },
-            { 0xD01FEF10A657842C,   800,  260 },
-            { 0x9B10A4E5E9913129,   827,  268 },
-            { 0xE7109BFBA19C0C9D,   853,  276 },
-            { 0xAC2820D9623BF429,   880,  284 },
-            { 0x80444B5E7AA7CF85,   907,  292 },
-            { 0xBF21E44003ACDD2D,   933,  300 },
-            { 0x8E679C2F5E44FF8F,   960,  308 },
-            { 0xD433179D9C8CB841,   986,  316 },
-            { 0x9E19DB92B4E31BA9,  1013,  324 },
-        }
-    };
-
-    // This computation gives exactly the same results for k as
-    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
-    // for |e| <= 1500, but doesn't require floating-point operations.
-    // NB: log_10(2) ~= 78913 / 2^18
-    JSON_ASSERT(e >= -1500);
-    JSON_ASSERT(e <=  1500);
-    const int f = kAlpha - e - 1;
-    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
-
-    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
-    JSON_ASSERT(index >= 0);
-    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
-
-    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
-    JSON_ASSERT(kAlpha <= cached.e + e + 64);
-    JSON_ASSERT(kGamma >= cached.e + e + 64);
-
-    return cached;
-}
-
-/*!
-For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
-For n == 0, returns 1 and sets pow10 := 1.
-*/
-inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
-{
-    // LCOV_EXCL_START
-    if (n >= 1000000000)
-    {
-        pow10 = 1000000000;
-        return 10;
-    }
-    // LCOV_EXCL_STOP
-    else if (n >= 100000000)
-    {
-        pow10 = 100000000;
-        return  9;
-    }
-    else if (n >= 10000000)
-    {
-        pow10 = 10000000;
-        return  8;
-    }
-    else if (n >= 1000000)
-    {
-        pow10 = 1000000;
-        return  7;
-    }
-    else if (n >= 100000)
-    {
-        pow10 = 100000;
-        return  6;
-    }
-    else if (n >= 10000)
-    {
-        pow10 = 10000;
-        return  5;
-    }
-    else if (n >= 1000)
-    {
-        pow10 = 1000;
-        return  4;
-    }
-    else if (n >= 100)
-    {
-        pow10 = 100;
-        return  3;
-    }
-    else if (n >= 10)
-    {
-        pow10 = 10;
-        return  2;
-    }
-    else
-    {
-        pow10 = 1;
-        return 1;
-    }
-}
-
-inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
-                         std::uint64_t rest, std::uint64_t ten_k)
-{
-    JSON_ASSERT(len >= 1);
-    JSON_ASSERT(dist <= delta);
-    JSON_ASSERT(rest <= delta);
-    JSON_ASSERT(ten_k > 0);
-
-    //               <--------------------------- delta ---->
-    //                                  <---- dist --------->
-    // --------------[------------------+-------------------]--------------
-    //               M-                 w                   M+
-    //
-    //                                  ten_k
-    //                                <------>
-    //                                       <---- rest ---->
-    // --------------[------------------+----+--------------]--------------
-    //                                  w    V
-    //                                       = buf * 10^k
-    //
-    // ten_k represents a unit-in-the-last-place in the decimal representation
-    // stored in buf.
-    // Decrement buf by ten_k while this takes buf closer to w.
-
-    // The tests are written in this order to avoid overflow in unsigned
-    // integer arithmetic.
-
-    while (rest < dist
-            && delta - rest >= ten_k
-            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
-    {
-        JSON_ASSERT(buf[len - 1] != '0');
-        buf[len - 1]--;
-        rest += ten_k;
-    }
-}
-
-/*!
-Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
-M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
-*/
-inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
-                             diyfp M_minus, diyfp w, diyfp M_plus)
-{
-    static_assert(kAlpha >= -60, "internal error");
-    static_assert(kGamma <= -32, "internal error");
-
-    // Generates the digits (and the exponent) of a decimal floating-point
-    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
-    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
-    //
-    //               <--------------------------- delta ---->
-    //                                  <---- dist --------->
-    // --------------[------------------+-------------------]--------------
-    //               M-                 w                   M+
-    //
-    // Grisu2 generates the digits of M+ from left to right and stops as soon as
-    // V is in [M-,M+].
-
-    JSON_ASSERT(M_plus.e >= kAlpha);
-    JSON_ASSERT(M_plus.e <= kGamma);
-
-    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
-    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
-
-    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
-    //
-    //      M+ = f * 2^e
-    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
-    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
-    //         = p1 + p2 * 2^e
-
-    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
-
-    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
-    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
-
-    // 1)
-    //
-    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
-
-    JSON_ASSERT(p1 > 0);
-
-    std::uint32_t pow10;
-    const int k = find_largest_pow10(p1, pow10);
-
-    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
-    //
-    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
-    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
-    //
-    //      M+ = p1                                             + p2 * 2^e
-    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
-    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
-    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
-    //
-    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
-    //
-    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
-    //
-    // but stop as soon as
-    //
-    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
-
-    int n = k;
-    while (n > 0)
-    {
-        // Invariants:
-        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
-        //      pow10 = 10^(n-1) <= p1 < 10^n
-        //
-        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
-        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
-        //
-        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
-        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
-        //
-        JSON_ASSERT(d <= 9);
-        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
-        //
-        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
-        //
-        p1 = r;
-        n--;
-        //
-        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
-        //      pow10 = 10^n
-        //
-
-        // Now check if enough digits have been generated.
-        // Compute
-        //
-        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
-        //
-        // Note:
-        // Since rest and delta share the same exponent e, it suffices to
-        // compare the significands.
-        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
-        if (rest <= delta)
-        {
-            // V = buffer * 10^n, with M- <= V <= M+.
-
-            decimal_exponent += n;
-
-            // We may now just stop. But instead look if the buffer could be
-            // decremented to bring V closer to w.
-            //
-            // pow10 = 10^n is now 1 ulp in the decimal representation V.
-            // The rounding procedure works with diyfp's with an implicit
-            // exponent of e.
-            //
-            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
-            //
-            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
-            grisu2_round(buffer, length, dist, delta, rest, ten_n);
-
-            return;
-        }
-
-        pow10 /= 10;
-        //
-        //      pow10 = 10^(n-1) <= p1 < 10^n
-        // Invariants restored.
-    }
-
-    // 2)
-    //
-    // The digits of the integral part have been generated:
-    //
-    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
-    //         = buffer            + p2 * 2^e
-    //
-    // Now generate the digits of the fractional part p2 * 2^e.
-    //
-    // Note:
-    // No decimal point is generated: the exponent is adjusted instead.
-    //
-    // p2 actually represents the fraction
-    //
-    //      p2 * 2^e
-    //          = p2 / 2^-e
-    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
-    //
-    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
-    //
-    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
-    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
-    //
-    // using
-    //
-    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
-    //                = (                   d) * 2^-e + (                   r)
-    //
-    // or
-    //      10^m * p2 * 2^e = d + r * 2^e
-    //
-    // i.e.
-    //
-    //      M+ = buffer + p2 * 2^e
-    //         = buffer + 10^-m * (d + r * 2^e)
-    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
-    //
-    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
-
-    JSON_ASSERT(p2 > delta);
-
-    int m = 0;
-    for (;;)
-    {
-        // Invariant:
-        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
-        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
-        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
-        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
-        //
-        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
-        p2 *= 10;
-        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
-        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
-        //
-        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
-        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
-        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
-        //
-        JSON_ASSERT(d <= 9);
-        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
-        //
-        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
-        //
-        p2 = r;
-        m++;
-        //
-        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
-        // Invariant restored.
-
-        // Check if enough digits have been generated.
-        //
-        //      10^-m * p2 * 2^e <= delta * 2^e
-        //              p2 * 2^e <= 10^m * delta * 2^e
-        //                    p2 <= 10^m * delta
-        delta *= 10;
-        dist  *= 10;
-        if (p2 <= delta)
-        {
-            break;
-        }
-    }
-
-    // V = buffer * 10^-m, with M- <= V <= M+.
-
-    decimal_exponent -= m;
-
-    // 1 ulp in the decimal representation is now 10^-m.
-    // Since delta and dist are now scaled by 10^m, we need to do the
-    // same with ulp in order to keep the units in sync.
-    //
-    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
-    //
-    const std::uint64_t ten_m = one.f;
-    grisu2_round(buffer, length, dist, delta, p2, ten_m);
-
-    // By construction this algorithm generates the shortest possible decimal
-    // number (Loitsch, Theorem 6.2) which rounds back to w.
-    // For an input number of precision p, at least
-    //
-    //      N = 1 + ceil(p * log_10(2))
-    //
-    // decimal digits are sufficient to identify all binary floating-point
-    // numbers (Matula, "In-and-Out conversions").
-    // This implies that the algorithm does not produce more than N decimal
-    // digits.
-    //
-    //      N = 17 for p = 53 (IEEE double precision)
-    //      N = 9  for p = 24 (IEEE single precision)
-}
-
-/*!
-v = buf * 10^decimal_exponent
-len is the length of the buffer (number of decimal digits)
-The buffer must be large enough, i.e. >= max_digits10.
-*/
-JSON_HEDLEY_NON_NULL(1)
-inline void grisu2(char* buf, int& len, int& decimal_exponent,
-                   diyfp m_minus, diyfp v, diyfp m_plus)
-{
-    JSON_ASSERT(m_plus.e == m_minus.e);
-    JSON_ASSERT(m_plus.e == v.e);
-
-    //  --------(-----------------------+-----------------------)--------    (A)
-    //          m-                      v                       m+
-    //
-    //  --------------------(-----------+-----------------------)--------    (B)
-    //                      m-          v                       m+
-    //
-    // First scale v (and m- and m+) such that the exponent is in the range
-    // [alpha, gamma].
-
-    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
-
-    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
-
-    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
-    const diyfp w       = diyfp::mul(v,       c_minus_k);
-    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
-    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
-
-    //  ----(---+---)---------------(---+---)---------------(---+---)----
-    //          w-                      w                       w+
-    //          = c*m-                  = c*v                   = c*m+
-    //
-    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
-    // w+ are now off by a small amount.
-    // In fact:
-    //
-    //      w - v * 10^k < 1 ulp
-    //
-    // To account for this inaccuracy, add resp. subtract 1 ulp.
-    //
-    //  --------+---[---------------(---+---)---------------]---+--------
-    //          w-  M-                  w                   M+  w+
-    //
-    // Now any number in [M-, M+] (bounds included) will round to w when input,
-    // regardless of how the input rounding algorithm breaks ties.
-    //
-    // And digit_gen generates the shortest possible such number in [M-, M+].
-    // Note that this does not mean that Grisu2 always generates the shortest
-    // possible number in the interval (m-, m+).
-    const diyfp M_minus(w_minus.f + 1, w_minus.e);
-    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
-
-    decimal_exponent = -cached.k; // = -(-k) = k
-
-    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
-}
-
-/*!
-v = buf * 10^decimal_exponent
-len is the length of the buffer (number of decimal digits)
-The buffer must be large enough, i.e. >= max_digits10.
-*/
-template<typename FloatType>
-JSON_HEDLEY_NON_NULL(1)
-void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
-{
-    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
-                  "internal error: not enough precision");
-
-    JSON_ASSERT(std::isfinite(value));
-    JSON_ASSERT(value > 0);
-
-    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
-    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
-    // decimal representations are not exactly "short".
-    //
-    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
-    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
-    // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
-    // does.
-    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
-    // representation using the corresponding std::from_chars function recovers value exactly". That
-    // indicates that single precision floating-point numbers should be recovered using
-    // 'std::strtof'.
-    //
-    // NB: If the neighbors are computed for single-precision numbers, there is a single float
-    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
-    //     value is off by 1 ulp.
-#if 0
-    const boundaries w = compute_boundaries(static_cast<double>(value));
-#else
-    const boundaries w = compute_boundaries(value);
-#endif
-
-    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
-}
-
-/*!
-@brief appends a decimal representation of e to buf
-@return a pointer to the element following the exponent.
-@pre -1000 < e < 1000
-*/
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
-inline char* append_exponent(char* buf, int e)
-{
-    JSON_ASSERT(e > -1000);
-    JSON_ASSERT(e <  1000);
-
-    if (e < 0)
-    {
-        e = -e;
-        *buf++ = '-';
-    }
-    else
-    {
-        *buf++ = '+';
-    }
-
-    auto k = static_cast<std::uint32_t>(e);
-    if (k < 10)
-    {
-        // Always print at least two digits in the exponent.
-        // This is for compatibility with printf("%g").
-        *buf++ = '0';
-        *buf++ = static_cast<char>('0' + k);
-    }
-    else if (k < 100)
-    {
-        *buf++ = static_cast<char>('0' + k / 10);
-        k %= 10;
-        *buf++ = static_cast<char>('0' + k);
-    }
-    else
-    {
-        *buf++ = static_cast<char>('0' + k / 100);
-        k %= 100;
-        *buf++ = static_cast<char>('0' + k / 10);
-        k %= 10;
-        *buf++ = static_cast<char>('0' + k);
-    }
-
-    return buf;
-}
-
-/*!
-@brief prettify v = buf * 10^decimal_exponent
-
-If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
-notation. Otherwise it will be printed in exponential notation.
-
-@pre min_exp < 0
-@pre max_exp > 0
-*/
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
-inline char* format_buffer(char* buf, int len, int decimal_exponent,
-                           int min_exp, int max_exp)
-{
-    JSON_ASSERT(min_exp < 0);
-    JSON_ASSERT(max_exp > 0);
-
-    const int k = len;
-    const int n = len + decimal_exponent;
-
-    // v = buf * 10^(n-k)
-    // k is the length of the buffer (number of decimal digits)
-    // n is the position of the decimal point relative to the start of the buffer.
-
-    if (k <= n && n <= max_exp)
-    {
-        // digits[000]
-        // len <= max_exp + 2
-
-        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
-        // Make it look like a floating-point number (#362, #378)
-        buf[n + 0] = '.';
-        buf[n + 1] = '0';
-        return buf + (static_cast<size_t>(n) + 2);
-    }
-
-    if (0 < n && n <= max_exp)
-    {
-        // dig.its
-        // len <= max_digits10 + 1
-
-        JSON_ASSERT(k > n);
-
-        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
-        buf[n] = '.';
-        return buf + (static_cast<size_t>(k) + 1U);
-    }
-
-    if (min_exp < n && n <= 0)
-    {
-        // 0.[000]digits
-        // len <= 2 + (-min_exp - 1) + max_digits10
-
-        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
-        buf[0] = '0';
-        buf[1] = '.';
-        std::memset(buf + 2, '0', static_cast<size_t>(-n));
-        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
-    }
-
-    if (k == 1)
-    {
-        // dE+123
-        // len <= 1 + 5
-
-        buf += 1;
-    }
-    else
-    {
-        // d.igitsE+123
-        // len <= max_digits10 + 1 + 5
-
-        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
-        buf[1] = '.';
-        buf += 1 + static_cast<size_t>(k);
-    }
-
-    *buf++ = 'e';
-    return append_exponent(buf, n - 1);
-}
-
-} // namespace dtoa_impl
-
-/*!
-@brief generates a decimal representation of the floating-point number value in [first, last).
-
-The format of the resulting decimal representation is similar to printf's %g
-format. Returns an iterator pointing past-the-end of the decimal representation.
-
-@note The input number must be finite, i.e. NaN's and Inf's are not supported.
-@note The buffer must be large enough.
-@note The result is NOT null-terminated.
-*/
-template<typename FloatType>
-JSON_HEDLEY_NON_NULL(1, 2)
-JSON_HEDLEY_RETURNS_NON_NULL
-char* to_chars(char* first, const char* last, FloatType value)
-{
-    static_cast<void>(last); // maybe unused - fix warning
-    JSON_ASSERT(std::isfinite(value));
-
-    // Use signbit(value) instead of (value < 0) since signbit works for -0.
-    if (std::signbit(value))
-    {
-        value = -value;
-        *first++ = '-';
-    }
-
-    if (value == 0) // +-0
-    {
-        *first++ = '0';
-        // Make it look like a floating-point number (#362, #378)
-        *first++ = '.';
-        *first++ = '0';
-        return first;
-    }
-
-    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
-
-    // Compute v = buffer * 10^decimal_exponent.
-    // The decimal digits are stored in the buffer, which needs to be interpreted
-    // as an unsigned decimal integer.
-    // len is the length of the buffer, i.e. the number of decimal digits.
-    int len = 0;
-    int decimal_exponent = 0;
-    dtoa_impl::grisu2(first, len, decimal_exponent, value);
-
-    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
-
-    // Format the buffer like printf("%.*g", prec, value)
-    constexpr int kMinExp = -4;
-    // Use digits10 here to increase compatibility with version 2.
-    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
-
-    JSON_ASSERT(last - first >= kMaxExp + 2);
-    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
-    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
-
-    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
-}
-
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/output/binary_writer.hpp>
-
-// #include <nlohmann/detail/output/output_adapters.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-///////////////////
-// serialization //
-///////////////////
-
-/// how to treat decoding errors
-enum class error_handler_t
-{
-    strict,  ///< throw a type_error exception in case of invalid UTF-8
-    replace, ///< replace invalid UTF-8 sequences with U+FFFD
-    ignore   ///< ignore invalid UTF-8 sequences
-};
-
-template<typename BasicJsonType>
-class serializer
-{
-    using string_t = typename BasicJsonType::string_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using binary_char_t = typename BasicJsonType::binary_t::value_type;
-    static constexpr std::uint8_t UTF8_ACCEPT = 0;
-    static constexpr std::uint8_t UTF8_REJECT = 1;
-
-  public:
-    /*!
-    @param[in] s  output stream to serialize to
-    @param[in] ichar  indentation character to use
-    @param[in] error_handler_  how to react on decoding errors
-    */
-    serializer(output_adapter_t<char> s, const char ichar,
-               error_handler_t error_handler_ = error_handler_t::strict)
-        : o(std::move(s))
-        , loc(std::localeconv())
-        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
-        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
-        , indent_char(ichar)
-        , indent_string(512, indent_char)
-        , error_handler(error_handler_)
-    {}
-
-    // delete because of pointer members
-    serializer(const serializer&) = delete;
-    serializer& operator=(const serializer&) = delete;
-    serializer(serializer&&) = delete;
-    serializer& operator=(serializer&&) = delete;
-    ~serializer() = default;
-
-    /*!
-    @brief internal implementation of the serialization function
-
-    This function is called by the public member function dump and organizes
-    the serialization internally. The indentation level is propagated as
-    additional parameter. In case of arrays and objects, the function is
-    called recursively.
-
-    - strings and object keys are escaped using `escape_string()`
-    - integer numbers are converted implicitly via `operator<<`
-    - floating-point numbers are converted to a string using `"%g"` format
-    - binary values are serialized as objects containing the subtype and the
-      byte array
-
-    @param[in] val               value to serialize
-    @param[in] pretty_print      whether the output shall be pretty-printed
-    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
-    in the output are escaped with `\uXXXX` sequences, and the result consists
-    of ASCII characters only.
-    @param[in] indent_step       the indent level
-    @param[in] current_indent    the current indent level (only used internally)
-    */
-    void dump(const BasicJsonType& val,
-              const bool pretty_print,
-              const bool ensure_ascii,
-              const unsigned int indent_step,
-              const unsigned int current_indent = 0)
-    {
-        switch (val.m_type)
-        {
-            case value_t::object:
-            {
-                if (val.m_value.object->empty())
-                {
-                    o->write_characters("{}", 2);
-                    return;
-                }
-
-                if (pretty_print)
-                {
-                    o->write_characters("{\n", 2);
-
-                    // variable to hold indentation for recursive calls
-                    const auto new_indent = current_indent + indent_step;
-                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
-                    {
-                        indent_string.resize(indent_string.size() * 2, ' ');
-                    }
-
-                    // first n-1 elements
-                    auto i = val.m_value.object->cbegin();
-                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
-                    {
-                        o->write_characters(indent_string.c_str(), new_indent);
-                        o->write_character('\"');
-                        dump_escaped(i->first, ensure_ascii);
-                        o->write_characters("\": ", 3);
-                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
-                        o->write_characters(",\n", 2);
-                    }
-
-                    // last element
-                    JSON_ASSERT(i != val.m_value.object->cend());
-                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
-                    o->write_characters(indent_string.c_str(), new_indent);
-                    o->write_character('\"');
-                    dump_escaped(i->first, ensure_ascii);
-                    o->write_characters("\": ", 3);
-                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
-
-                    o->write_character('\n');
-                    o->write_characters(indent_string.c_str(), current_indent);
-                    o->write_character('}');
-                }
-                else
-                {
-                    o->write_character('{');
-
-                    // first n-1 elements
-                    auto i = val.m_value.object->cbegin();
-                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
-                    {
-                        o->write_character('\"');
-                        dump_escaped(i->first, ensure_ascii);
-                        o->write_characters("\":", 2);
-                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
-                        o->write_character(',');
-                    }
-
-                    // last element
-                    JSON_ASSERT(i != val.m_value.object->cend());
-                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
-                    o->write_character('\"');
-                    dump_escaped(i->first, ensure_ascii);
-                    o->write_characters("\":", 2);
-                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
-
-                    o->write_character('}');
-                }
-
-                return;
-            }
-
-            case value_t::array:
-            {
-                if (val.m_value.array->empty())
-                {
-                    o->write_characters("[]", 2);
-                    return;
-                }
-
-                if (pretty_print)
-                {
-                    o->write_characters("[\n", 2);
-
-                    // variable to hold indentation for recursive calls
-                    const auto new_indent = current_indent + indent_step;
-                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
-                    {
-                        indent_string.resize(indent_string.size() * 2, ' ');
-                    }
-
-                    // first n-1 elements
-                    for (auto i = val.m_value.array->cbegin();
-                            i != val.m_value.array->cend() - 1; ++i)
-                    {
-                        o->write_characters(indent_string.c_str(), new_indent);
-                        dump(*i, true, ensure_ascii, indent_step, new_indent);
-                        o->write_characters(",\n", 2);
-                    }
-
-                    // last element
-                    JSON_ASSERT(!val.m_value.array->empty());
-                    o->write_characters(indent_string.c_str(), new_indent);
-                    dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
-
-                    o->write_character('\n');
-                    o->write_characters(indent_string.c_str(), current_indent);
-                    o->write_character(']');
-                }
-                else
-                {
-                    o->write_character('[');
-
-                    // first n-1 elements
-                    for (auto i = val.m_value.array->cbegin();
-                            i != val.m_value.array->cend() - 1; ++i)
-                    {
-                        dump(*i, false, ensure_ascii, indent_step, current_indent);
-                        o->write_character(',');
-                    }
-
-                    // last element
-                    JSON_ASSERT(!val.m_value.array->empty());
-                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
-
-                    o->write_character(']');
-                }
-
-                return;
-            }
-
-            case value_t::string:
-            {
-                o->write_character('\"');
-                dump_escaped(*val.m_value.string, ensure_ascii);
-                o->write_character('\"');
-                return;
-            }
-
-            case value_t::binary:
-            {
-                if (pretty_print)
-                {
-                    o->write_characters("{\n", 2);
-
-                    // variable to hold indentation for recursive calls
-                    const auto new_indent = current_indent + indent_step;
-                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
-                    {
-                        indent_string.resize(indent_string.size() * 2, ' ');
-                    }
-
-                    o->write_characters(indent_string.c_str(), new_indent);
-
-                    o->write_characters("\"bytes\": [", 10);
-
-                    if (!val.m_value.binary->empty())
-                    {
-                        for (auto i = val.m_value.binary->cbegin();
-                                i != val.m_value.binary->cend() - 1; ++i)
-                        {
-                            dump_integer(*i);
-                            o->write_characters(", ", 2);
-                        }
-                        dump_integer(val.m_value.binary->back());
-                    }
-
-                    o->write_characters("],\n", 3);
-                    o->write_characters(indent_string.c_str(), new_indent);
-
-                    o->write_characters("\"subtype\": ", 11);
-                    if (val.m_value.binary->has_subtype())
-                    {
-                        dump_integer(val.m_value.binary->subtype());
-                    }
-                    else
-                    {
-                        o->write_characters("null", 4);
-                    }
-                    o->write_character('\n');
-                    o->write_characters(indent_string.c_str(), current_indent);
-                    o->write_character('}');
-                }
-                else
-                {
-                    o->write_characters("{\"bytes\":[", 10);
-
-                    if (!val.m_value.binary->empty())
-                    {
-                        for (auto i = val.m_value.binary->cbegin();
-                                i != val.m_value.binary->cend() - 1; ++i)
-                        {
-                            dump_integer(*i);
-                            o->write_character(',');
-                        }
-                        dump_integer(val.m_value.binary->back());
-                    }
-
-                    o->write_characters("],\"subtype\":", 12);
-                    if (val.m_value.binary->has_subtype())
-                    {
-                        dump_integer(val.m_value.binary->subtype());
-                        o->write_character('}');
-                    }
-                    else
-                    {
-                        o->write_characters("null}", 5);
-                    }
-                }
-                return;
-            }
-
-            case value_t::boolean:
-            {
-                if (val.m_value.boolean)
-                {
-                    o->write_characters("true", 4);
-                }
-                else
-                {
-                    o->write_characters("false", 5);
-                }
-                return;
-            }
-
-            case value_t::number_integer:
-            {
-                dump_integer(val.m_value.number_integer);
-                return;
-            }
-
-            case value_t::number_unsigned:
-            {
-                dump_integer(val.m_value.number_unsigned);
-                return;
-            }
-
-            case value_t::number_float:
-            {
-                dump_float(val.m_value.number_float);
-                return;
-            }
-
-            case value_t::discarded:
-            {
-                o->write_characters("<discarded>", 11);
-                return;
-            }
-
-            case value_t::null:
-            {
-                o->write_characters("null", 4);
-                return;
-            }
-
-            default:            // LCOV_EXCL_LINE
-                JSON_ASSERT(false);  // LCOV_EXCL_LINE
-        }
-    }
-
-  private:
-    /*!
-    @brief dump escaped string
-
-    Escape a string by replacing certain special characters by a sequence of an
-    escape character (backslash) and another character and other control
-    characters by a sequence of "\u" followed by a four-digit hex
-    representation. The escaped string is written to output stream @a o.
-
-    @param[in] s  the string to escape
-    @param[in] ensure_ascii  whether to escape non-ASCII characters with
-                             \uXXXX sequences
-
-    @complexity Linear in the length of string @a s.
-    */
-    void dump_escaped(const string_t& s, const bool ensure_ascii)
-    {
-        std::uint32_t codepoint;
-        std::uint8_t state = UTF8_ACCEPT;
-        std::size_t bytes = 0;  // number of bytes written to string_buffer
-
-        // number of bytes written at the point of the last valid byte
-        std::size_t bytes_after_last_accept = 0;
-        std::size_t undumped_chars = 0;
-
-        for (std::size_t i = 0; i < s.size(); ++i)
-        {
-            const auto byte = static_cast<uint8_t>(s[i]);
-
-            switch (decode(state, codepoint, byte))
-            {
-                case UTF8_ACCEPT:  // decode found a new code point
-                {
-                    switch (codepoint)
-                    {
-                        case 0x08: // backspace
-                        {
-                            string_buffer[bytes++] = '\\';
-                            string_buffer[bytes++] = 'b';
-                            break;
-                        }
-
-                        case 0x09: // horizontal tab
-                        {
-                            string_buffer[bytes++] = '\\';
-                            string_buffer[bytes++] = 't';
-                            break;
-                        }
-
-                        case 0x0A: // newline
-                        {
-                            string_buffer[bytes++] = '\\';
-                            string_buffer[bytes++] = 'n';
-                            break;
-                        }
-
-                        case 0x0C: // formfeed
-                        {
-                            string_buffer[bytes++] = '\\';
-                            string_buffer[bytes++] = 'f';
-                            break;
-                        }
-
-                        case 0x0D: // carriage return
-                        {
-                            string_buffer[bytes++] = '\\';
-                            string_buffer[bytes++] = 'r';
-                            break;
-                        }
-
-                        case 0x22: // quotation mark
-                        {
-                            string_buffer[bytes++] = '\\';
-                            string_buffer[bytes++] = '\"';
-                            break;
-                        }
-
-                        case 0x5C: // reverse solidus
-                        {
-                            string_buffer[bytes++] = '\\';
-                            string_buffer[bytes++] = '\\';
-                            break;
-                        }
-
-                        default:
-                        {
-                            // escape control characters (0x00..0x1F) or, if
-                            // ensure_ascii parameter is used, non-ASCII characters
-                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
-                            {
-                                if (codepoint <= 0xFFFF)
-                                {
-                                    (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
-                                                    static_cast<std::uint16_t>(codepoint));
-                                    bytes += 6;
-                                }
-                                else
-                                {
-                                    (std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
-                                                    static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
-                                                    static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
-                                    bytes += 12;
-                                }
-                            }
-                            else
-                            {
-                                // copy byte to buffer (all previous bytes
-                                // been copied have in default case above)
-                                string_buffer[bytes++] = s[i];
-                            }
-                            break;
-                        }
-                    }
-
-                    // write buffer and reset index; there must be 13 bytes
-                    // left, as this is the maximal number of bytes to be
-                    // written ("\uxxxx\uxxxx\0") for one code point
-                    if (string_buffer.size() - bytes < 13)
-                    {
-                        o->write_characters(string_buffer.data(), bytes);
-                        bytes = 0;
-                    }
-
-                    // remember the byte position of this accept
-                    bytes_after_last_accept = bytes;
-                    undumped_chars = 0;
-                    break;
-                }
-
-                case UTF8_REJECT:  // decode found invalid UTF-8 byte
-                {
-                    switch (error_handler)
-                    {
-                        case error_handler_t::strict:
-                        {
-                            std::string sn(3, '\0');
-                            (std::snprintf)(&sn[0], sn.size(), "%.2X", byte);
-                            JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
-                        }
-
-                        case error_handler_t::ignore:
-                        case error_handler_t::replace:
-                        {
-                            // in case we saw this character the first time, we
-                            // would like to read it again, because the byte
-                            // may be OK for itself, but just not OK for the
-                            // previous sequence
-                            if (undumped_chars > 0)
-                            {
-                                --i;
-                            }
-
-                            // reset length buffer to the last accepted index;
-                            // thus removing/ignoring the invalid characters
-                            bytes = bytes_after_last_accept;
-
-                            if (error_handler == error_handler_t::replace)
-                            {
-                                // add a replacement character
-                                if (ensure_ascii)
-                                {
-                                    string_buffer[bytes++] = '\\';
-                                    string_buffer[bytes++] = 'u';
-                                    string_buffer[bytes++] = 'f';
-                                    string_buffer[bytes++] = 'f';
-                                    string_buffer[bytes++] = 'f';
-                                    string_buffer[bytes++] = 'd';
-                                }
-                                else
-                                {
-                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
-                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
-                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
-                                }
-
-                                // write buffer and reset index; there must be 13 bytes
-                                // left, as this is the maximal number of bytes to be
-                                // written ("\uxxxx\uxxxx\0") for one code point
-                                if (string_buffer.size() - bytes < 13)
-                                {
-                                    o->write_characters(string_buffer.data(), bytes);
-                                    bytes = 0;
-                                }
-
-                                bytes_after_last_accept = bytes;
-                            }
-
-                            undumped_chars = 0;
-
-                            // continue processing the string
-                            state = UTF8_ACCEPT;
-                            break;
-                        }
-
-                        default:            // LCOV_EXCL_LINE
-                            JSON_ASSERT(false);  // LCOV_EXCL_LINE
-                    }
-                    break;
-                }
-
-                default:  // decode found yet incomplete multi-byte code point
-                {
-                    if (!ensure_ascii)
-                    {
-                        // code point will not be escaped - copy byte to buffer
-                        string_buffer[bytes++] = s[i];
-                    }
-                    ++undumped_chars;
-                    break;
-                }
-            }
-        }
-
-        // we finished processing the string
-        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
-        {
-            // write buffer
-            if (bytes > 0)
-            {
-                o->write_characters(string_buffer.data(), bytes);
-            }
-        }
-        else
-        {
-            // we finish reading, but do not accept: string was incomplete
-            switch (error_handler)
-            {
-                case error_handler_t::strict:
-                {
-                    std::string sn(3, '\0');
-                    (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
-                    JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
-                }
-
-                case error_handler_t::ignore:
-                {
-                    // write all accepted bytes
-                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
-                    break;
-                }
-
-                case error_handler_t::replace:
-                {
-                    // write all accepted bytes
-                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
-                    // add a replacement character
-                    if (ensure_ascii)
-                    {
-                        o->write_characters("\\ufffd", 6);
-                    }
-                    else
-                    {
-                        o->write_characters("\xEF\xBF\xBD", 3);
-                    }
-                    break;
-                }
-
-                default:            // LCOV_EXCL_LINE
-                    JSON_ASSERT(false);  // LCOV_EXCL_LINE
-            }
-        }
-    }
-
-    /*!
-    @brief count digits
-
-    Count the number of decimal (base 10) digits for an input unsigned integer.
-
-    @param[in] x  unsigned integer number to count its digits
-    @return    number of decimal digits
-    */
-    inline unsigned int count_digits(number_unsigned_t x) noexcept
-    {
-        unsigned int n_digits = 1;
-        for (;;)
-        {
-            if (x < 10)
-            {
-                return n_digits;
-            }
-            if (x < 100)
-            {
-                return n_digits + 1;
-            }
-            if (x < 1000)
-            {
-                return n_digits + 2;
-            }
-            if (x < 10000)
-            {
-                return n_digits + 3;
-            }
-            x = x / 10000u;
-            n_digits += 4;
-        }
-    }
-
-    /*!
-    @brief dump an integer
-
-    Dump a given integer to output stream @a o. Works internally with
-    @a number_buffer.
-
-    @param[in] x  integer number (signed or unsigned) to dump
-    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
-    */
-    template < typename NumberType, detail::enable_if_t <
-                   std::is_same<NumberType, number_unsigned_t>::value ||
-                   std::is_same<NumberType, number_integer_t>::value ||
-                   std::is_same<NumberType, binary_char_t>::value,
-                   int > = 0 >
-    void dump_integer(NumberType x)
-    {
-        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
-        {
-            {
-                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
-                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
-                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
-                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
-                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
-                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
-                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
-                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
-                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
-                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
-            }
-        };
-
-        // special case for "0"
-        if (x == 0)
-        {
-            o->write_character('0');
-            return;
-        }
-
-        // use a pointer to fill the buffer
-        auto buffer_ptr = number_buffer.begin();
-
-        const bool is_negative = std::is_same<NumberType, number_integer_t>::value && !(x >= 0); // see issue #755
-        number_unsigned_t abs_value;
-
-        unsigned int n_chars;
-
-        if (is_negative)
-        {
-            *buffer_ptr = '-';
-            abs_value = remove_sign(static_cast<number_integer_t>(x));
-
-            // account one more byte for the minus sign
-            n_chars = 1 + count_digits(abs_value);
-        }
-        else
-        {
-            abs_value = static_cast<number_unsigned_t>(x);
-            n_chars = count_digits(abs_value);
-        }
-
-        // spare 1 byte for '\0'
-        JSON_ASSERT(n_chars < number_buffer.size() - 1);
-
-        // jump to the end to generate the string from backward
-        // so we later avoid reversing the result
-        buffer_ptr += n_chars;
-
-        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
-        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
-        while (abs_value >= 100)
-        {
-            const auto digits_index = static_cast<unsigned>((abs_value % 100));
-            abs_value /= 100;
-            *(--buffer_ptr) = digits_to_99[digits_index][1];
-            *(--buffer_ptr) = digits_to_99[digits_index][0];
-        }
-
-        if (abs_value >= 10)
-        {
-            const auto digits_index = static_cast<unsigned>(abs_value);
-            *(--buffer_ptr) = digits_to_99[digits_index][1];
-            *(--buffer_ptr) = digits_to_99[digits_index][0];
-        }
-        else
-        {
-            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
-        }
-
-        o->write_characters(number_buffer.data(), n_chars);
-    }
-
-    /*!
-    @brief dump a floating-point number
-
-    Dump a given floating-point number to output stream @a o. Works internally
-    with @a number_buffer.
-
-    @param[in] x  floating-point number to dump
-    */
-    void dump_float(number_float_t x)
-    {
-        // NaN / inf
-        if (!std::isfinite(x))
-        {
-            o->write_characters("null", 4);
-            return;
-        }
-
-        // If number_float_t is an IEEE-754 single or double precision number,
-        // use the Grisu2 algorithm to produce short numbers which are
-        // guaranteed to round-trip, using strtof and strtod, resp.
-        //
-        // NB: The test below works if <long double> == <double>.
-        static constexpr bool is_ieee_single_or_double
-            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
-              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
-
-        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
-    }
-
-    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
-    {
-        char* begin = number_buffer.data();
-        char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
-
-        o->write_characters(begin, static_cast<size_t>(end - begin));
-    }
-
-    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
-    {
-        // get number of digits for a float -> text -> float round-trip
-        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
-
-        // the actual conversion
-        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
-
-        // negative value indicates an error
-        JSON_ASSERT(len > 0);
-        // check if buffer was large enough
-        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
-
-        // erase thousands separator
-        if (thousands_sep != '\0')
-        {
-            const auto end = std::remove(number_buffer.begin(),
-                                         number_buffer.begin() + len, thousands_sep);
-            std::fill(end, number_buffer.end(), '\0');
-            JSON_ASSERT((end - number_buffer.begin()) <= len);
-            len = (end - number_buffer.begin());
-        }
-
-        // convert decimal point to '.'
-        if (decimal_point != '\0' && decimal_point != '.')
-        {
-            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
-            if (dec_pos != number_buffer.end())
-            {
-                *dec_pos = '.';
-            }
-        }
-
-        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
-
-        // determine if need to append ".0"
-        const bool value_is_int_like =
-            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
-                         [](char c)
-        {
-            return c == '.' || c == 'e';
-        });
-
-        if (value_is_int_like)
-        {
-            o->write_characters(".0", 2);
-        }
-    }
-
-    /*!
-    @brief check whether a string is UTF-8 encoded
-
-    The function checks each byte of a string whether it is UTF-8 encoded. The
-    result of the check is stored in the @a state parameter. The function must
-    be called initially with state 0 (accept). State 1 means the string must
-    be rejected, because the current byte is not allowed. If the string is
-    completely processed, but the state is non-zero, the string ended
-    prematurely; that is, the last byte indicated more bytes should have
-    followed.
-
-    @param[in,out] state  the state of the decoding
-    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
-    @param[in] byte       next byte to decode
-    @return               new state
-
-    @note The function has been edited: a std::array is used.
-
-    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-    */
-    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
-    {
-        static const std::array<std::uint8_t, 400> utf8d =
-        {
-            {
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
-                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
-                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
-                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
-                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
-                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
-                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
-                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
-                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
-                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
-                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
-            }
-        };
-
-        const std::uint8_t type = utf8d[byte];
-
-        codep = (state != UTF8_ACCEPT)
-                ? (byte & 0x3fu) | (codep << 6u)
-                : (0xFFu >> type) & (byte);
-
-        std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
-        JSON_ASSERT(index < 400);
-        state = utf8d[index];
-        return state;
-    }
-
-    /*
-     * Overload to make the compiler happy while it is instantiating
-     * dump_integer for number_unsigned_t.
-     * Must never be called.
-     */
-    number_unsigned_t remove_sign(number_unsigned_t x)
-    {
-        JSON_ASSERT(false); // LCOV_EXCL_LINE
-        return x; // LCOV_EXCL_LINE
-    }
-
-    /*
-     * Helper function for dump_integer
-     *
-     * This function takes a negative signed integer and returns its absolute
-     * value as unsigned integer. The plus/minus shuffling is necessary as we can
-     * not directly remove the sign of an arbitrary signed integer as the
-     * absolute values of INT_MIN and INT_MAX are usually not the same. See
-     * #1708 for details.
-     */
-    inline number_unsigned_t remove_sign(number_integer_t x) noexcept
-    {
-        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
-        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
-    }
-
-  private:
-    /// the output of the serializer
-    output_adapter_t<char> o = nullptr;
-
-    /// a (hopefully) large enough character buffer
-    std::array<char, 64> number_buffer{{}};
-
-    /// the locale
-    const std::lconv* loc = nullptr;
-    /// the locale's thousand separator character
-    const char thousands_sep = '\0';
-    /// the locale's decimal point character
-    const char decimal_point = '\0';
-
-    /// string buffer
-    std::array<char, 512> string_buffer{{}};
-
-    /// the indentation character
-    const char indent_char;
-    /// the indentation string
-    string_t indent_string;
-
-    /// error_handler how to react on decoding errors
-    const error_handler_t error_handler;
-};
-}  // namespace detail
-}  // namespace nlohmann
-
-// #include <nlohmann/detail/value_t.hpp>
-
-// #include <nlohmann/json_fwd.hpp>
-
-// #include <nlohmann/ordered_map.hpp>
-
-
-#include <functional> // less
-#include <memory> // allocator
-#include <utility> // pair
-#include <vector> // vector
-
-namespace nlohmann
-{
-
-/// ordered_map: a minimal map-like container that preserves insertion order
-/// for use within nlohmann::basic_json<ordered_map>
-template <class Key, class T, class IgnoredLess = std::less<Key>,
-          class Allocator = std::allocator<std::pair<const Key, T>>>
-                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
-{
-    using key_type = Key;
-    using mapped_type = T;
-    using Container = std::vector<std::pair<const Key, T>, Allocator>;
-    using typename Container::iterator;
-    using typename Container::const_iterator;
-    using typename Container::size_type;
-    using typename Container::value_type;
-
-    // Explicit constructors instead of `using Container::Container`
-    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
-    ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
-    template <class It>
-    ordered_map(It first, It last, const Allocator& alloc = Allocator())
-        : Container{first, last, alloc} {}
-    ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
-        : Container{init, alloc} {}
-
-    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
-    {
-        for (auto it = this->begin(); it != this->end(); ++it)
-        {
-            if (it->first == key)
-            {
-                return {it, false};
-            }
-        }
-        Container::emplace_back(key, t);
-        return {--this->end(), true};
-    }
-
-    T& operator[](const Key& key)
-    {
-        return emplace(key, T{}).first->second;
-    }
-
-    const T& operator[](const Key& key) const
-    {
-        return at(key);
-    }
-
-    T& at(const Key& key)
-    {
-        for (auto it = this->begin(); it != this->end(); ++it)
-        {
-            if (it->first == key)
-            {
-                return it->second;
-            }
-        }
-
-        throw std::out_of_range("key not found");
-    }
-
-    const T& at(const Key& key) const
-    {
-        for (auto it = this->begin(); it != this->end(); ++it)
-        {
-            if (it->first == key)
-            {
-                return it->second;
-            }
-        }
-
-        throw std::out_of_range("key not found");
-    }
-
-    size_type erase(const Key& key)
-    {
-        for (auto it = this->begin(); it != this->end(); ++it)
-        {
-            if (it->first == key)
-            {
-                // Since we cannot move const Keys, re-construct them in place
-                for (auto next = it; ++next != this->end(); ++it)
-                {
-                    it->~value_type(); // Destroy but keep allocation
-                    new (&*it) value_type{std::move(*next)};
-                }
-                Container::pop_back();
-                return 1;
-            }
-        }
-        return 0;
-    }
-
-    iterator erase(iterator pos)
-    {
-        auto it = pos;
-
-        // Since we cannot move const Keys, re-construct them in place
-        for (auto next = it; ++next != this->end(); ++it)
-        {
-            it->~value_type(); // Destroy but keep allocation
-            new (&*it) value_type{std::move(*next)};
-        }
-        Container::pop_back();
-        return pos;
-    }
-
-    size_type count(const Key& key) const
-    {
-        for (auto it = this->begin(); it != this->end(); ++it)
-        {
-            if (it->first == key)
-            {
-                return 1;
-            }
-        }
-        return 0;
-    }
-
-    iterator find(const Key& key)
-    {
-        for (auto it = this->begin(); it != this->end(); ++it)
-        {
-            if (it->first == key)
-            {
-                return it;
-            }
-        }
-        return Container::end();
-    }
-
-    const_iterator find(const Key& key) const
-    {
-        for (auto it = this->begin(); it != this->end(); ++it)
-        {
-            if (it->first == key)
-            {
-                return it;
-            }
-        }
-        return Container::end();
-    }
-
-    std::pair<iterator, bool> insert( value_type&& value )
-    {
-        return emplace(value.first, std::move(value.second));
-    }
-
-    std::pair<iterator, bool> insert( const value_type& value )
-    {
-        for (auto it = this->begin(); it != this->end(); ++it)
-        {
-            if (it->first == value.first)
-            {
-                return {it, false};
-            }
-        }
-        Container::push_back(value);
-        return {--this->end(), true};
-    }
-};
-
-}  // namespace nlohmann
-
-
-/*!
-@brief namespace for Niels Lohmann
-@see https://github.com/nlohmann
-@since version 1.0.0
-*/
-namespace nlohmann
-{
-
-/*!
-@brief a class to store JSON values
-
-@tparam ObjectType type for JSON objects (`std::map` by default; will be used
-in @ref object_t)
-@tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
-in @ref array_t)
-@tparam StringType type for JSON strings and object keys (`std::string` by
-default; will be used in @ref string_t)
-@tparam BooleanType type for JSON booleans (`bool` by default; will be used
-in @ref boolean_t)
-@tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
-default; will be used in @ref number_integer_t)
-@tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
-`uint64_t` by default; will be used in @ref number_unsigned_t)
-@tparam NumberFloatType type for JSON floating-point numbers (`double` by
-default; will be used in @ref number_float_t)
-@tparam BinaryType type for packed binary data for compatibility with binary
-serialization formats (`std::vector<std::uint8_t>` by default; will be used in
-@ref binary_t)
-@tparam AllocatorType type of the allocator to use (`std::allocator` by
-default)
-@tparam JSONSerializer the serializer to resolve internal calls to `to_json()`
-and `from_json()` (@ref adl_serializer by default)
-
-@requirement The class satisfies the following concept requirements:
-- Basic
- - [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible):
-   JSON values can be default constructed. The result will be a JSON null
-   value.
- - [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible):
-   A JSON value can be constructed from an rvalue argument.
- - [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible):
-   A JSON value can be copy-constructed from an lvalue expression.
- - [MoveAssignable](https://en.cppreference.com/w/cpp/named_req/MoveAssignable):
-   A JSON value van be assigned from an rvalue argument.
- - [CopyAssignable](https://en.cppreference.com/w/cpp/named_req/CopyAssignable):
-   A JSON value can be copy-assigned from an lvalue expression.
- - [Destructible](https://en.cppreference.com/w/cpp/named_req/Destructible):
-   JSON values can be destructed.
-- Layout
- - [StandardLayoutType](https://en.cppreference.com/w/cpp/named_req/StandardLayoutType):
-   JSON values have
-   [standard layout](https://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
-   All non-static data members are private and standard layout types, the
-   class has no virtual functions or (virtual) base classes.
-- Library-wide
- - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable):
-   JSON values can be compared with `==`, see @ref
-   operator==(const_reference,const_reference).
- - [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable):
-   JSON values can be compared with `<`, see @ref
-   operator<(const_reference,const_reference).
- - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable):
-   Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
-   other compatible types, using unqualified function call @ref swap().
- - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer):
-   JSON values can be compared against `std::nullptr_t` objects which are used
-   to model the `null` value.
-- Container
- - [Container](https://en.cppreference.com/w/cpp/named_req/Container):
-   JSON values can be used like STL containers and provide iterator access.
- - [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer);
-   JSON values can be used like STL containers and provide reverse iterator
-   access.
-
-@invariant The member variables @a m_value and @a m_type have the following
-relationship:
-- If `m_type == value_t::object`, then `m_value.object != nullptr`.
-- If `m_type == value_t::array`, then `m_value.array != nullptr`.
-- If `m_type == value_t::string`, then `m_value.string != nullptr`.
-The invariants are checked by member function assert_invariant().
-
-@internal
-@note ObjectType trick from https://stackoverflow.com/a/9860911
-@endinternal
-
-@see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
-Format](http://rfc7159.net/rfc7159)
-
-@since version 1.0.0
-
-@nosubgrouping
-*/
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-class basic_json
-{
-  private:
-    template<detail::value_t> friend struct detail::external_constructor;
-    friend ::nlohmann::json_pointer<basic_json>;
-
-    template<typename BasicJsonType, typename InputType>
-    friend class ::nlohmann::detail::parser;
-    friend ::nlohmann::detail::serializer<basic_json>;
-    template<typename BasicJsonType>
-    friend class ::nlohmann::detail::iter_impl;
-    template<typename BasicJsonType, typename CharType>
-    friend class ::nlohmann::detail::binary_writer;
-    template<typename BasicJsonType, typename InputType, typename SAX>
-    friend class ::nlohmann::detail::binary_reader;
-    template<typename BasicJsonType>
-    friend class ::nlohmann::detail::json_sax_dom_parser;
-    template<typename BasicJsonType>
-    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
-
-    /// workaround type for MSVC
-    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
-
-    // convenience aliases for types residing in namespace detail;
-    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
-
-    template<typename InputAdapterType>
-    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
-        InputAdapterType adapter,
-        detail::parser_callback_t<basic_json>cb = nullptr,
-        const bool allow_exceptions = true,
-        const bool ignore_comments = false
-                                 )
-    {
-        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
-                std::move(cb), allow_exceptions, ignore_comments);
-    }
-
-    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
-    template<typename BasicJsonType>
-    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
-    template<typename BasicJsonType>
-    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
-    template<typename Iterator>
-    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
-    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
-
-    template<typename CharType>
-    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
-
-    template<typename InputType>
-    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
-    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
-
-    using serializer = ::nlohmann::detail::serializer<basic_json>;
-
-  public:
-    using value_t = detail::value_t;
-    /// JSON Pointer, see @ref nlohmann::json_pointer
-    using json_pointer = ::nlohmann::json_pointer<basic_json>;
-    template<typename T, typename SFINAE>
-    using json_serializer = JSONSerializer<T, SFINAE>;
-    /// how to treat decoding errors
-    using error_handler_t = detail::error_handler_t;
-    /// how to treat CBOR tags
-    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
-    /// helper type for initializer lists of basic_json values
-    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
-
-    using input_format_t = detail::input_format_t;
-    /// SAX interface type, see @ref nlohmann::json_sax
-    using json_sax_t = json_sax<basic_json>;
-
-    ////////////////
-    // exceptions //
-    ////////////////
-
-    /// @name exceptions
-    /// Classes to implement user-defined exceptions.
-    /// @{
-
-    /// @copydoc detail::exception
-    using exception = detail::exception;
-    /// @copydoc detail::parse_error
-    using parse_error = detail::parse_error;
-    /// @copydoc detail::invalid_iterator
-    using invalid_iterator = detail::invalid_iterator;
-    /// @copydoc detail::type_error
-    using type_error = detail::type_error;
-    /// @copydoc detail::out_of_range
-    using out_of_range = detail::out_of_range;
-    /// @copydoc detail::other_error
-    using other_error = detail::other_error;
-
-    /// @}
-
-
-    /////////////////////
-    // container types //
-    /////////////////////
-
-    /// @name container types
-    /// The canonic container types to use @ref basic_json like any other STL
-    /// container.
-    /// @{
-
-    /// the type of elements in a basic_json container
-    using value_type = basic_json;
-
-    /// the type of an element reference
-    using reference = value_type&;
-    /// the type of an element const reference
-    using const_reference = const value_type&;
-
-    /// a type to represent differences between iterators
-    using difference_type = std::ptrdiff_t;
-    /// a type to represent container sizes
-    using size_type = std::size_t;
-
-    /// the allocator type
-    using allocator_type = AllocatorType<basic_json>;
-
-    /// the type of an element pointer
-    using pointer = typename std::allocator_traits<allocator_type>::pointer;
-    /// the type of an element const pointer
-    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
-
-    /// an iterator for a basic_json container
-    using iterator = iter_impl<basic_json>;
-    /// a const iterator for a basic_json container
-    using const_iterator = iter_impl<const basic_json>;
-    /// a reverse iterator for a basic_json container
-    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
-    /// a const reverse iterator for a basic_json container
-    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
-
-    /// @}
-
-
-    /*!
-    @brief returns the allocator associated with the container
-    */
-    static allocator_type get_allocator()
-    {
-        return allocator_type();
-    }
-
-    /*!
-    @brief returns version information on the library
-
-    This function returns a JSON object with information about the library,
-    including the version number and information on the platform and compiler.
-
-    @return JSON object holding version information
-    key         | description
-    ----------- | ---------------
-    `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
-    `copyright` | The copyright line for the library as string.
-    `name`      | The name of the library as string.
-    `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
-    `url`       | The URL of the project as string.
-    `version`   | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
-
-    @liveexample{The following code shows an example output of the `meta()`
-    function.,meta}
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @complexity Constant.
-
-    @since 2.1.0
-    */
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json meta()
-    {
-        basic_json result;
-
-        result["copyright"] = "(C) 2013-2020 Niels Lohmann";
-        result["name"] = "JSON for Modern C++";
-        result["url"] = "https://github.com/nlohmann/json";
-        result["version"]["string"] =
-            std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
-            std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
-            std::to_string(NLOHMANN_JSON_VERSION_PATCH);
-        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
-        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
-        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
-
-#ifdef _WIN32
-        result["platform"] = "win32";
-#elif defined __linux__
-        result["platform"] = "linux";
-#elif defined __APPLE__
-        result["platform"] = "apple";
-#elif defined __unix__
-        result["platform"] = "unix";
-#else
-        result["platform"] = "unknown";
-#endif
-
-#if defined(__ICC) || defined(__INTEL_COMPILER)
-        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
-#elif defined(__clang__)
-        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
-#elif defined(__GNUC__) || defined(__GNUG__)
-        result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
-#elif defined(__HP_cc) || defined(__HP_aCC)
-        result["compiler"] = "hp"
-#elif defined(__IBMCPP__)
-        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
-#elif defined(_MSC_VER)
-        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
-#elif defined(__PGI)
-        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
-#elif defined(__SUNPRO_CC)
-        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
-#else
-        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
-#endif
-
-#ifdef __cplusplus
-        result["compiler"]["c++"] = std::to_string(__cplusplus);
-#else
-        result["compiler"]["c++"] = "unknown";
-#endif
-        return result;
-    }
-
-
-    ///////////////////////////
-    // JSON value data types //
-    ///////////////////////////
-
-    /// @name JSON value data types
-    /// The data types to store a JSON value. These types are derived from
-    /// the template arguments passed to class @ref basic_json.
-    /// @{
-
-#if defined(JSON_HAS_CPP_14)
-    // Use transparent comparator if possible, combined with perfect forwarding
-    // on find() and count() calls prevents unnecessary string construction.
-    using object_comparator_t = std::less<>;
-#else
-    using object_comparator_t = std::less<StringType>;
-#endif
-
-    /*!
-    @brief a type for an object
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
-    > An object is an unordered collection of zero or more name/value pairs,
-    > where a name is a string and a value is a string, number, boolean, null,
-    > object, or array.
-
-    To store objects in C++, a type is defined by the template parameters
-    described below.
-
-    @tparam ObjectType  the container to store objects (e.g., `std::map` or
-    `std::unordered_map`)
-    @tparam StringType the type of the keys or names (e.g., `std::string`).
-    The comparison function `std::less<StringType>` is used to order elements
-    inside the container.
-    @tparam AllocatorType the allocator to use for objects (e.g.,
-    `std::allocator`)
-
-    #### Default type
-
-    With the default values for @a ObjectType (`std::map`), @a StringType
-    (`std::string`), and @a AllocatorType (`std::allocator`), the default
-    value for @a object_t is:
-
-    @code {.cpp}
-    std::map<
-      std::string, // key_type
-      basic_json, // value_type
-      std::less<std::string>, // key_compare
-      std::allocator<std::pair<const std::string, basic_json>> // allocator_type
-    >
-    @endcode
-
-    #### Behavior
-
-    The choice of @a object_t influences the behavior of the JSON class. With
-    the default type, objects have the following behavior:
-
-    - When all names are unique, objects will be interoperable in the sense
-      that all software implementations receiving that object will agree on
-      the name-value mappings.
-    - When the names within an object are not unique, it is unspecified which
-      one of the values for a given key will be chosen. For instance,
-      `{"key": 2, "key": 1}` could be equal to either `{"key": 1}` or
-      `{"key": 2}`.
-    - Internally, name/value pairs are stored in lexicographical order of the
-      names. Objects will also be serialized (see @ref dump) in this order.
-      For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
-      and serialized as `{"a": 2, "b": 1}`.
-    - When comparing objects, the order of the name/value pairs is irrelevant.
-      This makes objects interoperable in the sense that they will not be
-      affected by these differences. For instance, `{"b": 1, "a": 2}` and
-      `{"a": 2, "b": 1}` will be treated as equal.
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
-    > An implementation may set limits on the maximum depth of nesting.
-
-    In this class, the object's limit of nesting is not explicitly constrained.
-    However, a maximum depth of nesting may be introduced by the compiler or
-    runtime environment. A theoretical limit can be queried by calling the
-    @ref max_size function of a JSON object.
-
-    #### Storage
-
-    Objects are stored as pointers in a @ref basic_json type. That is, for any
-    access to object values, a pointer of type `object_t*` must be
-    dereferenced.
-
-    @sa @ref array_t -- type for an array value
-
-    @since version 1.0.0
-
-    @note The order name/value pairs are added to the object is *not*
-    preserved by the library. Therefore, iterating an object may return
-    name/value pairs in a different order than they were originally stored. In
-    fact, keys will be traversed in alphabetical order as `std::map` with
-    `std::less` is used by default. Please note this behavior conforms to [RFC
-    7159](http://rfc7159.net/rfc7159), because any order implements the
-    specified "unordered" nature of JSON objects.
-    */
-    using object_t = ObjectType<StringType,
-          basic_json,
-          object_comparator_t,
-          AllocatorType<std::pair<const StringType,
-          basic_json>>>;
-
-    /*!
-    @brief a type for an array
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
-    > An array is an ordered sequence of zero or more values.
-
-    To store objects in C++, a type is defined by the template parameters
-    explained below.
-
-    @tparam ArrayType  container type to store arrays (e.g., `std::vector` or
-    `std::list`)
-    @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
-
-    #### Default type
-
-    With the default values for @a ArrayType (`std::vector`) and @a
-    AllocatorType (`std::allocator`), the default value for @a array_t is:
-
-    @code {.cpp}
-    std::vector<
-      basic_json, // value_type
-      std::allocator<basic_json> // allocator_type
-    >
-    @endcode
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
-    > An implementation may set limits on the maximum depth of nesting.
-
-    In this class, the array's limit of nesting is not explicitly constrained.
-    However, a maximum depth of nesting may be introduced by the compiler or
-    runtime environment. A theoretical limit can be queried by calling the
-    @ref max_size function of a JSON array.
-
-    #### Storage
-
-    Arrays are stored as pointers in a @ref basic_json type. That is, for any
-    access to array values, a pointer of type `array_t*` must be dereferenced.
-
-    @sa @ref object_t -- type for an object value
-
-    @since version 1.0.0
-    */
-    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
-
-    /*!
-    @brief a type for a string
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
-    > A string is a sequence of zero or more Unicode characters.
-
-    To store objects in C++, a type is defined by the template parameter
-    described below. Unicode values are split by the JSON class into
-    byte-sized characters during deserialization.
-
-    @tparam StringType  the container to store strings (e.g., `std::string`).
-    Note this container is used for keys/names in objects, see @ref object_t.
-
-    #### Default type
-
-    With the default values for @a StringType (`std::string`), the default
-    value for @a string_t is:
-
-    @code {.cpp}
-    std::string
-    @endcode
-
-    #### Encoding
-
-    Strings are stored in UTF-8 encoding. Therefore, functions like
-    `std::string::size()` or `std::string::length()` return the number of
-    bytes in the string rather than the number of characters or glyphs.
-
-    #### String comparison
-
-    [RFC 7159](http://rfc7159.net/rfc7159) states:
-    > Software implementations are typically required to test names of object
-    > members for equality. Implementations that transform the textual
-    > representation into sequences of Unicode code units and then perform the
-    > comparison numerically, code unit by code unit, are interoperable in the
-    > sense that implementations will agree in all cases on equality or
-    > inequality of two strings. For example, implementations that compare
-    > strings with escaped characters unconverted may incorrectly find that
-    > `"a\\b"` and `"a\u005Cb"` are not equal.
-
-    This implementation is interoperable as it does compare strings code unit
-    by code unit.
-
-    #### Storage
-
-    String values are stored as pointers in a @ref basic_json type. That is,
-    for any access to string values, a pointer of type `string_t*` must be
-    dereferenced.
-
-    @since version 1.0.0
-    */
-    using string_t = StringType;
-
-    /*!
-    @brief a type for a boolean
-
-    [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
-    type which differentiates the two literals `true` and `false`.
-
-    To store objects in C++, a type is defined by the template parameter @a
-    BooleanType which chooses the type to use.
-
-    #### Default type
-
-    With the default values for @a BooleanType (`bool`), the default value for
-    @a boolean_t is:
-
-    @code {.cpp}
-    bool
-    @endcode
-
-    #### Storage
-
-    Boolean values are stored directly inside a @ref basic_json type.
-
-    @since version 1.0.0
-    */
-    using boolean_t = BooleanType;
-
-    /*!
-    @brief a type for a number (integer)
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
-    > The representation of numbers is similar to that used in most
-    > programming languages. A number is represented in base 10 using decimal
-    > digits. It contains an integer component that may be prefixed with an
-    > optional minus sign, which may be followed by a fraction part and/or an
-    > exponent part. Leading zeros are not allowed. (...) Numeric values that
-    > cannot be represented in the grammar below (such as Infinity and NaN)
-    > are not permitted.
-
-    This description includes both integer and floating-point numbers.
-    However, C++ allows more precise storage if it is known whether the number
-    is a signed integer, an unsigned integer or a floating-point number.
-    Therefore, three different types, @ref number_integer_t, @ref
-    number_unsigned_t and @ref number_float_t are used.
-
-    To store integer numbers in C++, a type is defined by the template
-    parameter @a NumberIntegerType which chooses the type to use.
-
-    #### Default type
-
-    With the default values for @a NumberIntegerType (`int64_t`), the default
-    value for @a number_integer_t is:
-
-    @code {.cpp}
-    int64_t
-    @endcode
-
-    #### Default behavior
-
-    - The restrictions about leading zeros is not enforced in C++. Instead,
-      leading zeros in integer literals lead to an interpretation as octal
-      number. Internally, the value will be stored as decimal number. For
-      instance, the C++ integer literal `010` will be serialized to `8`.
-      During deserialization, leading zeros yield an error.
-    - Not-a-number (NaN) values will be serialized to `null`.
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
-    > An implementation may set limits on the range and precision of numbers.
-
-    When the default type is used, the maximal integer number that can be
-    stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
-    that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
-    that are out of range will yield over/underflow when used in a
-    constructor. During deserialization, too large or small integer numbers
-    will be automatically be stored as @ref number_unsigned_t or @ref
-    number_float_t.
-
-    [RFC 7159](http://rfc7159.net/rfc7159) further states:
-    > Note that when such software is used, numbers that are integers and are
-    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
-    > that implementations will agree exactly on their numeric values.
-
-    As this range is a subrange of the exactly supported range [INT64_MIN,
-    INT64_MAX], this class's integer type is interoperable.
-
-    #### Storage
-
-    Integer number values are stored directly inside a @ref basic_json type.
-
-    @sa @ref number_float_t -- type for number values (floating-point)
-
-    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
-
-    @since version 1.0.0
-    */
-    using number_integer_t = NumberIntegerType;
-
-    /*!
-    @brief a type for a number (unsigned)
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
-    > The representation of numbers is similar to that used in most
-    > programming languages. A number is represented in base 10 using decimal
-    > digits. It contains an integer component that may be prefixed with an
-    > optional minus sign, which may be followed by a fraction part and/or an
-    > exponent part. Leading zeros are not allowed. (...) Numeric values that
-    > cannot be represented in the grammar below (such as Infinity and NaN)
-    > are not permitted.
-
-    This description includes both integer and floating-point numbers.
-    However, C++ allows more precise storage if it is known whether the number
-    is a signed integer, an unsigned integer or a floating-point number.
-    Therefore, three different types, @ref number_integer_t, @ref
-    number_unsigned_t and @ref number_float_t are used.
-
-    To store unsigned integer numbers in C++, a type is defined by the
-    template parameter @a NumberUnsignedType which chooses the type to use.
-
-    #### Default type
-
-    With the default values for @a NumberUnsignedType (`uint64_t`), the
-    default value for @a number_unsigned_t is:
-
-    @code {.cpp}
-    uint64_t
-    @endcode
-
-    #### Default behavior
-
-    - The restrictions about leading zeros is not enforced in C++. Instead,
-      leading zeros in integer literals lead to an interpretation as octal
-      number. Internally, the value will be stored as decimal number. For
-      instance, the C++ integer literal `010` will be serialized to `8`.
-      During deserialization, leading zeros yield an error.
-    - Not-a-number (NaN) values will be serialized to `null`.
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
-    > An implementation may set limits on the range and precision of numbers.
-
-    When the default type is used, the maximal integer number that can be
-    stored is `18446744073709551615` (UINT64_MAX) and the minimal integer
-    number that can be stored is `0`. Integer numbers that are out of range
-    will yield over/underflow when used in a constructor. During
-    deserialization, too large or small integer numbers will be automatically
-    be stored as @ref number_integer_t or @ref number_float_t.
-
-    [RFC 7159](http://rfc7159.net/rfc7159) further states:
-    > Note that when such software is used, numbers that are integers and are
-    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
-    > that implementations will agree exactly on their numeric values.
-
-    As this range is a subrange (when considered in conjunction with the
-    number_integer_t type) of the exactly supported range [0, UINT64_MAX],
-    this class's integer type is interoperable.
-
-    #### Storage
-
-    Integer number values are stored directly inside a @ref basic_json type.
-
-    @sa @ref number_float_t -- type for number values (floating-point)
-    @sa @ref number_integer_t -- type for number values (integer)
-
-    @since version 2.0.0
-    */
-    using number_unsigned_t = NumberUnsignedType;
-
-    /*!
-    @brief a type for a number (floating-point)
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
-    > The representation of numbers is similar to that used in most
-    > programming languages. A number is represented in base 10 using decimal
-    > digits. It contains an integer component that may be prefixed with an
-    > optional minus sign, which may be followed by a fraction part and/or an
-    > exponent part. Leading zeros are not allowed. (...) Numeric values that
-    > cannot be represented in the grammar below (such as Infinity and NaN)
-    > are not permitted.
-
-    This description includes both integer and floating-point numbers.
-    However, C++ allows more precise storage if it is known whether the number
-    is a signed integer, an unsigned integer or a floating-point number.
-    Therefore, three different types, @ref number_integer_t, @ref
-    number_unsigned_t and @ref number_float_t are used.
-
-    To store floating-point numbers in C++, a type is defined by the template
-    parameter @a NumberFloatType which chooses the type to use.
-
-    #### Default type
-
-    With the default values for @a NumberFloatType (`double`), the default
-    value for @a number_float_t is:
-
-    @code {.cpp}
-    double
-    @endcode
-
-    #### Default behavior
-
-    - The restrictions about leading zeros is not enforced in C++. Instead,
-      leading zeros in floating-point literals will be ignored. Internally,
-      the value will be stored as decimal number. For instance, the C++
-      floating-point literal `01.2` will be serialized to `1.2`. During
-      deserialization, leading zeros yield an error.
-    - Not-a-number (NaN) values will be serialized to `null`.
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) states:
-    > This specification allows implementations to set limits on the range and
-    > precision of numbers accepted. Since software that implements IEEE
-    > 754-2008 binary64 (double precision) numbers is generally available and
-    > widely used, good interoperability can be achieved by implementations
-    > that expect no more precision or range than these provide, in the sense
-    > that implementations will approximate JSON numbers within the expected
-    > precision.
-
-    This implementation does exactly follow this approach, as it uses double
-    precision floating-point numbers. Note values smaller than
-    `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
-    will be stored as NaN internally and be serialized to `null`.
-
-    #### Storage
-
-    Floating-point number values are stored directly inside a @ref basic_json
-    type.
-
-    @sa @ref number_integer_t -- type for number values (integer)
-
-    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
-
-    @since version 1.0.0
-    */
-    using number_float_t = NumberFloatType;
-
-    /*!
-    @brief a type for a packed binary type
-
-    This type is a type designed to carry binary data that appears in various
-    serialized formats, such as CBOR's Major Type 2, MessagePack's bin, and
-    BSON's generic binary subtype. This type is NOT a part of standard JSON and
-    exists solely for compatibility with these binary types. As such, it is
-    simply defined as an ordered sequence of zero or more byte values.
-
-    Additionally, as an implementation detail, the subtype of the binary data is
-    carried around as a `std::uint8_t`, which is compatible with both of the
-    binary data formats that use binary subtyping, (though the specific
-    numbering is incompatible with each other, and it is up to the user to
-    translate between them).
-
-    [CBOR's RFC 7049](https://tools.ietf.org/html/rfc7049) describes this type
-    as:
-    > Major type 2: a byte string. The string's length in bytes is represented
-    > following the rules for positive integers (major type 0).
-
-    [MessagePack's documentation on the bin type
-    family](https://github.com/msgpack/msgpack/blob/master/spec.md#bin-format-family)
-    describes this type as:
-    > Bin format family stores an byte array in 2, 3, or 5 bytes of extra bytes
-    > in addition to the size of the byte array.
-
-    [BSON's specifications](http://bsonspec.org/spec.html) describe several
-    binary types; however, this type is intended to represent the generic binary
-    type which has the description:
-    > Generic binary subtype - This is the most commonly used binary subtype and
-    > should be the 'default' for drivers and tools.
-
-    None of these impose any limitations on the internal representation other
-    than the basic unit of storage be some type of array whose parts are
-    decomposable into bytes.
-
-    The default representation of this binary format is a
-    `std::vector<std::uint8_t>`, which is a very common way to represent a byte
-    array in modern C++.
-
-    #### Default type
-
-    The default values for @a BinaryType is `std::vector<std::uint8_t>`
-
-    #### Storage
-
-    Binary Arrays are stored as pointers in a @ref basic_json type. That is,
-    for any access to array values, a pointer of the type `binary_t*` must be
-    dereferenced.
-
-    #### Notes on subtypes
-
-    - CBOR
-       - Binary values are represented as byte strings. No subtypes are
-         supported and will be ignored when CBOR is written.
-    - MessagePack
-       - If a subtype is given and the binary array contains exactly 1, 2, 4, 8,
-         or 16 elements, the fixext family (fixext1, fixext2, fixext4, fixext8)
-         is used. For other sizes, the ext family (ext8, ext16, ext32) is used.
-         The subtype is then added as singed 8-bit integer.
-       - If no subtype is given, the bin family (bin8, bin16, bin32) is used.
-    - BSON
-       - If a subtype is given, it is used and added as unsigned 8-bit integer.
-       - If no subtype is given, the generic binary subtype 0x00 is used.
-
-    @sa @ref binary -- create a binary array
-
-    @since version 3.8.0
-    */
-    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
-    /// @}
-
-  private:
-
-    /// helper for exception-safe object creation
-    template<typename T, typename... Args>
-    JSON_HEDLEY_RETURNS_NON_NULL
-    static T* create(Args&& ... args)
-    {
-        AllocatorType<T> alloc;
-        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
-
-        auto deleter = [&](T * object)
-        {
-            AllocatorTraits::deallocate(alloc, object, 1);
-        };
-        std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
-        AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
-        JSON_ASSERT(object != nullptr);
-        return object.release();
-    }
-
-    ////////////////////////
-    // JSON value storage //
-    ////////////////////////
-
-    /*!
-    @brief a JSON value
-
-    The actual storage for a JSON value of the @ref basic_json class. This
-    union combines the different storage types for the JSON value types
-    defined in @ref value_t.
-
-    JSON type | value_t type    | used type
-    --------- | --------------- | ------------------------
-    object    | object          | pointer to @ref object_t
-    array     | array           | pointer to @ref array_t
-    string    | string          | pointer to @ref string_t
-    boolean   | boolean         | @ref boolean_t
-    number    | number_integer  | @ref number_integer_t
-    number    | number_unsigned | @ref number_unsigned_t
-    number    | number_float    | @ref number_float_t
-    binary    | binary          | pointer to @ref binary_t
-    null      | null            | *no value is stored*
-
-    @note Variable-length types (objects, arrays, and strings) are stored as
-    pointers. The size of the union should not exceed 64 bits if the default
-    value types are used.
-
-    @since version 1.0.0
-    */
-    union json_value
-    {
-        /// object (stored with pointer to save storage)
-        object_t* object;
-        /// array (stored with pointer to save storage)
-        array_t* array;
-        /// string (stored with pointer to save storage)
-        string_t* string;
-        /// binary (stored with pointer to save storage)
-        binary_t* binary;
-        /// boolean
-        boolean_t boolean;
-        /// number (integer)
-        number_integer_t number_integer;
-        /// number (unsigned integer)
-        number_unsigned_t number_unsigned;
-        /// number (floating-point)
-        number_float_t number_float;
-
-        /// default constructor (for null values)
-        json_value() = default;
-        /// constructor for booleans
-        json_value(boolean_t v) noexcept : boolean(v) {}
-        /// constructor for numbers (integer)
-        json_value(number_integer_t v) noexcept : number_integer(v) {}
-        /// constructor for numbers (unsigned)
-        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
-        /// constructor for numbers (floating-point)
-        json_value(number_float_t v) noexcept : number_float(v) {}
-        /// constructor for empty values of a given type
-        json_value(value_t t)
-        {
-            switch (t)
-            {
-                case value_t::object:
-                {
-                    object = create<object_t>();
-                    break;
-                }
-
-                case value_t::array:
-                {
-                    array = create<array_t>();
-                    break;
-                }
-
-                case value_t::string:
-                {
-                    string = create<string_t>("");
-                    break;
-                }
-
-                case value_t::binary:
-                {
-                    binary = create<binary_t>();
-                    break;
-                }
-
-                case value_t::boolean:
-                {
-                    boolean = boolean_t(false);
-                    break;
-                }
-
-                case value_t::number_integer:
-                {
-                    number_integer = number_integer_t(0);
-                    break;
-                }
-
-                case value_t::number_unsigned:
-                {
-                    number_unsigned = number_unsigned_t(0);
-                    break;
-                }
-
-                case value_t::number_float:
-                {
-                    number_float = number_float_t(0.0);
-                    break;
-                }
-
-                case value_t::null:
-                {
-                    object = nullptr;  // silence warning, see #821
-                    break;
-                }
-
-                default:
-                {
-                    object = nullptr;  // silence warning, see #821
-                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
-                    {
-                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.1")); // LCOV_EXCL_LINE
-                    }
-                    break;
-                }
-            }
-        }
-
-        /// constructor for strings
-        json_value(const string_t& value)
-        {
-            string = create<string_t>(value);
-        }
-
-        /// constructor for rvalue strings
-        json_value(string_t&& value)
-        {
-            string = create<string_t>(std::move(value));
-        }
-
-        /// constructor for objects
-        json_value(const object_t& value)
-        {
-            object = create<object_t>(value);
-        }
-
-        /// constructor for rvalue objects
-        json_value(object_t&& value)
-        {
-            object = create<object_t>(std::move(value));
-        }
-
-        /// constructor for arrays
-        json_value(const array_t& value)
-        {
-            array = create<array_t>(value);
-        }
-
-        /// constructor for rvalue arrays
-        json_value(array_t&& value)
-        {
-            array = create<array_t>(std::move(value));
-        }
-
-        /// constructor for binary arrays
-        json_value(const typename binary_t::container_type& value)
-        {
-            binary = create<binary_t>(value);
-        }
-
-        /// constructor for rvalue binary arrays
-        json_value(typename binary_t::container_type&& value)
-        {
-            binary = create<binary_t>(std::move(value));
-        }
-
-        /// constructor for binary arrays (internal type)
-        json_value(const binary_t& value)
-        {
-            binary = create<binary_t>(value);
-        }
-
-        /// constructor for rvalue binary arrays (internal type)
-        json_value(binary_t&& value)
-        {
-            binary = create<binary_t>(std::move(value));
-        }
-
-        void destroy(value_t t) noexcept
-        {
-            // flatten the current json_value to a heap-allocated stack
-            std::vector<basic_json> stack;
-
-            // move the top-level items to stack
-            if (t == value_t::array)
-            {
-                stack.reserve(array->size());
-                std::move(array->begin(), array->end(), std::back_inserter(stack));
-            }
-            else if (t == value_t::object)
-            {
-                stack.reserve(object->size());
-                for (auto&& it : *object)
-                {
-                    stack.push_back(std::move(it.second));
-                }
-            }
-
-            while (!stack.empty())
-            {
-                // move the last item to local variable to be processed
-                basic_json current_item(std::move(stack.back()));
-                stack.pop_back();
-
-                // if current_item is array/object, move
-                // its children to the stack to be processed later
-                if (current_item.is_array())
-                {
-                    std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(),
-                              std::back_inserter(stack));
-
-                    current_item.m_value.array->clear();
-                }
-                else if (current_item.is_object())
-                {
-                    for (auto&& it : *current_item.m_value.object)
-                    {
-                        stack.push_back(std::move(it.second));
-                    }
-
-                    current_item.m_value.object->clear();
-                }
-
-                // it's now safe that current_item get destructed
-                // since it doesn't have any children
-            }
-
-            switch (t)
-            {
-                case value_t::object:
-                {
-                    AllocatorType<object_t> alloc;
-                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
-                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
-                    break;
-                }
-
-                case value_t::array:
-                {
-                    AllocatorType<array_t> alloc;
-                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
-                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
-                    break;
-                }
-
-                case value_t::string:
-                {
-                    AllocatorType<string_t> alloc;
-                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
-                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
-                    break;
-                }
-
-                case value_t::binary:
-                {
-                    AllocatorType<binary_t> alloc;
-                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
-                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
-                    break;
-                }
-
-                default:
-                {
-                    break;
-                }
-            }
-        }
-    };
-
-    /*!
-    @brief checks the class invariants
-
-    This function asserts the class invariants. It needs to be called at the
-    end of every constructor to make sure that created objects respect the
-    invariant. Furthermore, it has to be called each time the type of a JSON
-    value is changed, because the invariant expresses a relationship between
-    @a m_type and @a m_value.
-    */
-    void assert_invariant() const noexcept
-    {
-        JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
-        JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
-        JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
-        JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
-    }
-
-  public:
-    //////////////////////////
-    // JSON parser callback //
-    //////////////////////////
-
-    /*!
-    @brief parser event types
-
-    The parser callback distinguishes the following events:
-    - `object_start`: the parser read `{` and started to process a JSON object
-    - `key`: the parser read a key of a value in an object
-    - `object_end`: the parser read `}` and finished processing a JSON object
-    - `array_start`: the parser read `[` and started to process a JSON array
-    - `array_end`: the parser read `]` and finished processing a JSON array
-    - `value`: the parser finished reading a JSON value
-
-    @image html callback_events.png "Example when certain parse events are triggered"
-
-    @sa @ref parser_callback_t for more information and examples
-    */
-    using parse_event_t = detail::parse_event_t;
-
-    /*!
-    @brief per-element parser callback type
-
-    With a parser callback function, the result of parsing a JSON text can be
-    influenced. When passed to @ref parse, it is called on certain events
-    (passed as @ref parse_event_t via parameter @a event) with a set recursion
-    depth @a depth and context JSON value @a parsed. The return value of the
-    callback function is a boolean indicating whether the element that emitted
-    the callback shall be kept or not.
-
-    We distinguish six scenarios (determined by the event type) in which the
-    callback function can be called. The following table describes the values
-    of the parameters @a depth, @a event, and @a parsed.
-
-    parameter @a event | description | parameter @a depth | parameter @a parsed
-    ------------------ | ----------- | ------------------ | -------------------
-    parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
-    parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
-    parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
-    parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
-    parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
-    parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
-
-    @image html callback_events.png "Example when certain parse events are triggered"
-
-    Discarding a value (i.e., returning `false`) has different effects
-    depending on the context in which function was called:
-
-    - Discarded values in structured types are skipped. That is, the parser
-      will behave as if the discarded value was never read.
-    - In case a value outside a structured type is skipped, it is replaced
-      with `null`. This case happens if the top-level element is skipped.
-
-    @param[in] depth  the depth of the recursion during parsing
-
-    @param[in] event  an event of type parse_event_t indicating the context in
-    the callback function has been called
-
-    @param[in,out] parsed  the current intermediate parse result; note that
-    writing to this value has no effect for parse_event_t::key events
-
-    @return Whether the JSON value which called the function during parsing
-    should be kept (`true`) or not (`false`). In the latter case, it is either
-    skipped completely or replaced by an empty discarded object.
-
-    @sa @ref parse for examples
-
-    @since version 1.0.0
-    */
-    using parser_callback_t = detail::parser_callback_t<basic_json>;
-
-    //////////////////
-    // constructors //
-    //////////////////
-
-    /// @name constructors and destructors
-    /// Constructors of class @ref basic_json, copy/move constructor, copy
-    /// assignment, static functions creating objects, and the destructor.
-    /// @{
-
-    /*!
-    @brief create an empty value with a given type
-
-    Create an empty JSON value with a given type. The value will be default
-    initialized with an empty value which depends on the type:
-
-    Value type  | initial value
-    ----------- | -------------
-    null        | `null`
-    boolean     | `false`
-    string      | `""`
-    number      | `0`
-    object      | `{}`
-    array       | `[]`
-    binary      | empty array
-
-    @param[in] v  the type of the value to create
-
-    @complexity Constant.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The following code shows the constructor for different @ref
-    value_t values,basic_json__value_t}
-
-    @sa @ref clear() -- restores the postcondition of this constructor
-
-    @since version 1.0.0
-    */
-    basic_json(const value_t v)
-        : m_type(v), m_value(v)
-    {
-        assert_invariant();
-    }
-
-    /*!
-    @brief create a null object
-
-    Create a `null` JSON value. It either takes a null pointer as parameter
-    (explicitly creating `null`) or no parameter (implicitly creating `null`).
-    The passed null pointer itself is not read -- it is only used to choose
-    the right constructor.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this constructor never throws
-    exceptions.
-
-    @liveexample{The following code shows the constructor with and without a
-    null pointer parameter.,basic_json__nullptr_t}
-
-    @since version 1.0.0
-    */
-    basic_json(std::nullptr_t = nullptr) noexcept
-        : basic_json(value_t::null)
-    {
-        assert_invariant();
-    }
-
-    /*!
-    @brief create a JSON value
-
-    This is a "catch all" constructor for all compatible JSON types; that is,
-    types for which a `to_json()` method exists. The constructor forwards the
-    parameter @a val to that method (to `json_serializer<U>::to_json` method
-    with `U = uncvref_t<CompatibleType>`, to be exact).
-
-    Template type @a CompatibleType includes, but is not limited to, the
-    following types:
-    - **arrays**: @ref array_t and all kinds of compatible containers such as
-      `std::vector`, `std::deque`, `std::list`, `std::forward_list`,
-      `std::array`, `std::valarray`, `std::set`, `std::unordered_set`,
-      `std::multiset`, and `std::unordered_multiset` with a `value_type` from
-      which a @ref basic_json value can be constructed.
-    - **objects**: @ref object_t and all kinds of compatible associative
-      containers such as `std::map`, `std::unordered_map`, `std::multimap`,
-      and `std::unordered_multimap` with a `key_type` compatible to
-      @ref string_t and a `value_type` from which a @ref basic_json value can
-      be constructed.
-    - **strings**: @ref string_t, string literals, and all compatible string
-      containers can be used.
-    - **numbers**: @ref number_integer_t, @ref number_unsigned_t,
-      @ref number_float_t, and all convertible number types such as `int`,
-      `size_t`, `int64_t`, `float` or `double` can be used.
-    - **boolean**: @ref boolean_t / `bool` can be used.
-    - **binary**: @ref binary_t / `std::vector<uint8_t>` may be used,
-      unfortunately because string literals cannot be distinguished from binary
-      character arrays by the C++ type system, all types compatible with `const
-      char*` will be directed to the string constructor instead.  This is both
-      for backwards compatibility, and due to the fact that a binary type is not
-      a standard JSON type.
-
-    See the examples below.
-
-    @tparam CompatibleType a type such that:
-    - @a CompatibleType is not derived from `std::istream`,
-    - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move
-         constructors),
-    - @a CompatibleType is not a different @ref basic_json type (i.e. with different template arguments)
-    - @a CompatibleType is not a @ref basic_json nested type (e.g.,
-         @ref json_pointer, @ref iterator, etc ...)
-    - @ref @ref json_serializer<U> has a
-         `to_json(basic_json_t&, CompatibleType&&)` method
-
-    @tparam U = `uncvref_t<CompatibleType>`
-
-    @param[in] val the value to be forwarded to the respective constructor
-
-    @complexity Usually linear in the size of the passed @a val, also
-                depending on the implementation of the called `to_json()`
-                method.
-
-    @exceptionsafety Depends on the called constructor. For types directly
-    supported by the library (i.e., all types for which no `to_json()` function
-    was provided), strong guarantee holds: if an exception is thrown, there are
-    no changes to any JSON value.
-
-    @liveexample{The following code shows the constructor with several
-    compatible types.,basic_json__CompatibleType}
-
-    @since version 2.1.0
-    */
-    template < typename CompatibleType,
-               typename U = detail::uncvref_t<CompatibleType>,
-               detail::enable_if_t <
-                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
-    basic_json(CompatibleType && val) noexcept(noexcept(
-                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
-                                           std::forward<CompatibleType>(val))))
-    {
-        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
-        assert_invariant();
-    }
-
-    /*!
-    @brief create a JSON value from an existing one
-
-    This is a constructor for existing @ref basic_json types.
-    It does not hijack copy/move constructors, since the parameter has different
-    template arguments than the current ones.
-
-    The constructor tries to convert the internal @ref m_value of the parameter.
-
-    @tparam BasicJsonType a type such that:
-    - @a BasicJsonType is a @ref basic_json type.
-    - @a BasicJsonType has different template arguments than @ref basic_json_t.
-
-    @param[in] val the @ref basic_json value to be converted.
-
-    @complexity Usually linear in the size of the passed @a val, also
-                depending on the implementation of the called `to_json()`
-                method.
-
-    @exceptionsafety Depends on the called constructor. For types directly
-    supported by the library (i.e., all types for which no `to_json()` function
-    was provided), strong guarantee holds: if an exception is thrown, there are
-    no changes to any JSON value.
-
-    @since version 3.2.0
-    */
-    template < typename BasicJsonType,
-               detail::enable_if_t <
-                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
-    basic_json(const BasicJsonType& val)
-    {
-        using other_boolean_t = typename BasicJsonType::boolean_t;
-        using other_number_float_t = typename BasicJsonType::number_float_t;
-        using other_number_integer_t = typename BasicJsonType::number_integer_t;
-        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-        using other_string_t = typename BasicJsonType::string_t;
-        using other_object_t = typename BasicJsonType::object_t;
-        using other_array_t = typename BasicJsonType::array_t;
-        using other_binary_t = typename BasicJsonType::binary_t;
-
-        switch (val.type())
-        {
-            case value_t::boolean:
-                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
-                break;
-            case value_t::number_float:
-                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
-                break;
-            case value_t::number_integer:
-                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
-                break;
-            case value_t::number_unsigned:
-                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
-                break;
-            case value_t::string:
-                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
-                break;
-            case value_t::object:
-                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
-                break;
-            case value_t::array:
-                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
-                break;
-            case value_t::binary:
-                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
-                break;
-            case value_t::null:
-                *this = nullptr;
-                break;
-            case value_t::discarded:
-                m_type = value_t::discarded;
-                break;
-            default:            // LCOV_EXCL_LINE
-                JSON_ASSERT(false);  // LCOV_EXCL_LINE
-        }
-        assert_invariant();
-    }
-
-    /*!
-    @brief create a container (array or object) from an initializer list
-
-    Creates a JSON value of type array or object from the passed initializer
-    list @a init. In case @a type_deduction is `true` (default), the type of
-    the JSON value to be created is deducted from the initializer list @a init
-    according to the following rules:
-
-    1. If the list is empty, an empty JSON object value `{}` is created.
-    2. If the list consists of pairs whose first element is a string, a JSON
-       object value is created where the first elements of the pairs are
-       treated as keys and the second elements are as values.
-    3. In all other cases, an array is created.
-
-    The rules aim to create the best fit between a C++ initializer list and
-    JSON values. The rationale is as follows:
-
-    1. The empty initializer list is written as `{}` which is exactly an empty
-       JSON object.
-    2. C++ has no way of describing mapped types other than to list a list of
-       pairs. As JSON requires that keys must be of type string, rule 2 is the
-       weakest constraint one can pose on initializer lists to interpret them
-       as an object.
-    3. In all other cases, the initializer list could not be interpreted as
-       JSON object type, so interpreting it as JSON array type is safe.
-
-    With the rules described above, the following JSON values cannot be
-    expressed by an initializer list:
-
-    - the empty array (`[]`): use @ref array(initializer_list_t)
-      with an empty initializer list in this case
-    - arrays whose elements satisfy rule 2: use @ref
-      array(initializer_list_t) with the same initializer list
-      in this case
-
-    @note When used without parentheses around an empty initializer list, @ref
-    basic_json() is called instead of this function, yielding the JSON null
-    value.
-
-    @param[in] init  initializer list with JSON values
-
-    @param[in] type_deduction internal parameter; when set to `true`, the type
-    of the JSON value is deducted from the initializer list @a init; when set
-    to `false`, the type provided via @a manual_type is forced. This mode is
-    used by the functions @ref array(initializer_list_t) and
-    @ref object(initializer_list_t).
-
-    @param[in] manual_type internal parameter; when @a type_deduction is set
-    to `false`, the created JSON value will use the provided type (only @ref
-    value_t::array and @ref value_t::object are valid); when @a type_deduction
-    is set to `true`, this parameter has no effect
-
-    @throw type_error.301 if @a type_deduction is `false`, @a manual_type is
-    `value_t::object`, but @a init contains an element which is not a pair
-    whose first element is a string. In this case, the constructor could not
-    create an object. If @a type_deduction would have be `true`, an array
-    would have been created. See @ref object(initializer_list_t)
-    for an example.
-
-    @complexity Linear in the size of the initializer list @a init.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The example below shows how JSON values are created from
-    initializer lists.,basic_json__list_init_t}
-
-    @sa @ref array(initializer_list_t) -- create a JSON array
-    value from an initializer list
-    @sa @ref object(initializer_list_t) -- create a JSON object
-    value from an initializer list
-
-    @since version 1.0.0
-    */
-    basic_json(initializer_list_t init,
-               bool type_deduction = true,
-               value_t manual_type = value_t::array)
-    {
-        // check if each element is an array with two elements whose first
-        // element is a string
-        bool is_an_object = std::all_of(init.begin(), init.end(),
-                                        [](const detail::json_ref<basic_json>& element_ref)
-        {
-            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
-        });
-
-        // adjust type if type deduction is not wanted
-        if (!type_deduction)
-        {
-            // if array is wanted, do not create an object though possible
-            if (manual_type == value_t::array)
-            {
-                is_an_object = false;
-            }
-
-            // if object is wanted but impossible, throw an exception
-            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
-            {
-                JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
-            }
-        }
-
-        if (is_an_object)
-        {
-            // the initializer list is a list of pairs -> create object
-            m_type = value_t::object;
-            m_value = value_t::object;
-
-            std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)
-            {
-                auto element = element_ref.moved_or_copied();
-                m_value.object->emplace(
-                    std::move(*((*element.m_value.array)[0].m_value.string)),
-                    std::move((*element.m_value.array)[1]));
-            });
-        }
-        else
-        {
-            // the initializer list describes an array -> create array
-            m_type = value_t::array;
-            m_value.array = create<array_t>(init.begin(), init.end());
-        }
-
-        assert_invariant();
-    }
-
-    /*!
-    @brief explicitly create a binary array (without subtype)
-
-    Creates a JSON binary array value from a given binary container. Binary
-    values are part of various binary formats, such as CBOR, MessagePack, and
-    BSON. This constructor is used to create a value for serialization to those
-    formats.
-
-    @note Note, this function exists because of the difficulty in correctly
-    specifying the correct template overload in the standard value ctor, as both
-    JSON arrays and JSON binary arrays are backed with some form of a
-    `std::vector`. Because JSON binary arrays are a non-standard extension it
-    was decided that it would be best to prevent automatic initialization of a
-    binary array type, for backwards compatibility and so it does not happen on
-    accident.
-
-    @param[in] init container containing bytes to use as binary type
-
-    @return JSON binary array value
-
-    @complexity Linear in the size of @a init.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @since version 3.8.0
-    */
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json binary(const typename binary_t::container_type& init)
-    {
-        auto res = basic_json();
-        res.m_type = value_t::binary;
-        res.m_value = init;
-        return res;
-    }
-
-    /*!
-    @brief explicitly create a binary array (with subtype)
-
-    Creates a JSON binary array value from a given binary container. Binary
-    values are part of various binary formats, such as CBOR, MessagePack, and
-    BSON. This constructor is used to create a value for serialization to those
-    formats.
-
-    @note Note, this function exists because of the difficulty in correctly
-    specifying the correct template overload in the standard value ctor, as both
-    JSON arrays and JSON binary arrays are backed with some form of a
-    `std::vector`. Because JSON binary arrays are a non-standard extension it
-    was decided that it would be best to prevent automatic initialization of a
-    binary array type, for backwards compatibility and so it does not happen on
-    accident.
-
-    @param[in] init container containing bytes to use as binary type
-    @param[in] subtype subtype to use in MessagePack and BSON
-
-    @return JSON binary array value
-
-    @complexity Linear in the size of @a init.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @since version 3.8.0
-    */
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json binary(const typename binary_t::container_type& init, std::uint8_t subtype)
-    {
-        auto res = basic_json();
-        res.m_type = value_t::binary;
-        res.m_value = binary_t(init, subtype);
-        return res;
-    }
-
-    /// @copydoc binary(const typename binary_t::container_type&)
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json binary(typename binary_t::container_type&& init)
-    {
-        auto res = basic_json();
-        res.m_type = value_t::binary;
-        res.m_value = std::move(init);
-        return res;
-    }
-
-    /// @copydoc binary(const typename binary_t::container_type&, std::uint8_t)
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json binary(typename binary_t::container_type&& init, std::uint8_t subtype)
-    {
-        auto res = basic_json();
-        res.m_type = value_t::binary;
-        res.m_value = binary_t(std::move(init), subtype);
-        return res;
-    }
-
-    /*!
-    @brief explicitly create an array from an initializer list
-
-    Creates a JSON array value from a given initializer list. That is, given a
-    list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
-    initializer list is empty, the empty array `[]` is created.
-
-    @note This function is only needed to express two edge cases that cannot
-    be realized with the initializer list constructor (@ref
-    basic_json(initializer_list_t, bool, value_t)). These cases
-    are:
-    1. creating an array whose elements are all pairs whose first element is a
-    string -- in this case, the initializer list constructor would create an
-    object, taking the first elements as keys
-    2. creating an empty array -- passing the empty initializer list to the
-    initializer list constructor yields an empty object
-
-    @param[in] init  initializer list with JSON values to create an array from
-    (optional)
-
-    @return JSON array value
-
-    @complexity Linear in the size of @a init.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The following code shows an example for the `array`
-    function.,array}
-
-    @sa @ref basic_json(initializer_list_t, bool, value_t) --
-    create a JSON value from an initializer list
-    @sa @ref object(initializer_list_t) -- create a JSON object
-    value from an initializer list
-
-    @since version 1.0.0
-    */
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json array(initializer_list_t init = {})
-    {
-        return basic_json(init, false, value_t::array);
-    }
-
-    /*!
-    @brief explicitly create an object from an initializer list
-
-    Creates a JSON object value from a given initializer list. The initializer
-    lists elements must be pairs, and their first elements must be strings. If
-    the initializer list is empty, the empty object `{}` is created.
-
-    @note This function is only added for symmetry reasons. In contrast to the
-    related function @ref array(initializer_list_t), there are
-    no cases which can only be expressed by this function. That is, any
-    initializer list @a init can also be passed to the initializer list
-    constructor @ref basic_json(initializer_list_t, bool, value_t).
-
-    @param[in] init  initializer list to create an object from (optional)
-
-    @return JSON object value
-
-    @throw type_error.301 if @a init is not a list of pairs whose first
-    elements are strings. In this case, no object can be created. When such a
-    value is passed to @ref basic_json(initializer_list_t, bool, value_t),
-    an array would have been created from the passed initializer list @a init.
-    See example below.
-
-    @complexity Linear in the size of @a init.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The following code shows an example for the `object`
-    function.,object}
-
-    @sa @ref basic_json(initializer_list_t, bool, value_t) --
-    create a JSON value from an initializer list
-    @sa @ref array(initializer_list_t) -- create a JSON array
-    value from an initializer list
-
-    @since version 1.0.0
-    */
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json object(initializer_list_t init = {})
-    {
-        return basic_json(init, false, value_t::object);
-    }
-
-    /*!
-    @brief construct an array with count copies of given value
-
-    Constructs a JSON array value by creating @a cnt copies of a passed value.
-    In case @a cnt is `0`, an empty array is created.
-
-    @param[in] cnt  the number of JSON copies of @a val to create
-    @param[in] val  the JSON value to copy
-
-    @post `std::distance(begin(),end()) == cnt` holds.
-
-    @complexity Linear in @a cnt.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The following code shows examples for the @ref
-    basic_json(size_type\, const basic_json&)
-    constructor.,basic_json__size_type_basic_json}
-
-    @since version 1.0.0
-    */
-    basic_json(size_type cnt, const basic_json& val)
-        : m_type(value_t::array)
-    {
-        m_value.array = create<array_t>(cnt, val);
-        assert_invariant();
-    }
-
-    /*!
-    @brief construct a JSON container given an iterator range
-
-    Constructs the JSON value with the contents of the range `[first, last)`.
-    The semantics depends on the different types a JSON value can have:
-    - In case of a null type, invalid_iterator.206 is thrown.
-    - In case of other primitive types (number, boolean, or string), @a first
-      must be `begin()` and @a last must be `end()`. In this case, the value is
-      copied. Otherwise, invalid_iterator.204 is thrown.
-    - In case of structured types (array, object), the constructor behaves as
-      similar versions for `std::vector` or `std::map`; that is, a JSON array
-      or object is constructed from the values in the range.
-
-    @tparam InputIT an input iterator type (@ref iterator or @ref
-    const_iterator)
-
-    @param[in] first begin of the range to copy from (included)
-    @param[in] last end of the range to copy from (excluded)
-
-    @pre Iterators @a first and @a last must be initialized. **This
-         precondition is enforced with an assertion (see warning).** If
-         assertions are switched off, a violation of this precondition yields
-         undefined behavior.
-
-    @pre Range `[first, last)` is valid. Usually, this precondition cannot be
-         checked efficiently. Only certain edge cases are detected; see the
-         description of the exceptions below. A violation of this precondition
-         yields undefined behavior.
-
-    @warning A precondition is enforced with a runtime assertion that will
-             result in calling `std::abort` if this precondition is not met.
-             Assertions can be disabled by defining `NDEBUG` at compile time.
-             See https://en.cppreference.com/w/cpp/error/assert for more
-             information.
-
-    @throw invalid_iterator.201 if iterators @a first and @a last are not
-    compatible (i.e., do not belong to the same JSON value). In this case,
-    the range `[first, last)` is undefined.
-    @throw invalid_iterator.204 if iterators @a first and @a last belong to a
-    primitive type (number, boolean, or string), but @a first does not point
-    to the first element any more. In this case, the range `[first, last)` is
-    undefined. See example code below.
-    @throw invalid_iterator.206 if iterators @a first and @a last belong to a
-    null value. In this case, the range `[first, last)` is undefined.
-
-    @complexity Linear in distance between @a first and @a last.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The example below shows several ways to create JSON values by
-    specifying a subrange with iterators.,basic_json__InputIt_InputIt}
-
-    @since version 1.0.0
-    */
-    template < class InputIT, typename std::enable_if <
-                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
-                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
-    basic_json(InputIT first, InputIT last)
-    {
-        JSON_ASSERT(first.m_object != nullptr);
-        JSON_ASSERT(last.m_object != nullptr);
-
-        // make sure iterator fits the current value
-        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
-        {
-            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
-        }
-
-        // copy type from first iterator
-        m_type = first.m_object->m_type;
-
-        // check if iterator range is complete for primitive values
-        switch (m_type)
-        {
-            case value_t::boolean:
-            case value_t::number_float:
-            case value_t::number_integer:
-            case value_t::number_unsigned:
-            case value_t::string:
-            {
-                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
-                                         || !last.m_it.primitive_iterator.is_end()))
-                {
-                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
-                }
-                break;
-            }
-
-            default:
-                break;
-        }
-
-        switch (m_type)
-        {
-            case value_t::number_integer:
-            {
-                m_value.number_integer = first.m_object->m_value.number_integer;
-                break;
-            }
-
-            case value_t::number_unsigned:
-            {
-                m_value.number_unsigned = first.m_object->m_value.number_unsigned;
-                break;
-            }
-
-            case value_t::number_float:
-            {
-                m_value.number_float = first.m_object->m_value.number_float;
-                break;
-            }
-
-            case value_t::boolean:
-            {
-                m_value.boolean = first.m_object->m_value.boolean;
-                break;
-            }
-
-            case value_t::string:
-            {
-                m_value = *first.m_object->m_value.string;
-                break;
-            }
-
-            case value_t::object:
-            {
-                m_value.object = create<object_t>(first.m_it.object_iterator,
-                                                  last.m_it.object_iterator);
-                break;
-            }
-
-            case value_t::array:
-            {
-                m_value.array = create<array_t>(first.m_it.array_iterator,
-                                                last.m_it.array_iterator);
-                break;
-            }
-
-            case value_t::binary:
-            {
-                m_value = *first.m_object->m_value.binary;
-                break;
-            }
-
-            default:
-                JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
-                                                    std::string(first.m_object->type_name())));
-        }
-
-        assert_invariant();
-    }
-
-
-    ///////////////////////////////////////
-    // other constructors and destructor //
-    ///////////////////////////////////////
-
-    template<typename JsonRef,
-             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
-                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
-    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
-
-    /*!
-    @brief copy constructor
-
-    Creates a copy of a given JSON value.
-
-    @param[in] other  the JSON value to copy
-
-    @post `*this == other`
-
-    @complexity Linear in the size of @a other.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is linear.
-    - As postcondition, it holds: `other == basic_json(other)`.
-
-    @liveexample{The following code shows an example for the copy
-    constructor.,basic_json__basic_json}
-
-    @since version 1.0.0
-    */
-    basic_json(const basic_json& other)
-        : m_type(other.m_type)
-    {
-        // check of passed value is valid
-        other.assert_invariant();
-
-        switch (m_type)
-        {
-            case value_t::object:
-            {
-                m_value = *other.m_value.object;
-                break;
-            }
-
-            case value_t::array:
-            {
-                m_value = *other.m_value.array;
-                break;
-            }
-
-            case value_t::string:
-            {
-                m_value = *other.m_value.string;
-                break;
-            }
-
-            case value_t::boolean:
-            {
-                m_value = other.m_value.boolean;
-                break;
-            }
-
-            case value_t::number_integer:
-            {
-                m_value = other.m_value.number_integer;
-                break;
-            }
-
-            case value_t::number_unsigned:
-            {
-                m_value = other.m_value.number_unsigned;
-                break;
-            }
-
-            case value_t::number_float:
-            {
-                m_value = other.m_value.number_float;
-                break;
-            }
-
-            case value_t::binary:
-            {
-                m_value = *other.m_value.binary;
-                break;
-            }
-
-            default:
-                break;
-        }
-
-        assert_invariant();
-    }
-
-    /*!
-    @brief move constructor
-
-    Move constructor. Constructs a JSON value with the contents of the given
-    value @a other using move semantics. It "steals" the resources from @a
-    other and leaves it as JSON null value.
-
-    @param[in,out] other  value to move to this object
-
-    @post `*this` has the same value as @a other before the call.
-    @post @a other is a JSON null value.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this constructor never throws
-    exceptions.
-
-    @requirement This function helps `basic_json` satisfying the
-    [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible)
-    requirements.
-
-    @liveexample{The code below shows the move constructor explicitly called
-    via std::move.,basic_json__moveconstructor}
-
-    @since version 1.0.0
-    */
-    basic_json(basic_json&& other) noexcept
-        : m_type(std::move(other.m_type)),
-          m_value(std::move(other.m_value))
-    {
-        // check that passed value is valid
-        other.assert_invariant();
-
-        // invalidate payload
-        other.m_type = value_t::null;
-        other.m_value = {};
-
-        assert_invariant();
-    }
-
-    /*!
-    @brief copy assignment
-
-    Copy assignment operator. Copies a JSON value via the "copy and swap"
-    strategy: It is expressed in terms of the copy constructor, destructor,
-    and the `swap()` member function.
-
-    @param[in] other  value to copy from
-
-    @complexity Linear.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is linear.
-
-    @liveexample{The code below shows and example for the copy assignment. It
-    creates a copy of value `a` which is then swapped with `b`. Finally\, the
-    copy of `a` (which is the null value after the swap) is
-    destroyed.,basic_json__copyassignment}
-
-    @since version 1.0.0
-    */
-    basic_json& operator=(basic_json other) noexcept (
-        std::is_nothrow_move_constructible<value_t>::value&&
-        std::is_nothrow_move_assignable<value_t>::value&&
-        std::is_nothrow_move_constructible<json_value>::value&&
-        std::is_nothrow_move_assignable<json_value>::value
-    )
-    {
-        // check that passed value is valid
-        other.assert_invariant();
-
-        using std::swap;
-        swap(m_type, other.m_type);
-        swap(m_value, other.m_value);
-
-        assert_invariant();
-        return *this;
-    }
-
-    /*!
-    @brief destructor
-
-    Destroys the JSON value and frees all allocated memory.
-
-    @complexity Linear.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is linear.
-    - All stored elements are destroyed and all memory is freed.
-
-    @since version 1.0.0
-    */
-    ~basic_json() noexcept
-    {
-        assert_invariant();
-        m_value.destroy(m_type);
-    }
-
-    /// @}
-
-  public:
-    ///////////////////////
-    // object inspection //
-    ///////////////////////
-
-    /// @name object inspection
-    /// Functions to inspect the type of a JSON value.
-    /// @{
-
-    /*!
-    @brief serialization
-
-    Serialization function for JSON values. The function tries to mimic
-    Python's `json.dumps()` function, and currently supports its @a indent
-    and @a ensure_ascii parameters.
-
-    @param[in] indent If indent is nonnegative, then array elements and object
-    members will be pretty-printed with that indent level. An indent level of
-    `0` will only insert newlines. `-1` (the default) selects the most compact
-    representation.
-    @param[in] indent_char The character to use for indentation if @a indent is
-    greater than `0`. The default is ` ` (space).
-    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
-    in the output are escaped with `\uXXXX` sequences, and the result consists
-    of ASCII characters only.
-    @param[in] error_handler  how to react on decoding errors; there are three
-    possible values: `strict` (throws and exception in case a decoding error
-    occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
-    and `ignore` (ignore invalid UTF-8 sequences during serialization; all
-    bytes are copied to the output unchanged).
-
-    @return string containing the serialization of the JSON value
-
-    @throw type_error.316 if a string stored inside the JSON value is not
-                          UTF-8 encoded and @a error_handler is set to strict
-
-    @note Binary values are serialized as object containing two keys:
-      - "bytes": an array of bytes as integers
-      - "subtype": the subtype as integer or "null" if the binary has no subtype
-
-    @complexity Linear.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @liveexample{The following example shows the effect of different @a indent\,
-    @a indent_char\, and @a ensure_ascii parameters to the result of the
-    serialization.,dump}
-
-    @see https://docs.python.org/2/library/json.html#json.dump
-
-    @since version 1.0.0; indentation character @a indent_char, option
-           @a ensure_ascii and exceptions added in version 3.0.0; error
-           handlers added in version 3.4.0; serialization of binary values added
-           in version 3.8.0.
-    */
-    string_t dump(const int indent = -1,
-                  const char indent_char = ' ',
-                  const bool ensure_ascii = false,
-                  const error_handler_t error_handler = error_handler_t::strict) const
-    {
-        string_t result;
-        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
-
-        if (indent >= 0)
-        {
-            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
-        }
-        else
-        {
-            s.dump(*this, false, ensure_ascii, 0);
-        }
-
-        return result;
-    }
-
-    /*!
-    @brief return the type of the JSON value (explicit)
-
-    Return the type of the JSON value as a value from the @ref value_t
-    enumeration.
-
-    @return the type of the JSON value
-            Value type                | return value
-            ------------------------- | -------------------------
-            null                      | value_t::null
-            boolean                   | value_t::boolean
-            string                    | value_t::string
-            number (integer)          | value_t::number_integer
-            number (unsigned integer) | value_t::number_unsigned
-            number (floating-point)   | value_t::number_float
-            object                    | value_t::object
-            array                     | value_t::array
-            binary                    | value_t::binary
-            discarded                 | value_t::discarded
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `type()` for all JSON
-    types.,type}
-
-    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
-    @sa @ref type_name() -- return the type as string
-
-    @since version 1.0.0
-    */
-    constexpr value_t type() const noexcept
-    {
-        return m_type;
-    }
-
-    /*!
-    @brief return whether type is primitive
-
-    This function returns true if and only if the JSON type is primitive
-    (string, number, boolean, or null).
-
-    @return `true` if type is primitive (string, number, boolean, or null),
-    `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_primitive()` for all JSON
-    types.,is_primitive}
-
-    @sa @ref is_structured() -- returns whether JSON value is structured
-    @sa @ref is_null() -- returns whether JSON value is `null`
-    @sa @ref is_string() -- returns whether JSON value is a string
-    @sa @ref is_boolean() -- returns whether JSON value is a boolean
-    @sa @ref is_number() -- returns whether JSON value is a number
-    @sa @ref is_binary() -- returns whether JSON value is a binary array
-
-    @since version 1.0.0
-    */
-    constexpr bool is_primitive() const noexcept
-    {
-        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
-    }
-
-    /*!
-    @brief return whether type is structured
-
-    This function returns true if and only if the JSON type is structured
-    (array or object).
-
-    @return `true` if type is structured (array or object), `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_structured()` for all JSON
-    types.,is_structured}
-
-    @sa @ref is_primitive() -- returns whether value is primitive
-    @sa @ref is_array() -- returns whether value is an array
-    @sa @ref is_object() -- returns whether value is an object
-
-    @since version 1.0.0
-    */
-    constexpr bool is_structured() const noexcept
-    {
-        return is_array() || is_object();
-    }
-
-    /*!
-    @brief return whether value is null
-
-    This function returns true if and only if the JSON value is null.
-
-    @return `true` if type is null, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_null()` for all JSON
-    types.,is_null}
-
-    @since version 1.0.0
-    */
-    constexpr bool is_null() const noexcept
-    {
-        return m_type == value_t::null;
-    }
-
-    /*!
-    @brief return whether value is a boolean
-
-    This function returns true if and only if the JSON value is a boolean.
-
-    @return `true` if type is boolean, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_boolean()` for all JSON
-    types.,is_boolean}
-
-    @since version 1.0.0
-    */
-    constexpr bool is_boolean() const noexcept
-    {
-        return m_type == value_t::boolean;
-    }
-
-    /*!
-    @brief return whether value is a number
-
-    This function returns true if and only if the JSON value is a number. This
-    includes both integer (signed and unsigned) and floating-point values.
-
-    @return `true` if type is number (regardless whether integer, unsigned
-    integer or floating-type), `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_number()` for all JSON
-    types.,is_number}
-
-    @sa @ref is_number_integer() -- check if value is an integer or unsigned
-    integer number
-    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
-    number
-    @sa @ref is_number_float() -- check if value is a floating-point number
-
-    @since version 1.0.0
-    */
-    constexpr bool is_number() const noexcept
-    {
-        return is_number_integer() || is_number_float();
-    }
-
-    /*!
-    @brief return whether value is an integer number
-
-    This function returns true if and only if the JSON value is a signed or
-    unsigned integer number. This excludes floating-point values.
-
-    @return `true` if type is an integer or unsigned integer number, `false`
-    otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_number_integer()` for all
-    JSON types.,is_number_integer}
-
-    @sa @ref is_number() -- check if value is a number
-    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
-    number
-    @sa @ref is_number_float() -- check if value is a floating-point number
-
-    @since version 1.0.0
-    */
-    constexpr bool is_number_integer() const noexcept
-    {
-        return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
-    }
-
-    /*!
-    @brief return whether value is an unsigned integer number
-
-    This function returns true if and only if the JSON value is an unsigned
-    integer number. This excludes floating-point and signed integer values.
-
-    @return `true` if type is an unsigned integer number, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_number_unsigned()` for all
-    JSON types.,is_number_unsigned}
-
-    @sa @ref is_number() -- check if value is a number
-    @sa @ref is_number_integer() -- check if value is an integer or unsigned
-    integer number
-    @sa @ref is_number_float() -- check if value is a floating-point number
-
-    @since version 2.0.0
-    */
-    constexpr bool is_number_unsigned() const noexcept
-    {
-        return m_type == value_t::number_unsigned;
-    }
-
-    /*!
-    @brief return whether value is a floating-point number
-
-    This function returns true if and only if the JSON value is a
-    floating-point number. This excludes signed and unsigned integer values.
-
-    @return `true` if type is a floating-point number, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_number_float()` for all
-    JSON types.,is_number_float}
-
-    @sa @ref is_number() -- check if value is number
-    @sa @ref is_number_integer() -- check if value is an integer number
-    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
-    number
-
-    @since version 1.0.0
-    */
-    constexpr bool is_number_float() const noexcept
-    {
-        return m_type == value_t::number_float;
-    }
-
-    /*!
-    @brief return whether value is an object
-
-    This function returns true if and only if the JSON value is an object.
-
-    @return `true` if type is object, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_object()` for all JSON
-    types.,is_object}
-
-    @since version 1.0.0
-    */
-    constexpr bool is_object() const noexcept
-    {
-        return m_type == value_t::object;
-    }
-
-    /*!
-    @brief return whether value is an array
-
-    This function returns true if and only if the JSON value is an array.
-
-    @return `true` if type is array, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_array()` for all JSON
-    types.,is_array}
-
-    @since version 1.0.0
-    */
-    constexpr bool is_array() const noexcept
-    {
-        return m_type == value_t::array;
-    }
-
-    /*!
-    @brief return whether value is a string
-
-    This function returns true if and only if the JSON value is a string.
-
-    @return `true` if type is string, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_string()` for all JSON
-    types.,is_string}
-
-    @since version 1.0.0
-    */
-    constexpr bool is_string() const noexcept
-    {
-        return m_type == value_t::string;
-    }
-
-    /*!
-    @brief return whether value is a binary array
-
-    This function returns true if and only if the JSON value is a binary array.
-
-    @return `true` if type is binary array, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_binary()` for all JSON
-    types.,is_binary}
-
-    @since version 3.8.0
-    */
-    constexpr bool is_binary() const noexcept
-    {
-        return m_type == value_t::binary;
-    }
-
-    /*!
-    @brief return whether value is discarded
-
-    This function returns true if and only if the JSON value was discarded
-    during parsing with a callback function (see @ref parser_callback_t).
-
-    @note This function will always be `false` for JSON values after parsing.
-    That is, discarded values can only occur during parsing, but will be
-    removed when inside a structured value or replaced by null in other cases.
-
-    @return `true` if type is discarded, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_discarded()` for all JSON
-    types.,is_discarded}
-
-    @since version 1.0.0
-    */
-    constexpr bool is_discarded() const noexcept
-    {
-        return m_type == value_t::discarded;
-    }
-
-    /*!
-    @brief return the type of the JSON value (implicit)
-
-    Implicitly return the type of the JSON value as a value from the @ref
-    value_t enumeration.
-
-    @return the type of the JSON value
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies the @ref value_t operator for
-    all JSON types.,operator__value_t}
-
-    @sa @ref type() -- return the type of the JSON value (explicit)
-    @sa @ref type_name() -- return the type as string
-
-    @since version 1.0.0
-    */
-    constexpr operator value_t() const noexcept
-    {
-        return m_type;
-    }
-
-    /// @}
-
-  private:
-    //////////////////
-    // value access //
-    //////////////////
-
-    /// get a boolean (explicit)
-    boolean_t get_impl(boolean_t* /*unused*/) const
-    {
-        if (JSON_HEDLEY_LIKELY(is_boolean()))
-        {
-            return m_value.boolean;
-        }
-
-        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
-    }
-
-    /// get a pointer to the value (object)
-    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
-    {
-        return is_object() ? m_value.object : nullptr;
-    }
-
-    /// get a pointer to the value (object)
-    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
-    {
-        return is_object() ? m_value.object : nullptr;
-    }
-
-    /// get a pointer to the value (array)
-    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
-    {
-        return is_array() ? m_value.array : nullptr;
-    }
-
-    /// get a pointer to the value (array)
-    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
-    {
-        return is_array() ? m_value.array : nullptr;
-    }
-
-    /// get a pointer to the value (string)
-    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
-    {
-        return is_string() ? m_value.string : nullptr;
-    }
-
-    /// get a pointer to the value (string)
-    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
-    {
-        return is_string() ? m_value.string : nullptr;
-    }
-
-    /// get a pointer to the value (boolean)
-    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
-    {
-        return is_boolean() ? &m_value.boolean : nullptr;
-    }
-
-    /// get a pointer to the value (boolean)
-    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
-    {
-        return is_boolean() ? &m_value.boolean : nullptr;
-    }
-
-    /// get a pointer to the value (integer number)
-    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
-    {
-        return is_number_integer() ? &m_value.number_integer : nullptr;
-    }
-
-    /// get a pointer to the value (integer number)
-    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
-    {
-        return is_number_integer() ? &m_value.number_integer : nullptr;
-    }
-
-    /// get a pointer to the value (unsigned number)
-    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
-    {
-        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
-    }
-
-    /// get a pointer to the value (unsigned number)
-    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
-    {
-        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
-    }
-
-    /// get a pointer to the value (floating-point number)
-    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
-    {
-        return is_number_float() ? &m_value.number_float : nullptr;
-    }
-
-    /// get a pointer to the value (floating-point number)
-    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
-    {
-        return is_number_float() ? &m_value.number_float : nullptr;
-    }
-
-    /// get a pointer to the value (binary)
-    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
-    {
-        return is_binary() ? m_value.binary : nullptr;
-    }
-
-    /// get a pointer to the value (binary)
-    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
-    {
-        return is_binary() ? m_value.binary : nullptr;
-    }
-
-    /*!
-    @brief helper function to implement get_ref()
-
-    This function helps to implement get_ref() without code duplication for
-    const and non-const overloads
-
-    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
-
-    @throw type_error.303 if ReferenceType does not match underlying value
-    type of the current JSON
-    */
-    template<typename ReferenceType, typename ThisType>
-    static ReferenceType get_ref_impl(ThisType& obj)
-    {
-        // delegate the call to get_ptr<>()
-        auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
-
-        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
-        {
-            return *ptr;
-        }
-
-        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
-    }
-
-  public:
-    /// @name value access
-    /// Direct access to the stored value of a JSON value.
-    /// @{
-
-    /*!
-    @brief get special-case overload
-
-    This overloads avoids a lot of template boilerplate, it can be seen as the
-    identity method
-
-    @tparam BasicJsonType == @ref basic_json
-
-    @return a copy of *this
-
-    @complexity Constant.
-
-    @since version 2.1.0
-    */
-    template<typename BasicJsonType, detail::enable_if_t<
-                 std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
-                 int> = 0>
-    basic_json get() const
-    {
-        return *this;
-    }
-
-    /*!
-    @brief get special-case overload
-
-    This overloads converts the current @ref basic_json in a different
-    @ref basic_json type
-
-    @tparam BasicJsonType == @ref basic_json
-
-    @return a copy of *this, converted into @tparam BasicJsonType
-
-    @complexity Depending on the implementation of the called `from_json()`
-                method.
-
-    @since version 3.2.0
-    */
-    template < typename BasicJsonType, detail::enable_if_t <
-                   !std::is_same<BasicJsonType, basic_json>::value&&
-                   detail::is_basic_json<BasicJsonType>::value, int > = 0 >
-    BasicJsonType get() const
-    {
-        return *this;
-    }
-
-    /*!
-    @brief get a value (explicit)
-
-    Explicit type conversion between the JSON value and a compatible value
-    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
-    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
-    The value is converted by calling the @ref json_serializer<ValueType>
-    `from_json()` method.
-
-    The function is equivalent to executing
-    @code {.cpp}
-    ValueType ret;
-    JSONSerializer<ValueType>::from_json(*this, ret);
-    return ret;
-    @endcode
-
-    This overloads is chosen if:
-    - @a ValueType is not @ref basic_json,
-    - @ref json_serializer<ValueType> has a `from_json()` method of the form
-      `void from_json(const basic_json&, ValueType&)`, and
-    - @ref json_serializer<ValueType> does not have a `from_json()` method of
-      the form `ValueType from_json(const basic_json&)`
-
-    @tparam ValueTypeCV the provided value type
-    @tparam ValueType the returned value type
-
-    @return copy of the JSON value, converted to @a ValueType
-
-    @throw what @ref json_serializer<ValueType> `from_json()` method throws
-
-    @liveexample{The example below shows several conversions from JSON values
-    to other types. There a few things to note: (1) Floating-point numbers can
-    be converted to integers\, (2) A JSON array can be converted to a standard
-    `std::vector<short>`\, (3) A JSON object can be converted to C++
-    associative containers such as `std::unordered_map<std::string\,
-    json>`.,get__ValueType_const}
-
-    @since version 2.1.0
-    */
-    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
-               detail::enable_if_t <
-                   !detail::is_basic_json<ValueType>::value &&
-                   detail::has_from_json<basic_json_t, ValueType>::value &&
-                   !detail::has_non_default_from_json<basic_json_t, ValueType>::value,
-                   int > = 0 >
-    ValueType get() const noexcept(noexcept(
-                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
-    {
-        // we cannot static_assert on ValueTypeCV being non-const, because
-        // there is support for get<const basic_json_t>(), which is why we
-        // still need the uncvref
-        static_assert(!std::is_reference<ValueTypeCV>::value,
-                      "get() cannot be used with reference types, you might want to use get_ref()");
-        static_assert(std::is_default_constructible<ValueType>::value,
-                      "types must be DefaultConstructible when used with get()");
-
-        ValueType ret;
-        JSONSerializer<ValueType>::from_json(*this, ret);
-        return ret;
-    }
-
-    /*!
-    @brief get a value (explicit); special case
-
-    Explicit type conversion between the JSON value and a compatible value
-    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
-    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
-    The value is converted by calling the @ref json_serializer<ValueType>
-    `from_json()` method.
-
-    The function is equivalent to executing
-    @code {.cpp}
-    return JSONSerializer<ValueTypeCV>::from_json(*this);
-    @endcode
-
-    This overloads is chosen if:
-    - @a ValueType is not @ref basic_json and
-    - @ref json_serializer<ValueType> has a `from_json()` method of the form
-      `ValueType from_json(const basic_json&)`
-
-    @note If @ref json_serializer<ValueType> has both overloads of
-    `from_json()`, this one is chosen.
-
-    @tparam ValueTypeCV the provided value type
-    @tparam ValueType the returned value type
-
-    @return copy of the JSON value, converted to @a ValueType
-
-    @throw what @ref json_serializer<ValueType> `from_json()` method throws
-
-    @since version 2.1.0
-    */
-    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
-               detail::enable_if_t < !std::is_same<basic_json_t, ValueType>::value &&
-                                     detail::has_non_default_from_json<basic_json_t, ValueType>::value,
-                                     int > = 0 >
-    ValueType get() const noexcept(noexcept(
-                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
-    {
-        static_assert(!std::is_reference<ValueTypeCV>::value,
-                      "get() cannot be used with reference types, you might want to use get_ref()");
-        return JSONSerializer<ValueType>::from_json(*this);
-    }
-
-    /*!
-    @brief get a value (explicit)
-
-    Explicit type conversion between the JSON value and a compatible value.
-    The value is filled into the input parameter by calling the @ref json_serializer<ValueType>
-    `from_json()` method.
-
-    The function is equivalent to executing
-    @code {.cpp}
-    ValueType v;
-    JSONSerializer<ValueType>::from_json(*this, v);
-    @endcode
-
-    This overloads is chosen if:
-    - @a ValueType is not @ref basic_json,
-    - @ref json_serializer<ValueType> has a `from_json()` method of the form
-      `void from_json(const basic_json&, ValueType&)`, and
-
-    @tparam ValueType the input parameter type.
-
-    @return the input parameter, allowing chaining calls.
-
-    @throw what @ref json_serializer<ValueType> `from_json()` method throws
-
-    @liveexample{The example below shows several conversions from JSON values
-    to other types. There a few things to note: (1) Floating-point numbers can
-    be converted to integers\, (2) A JSON array can be converted to a standard
-    `std::vector<short>`\, (3) A JSON object can be converted to C++
-    associative containers such as `std::unordered_map<std::string\,
-    json>`.,get_to}
-
-    @since version 3.3.0
-    */
-    template < typename ValueType,
-               detail::enable_if_t <
-                   !detail::is_basic_json<ValueType>::value&&
-                   detail::has_from_json<basic_json_t, ValueType>::value,
-                   int > = 0 >
-    ValueType & get_to(ValueType& v) const noexcept(noexcept(
-                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
-    {
-        JSONSerializer<ValueType>::from_json(*this, v);
-        return v;
-    }
-
-    // specialization to allow to call get_to with a basic_json value
-    // see https://github.com/nlohmann/json/issues/2175
-    template<typename ValueType,
-             detail::enable_if_t <
-                 detail::is_basic_json<ValueType>::value,
-                 int> = 0>
-    ValueType & get_to(ValueType& v) const
-    {
-        v = *this;
-        return v;
-    }
-
-    template <
-        typename T, std::size_t N,
-        typename Array = T (&)[N],
-        detail::enable_if_t <
-            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
-    Array get_to(T (&v)[N]) const
-    noexcept(noexcept(JSONSerializer<Array>::from_json(
-                          std::declval<const basic_json_t&>(), v)))
-    {
-        JSONSerializer<Array>::from_json(*this, v);
-        return v;
-    }
-
-
-    /*!
-    @brief get a pointer value (implicit)
-
-    Implicit pointer access to the internally stored JSON value. No copies are
-    made.
-
-    @warning Writing data to the pointee of the result yields an undefined
-    state.
-
-    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
-    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
-    @ref number_unsigned_t, or @ref number_float_t. Enforced by a static
-    assertion.
-
-    @return pointer to the internally stored JSON value if the requested
-    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how pointers to internal values of a
-    JSON value can be requested. Note that no type conversions are made and a
-    `nullptr` is returned if the value and the requested pointer type does not
-    match.,get_ptr}
-
-    @since version 1.0.0
-    */
-    template<typename PointerType, typename std::enable_if<
-                 std::is_pointer<PointerType>::value, int>::type = 0>
-    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
-    {
-        // delegate the call to get_impl_ptr<>()
-        return get_impl_ptr(static_cast<PointerType>(nullptr));
-    }
-
-    /*!
-    @brief get a pointer value (implicit)
-    @copydoc get_ptr()
-    */
-    template < typename PointerType, typename std::enable_if <
-                   std::is_pointer<PointerType>::value&&
-                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
-    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
-    {
-        // delegate the call to get_impl_ptr<>() const
-        return get_impl_ptr(static_cast<PointerType>(nullptr));
-    }
-
-    /*!
-    @brief get a pointer value (explicit)
-
-    Explicit pointer access to the internally stored JSON value. No copies are
-    made.
-
-    @warning The pointer becomes invalid if the underlying JSON object
-    changes.
-
-    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
-    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
-    @ref number_unsigned_t, or @ref number_float_t.
-
-    @return pointer to the internally stored JSON value if the requested
-    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how pointers to internal values of a
-    JSON value can be requested. Note that no type conversions are made and a
-    `nullptr` is returned if the value and the requested pointer type does not
-    match.,get__PointerType}
-
-    @sa @ref get_ptr() for explicit pointer-member access
-
-    @since version 1.0.0
-    */
-    template<typename PointerType, typename std::enable_if<
-                 std::is_pointer<PointerType>::value, int>::type = 0>
-    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
-    {
-        // delegate the call to get_ptr
-        return get_ptr<PointerType>();
-    }
-
-    /*!
-    @brief get a pointer value (explicit)
-    @copydoc get()
-    */
-    template<typename PointerType, typename std::enable_if<
-                 std::is_pointer<PointerType>::value, int>::type = 0>
-    constexpr auto get() const noexcept -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
-    {
-        // delegate the call to get_ptr
-        return get_ptr<PointerType>();
-    }
-
-    /*!
-    @brief get a reference value (implicit)
-
-    Implicit reference access to the internally stored JSON value. No copies
-    are made.
-
-    @warning Writing data to the referee of the result yields an undefined
-    state.
-
-    @tparam ReferenceType reference type; must be a reference to @ref array_t,
-    @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
-    @ref number_float_t. Enforced by static assertion.
-
-    @return reference to the internally stored JSON value if the requested
-    reference type @a ReferenceType fits to the JSON value; throws
-    type_error.303 otherwise
-
-    @throw type_error.303 in case passed type @a ReferenceType is incompatible
-    with the stored JSON value; see example below
-
-    @complexity Constant.
-
-    @liveexample{The example shows several calls to `get_ref()`.,get_ref}
-
-    @since version 1.1.0
-    */
-    template<typename ReferenceType, typename std::enable_if<
-                 std::is_reference<ReferenceType>::value, int>::type = 0>
-    ReferenceType get_ref()
-    {
-        // delegate call to get_ref_impl
-        return get_ref_impl<ReferenceType>(*this);
-    }
-
-    /*!
-    @brief get a reference value (implicit)
-    @copydoc get_ref()
-    */
-    template < typename ReferenceType, typename std::enable_if <
-                   std::is_reference<ReferenceType>::value&&
-                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
-    ReferenceType get_ref() const
-    {
-        // delegate call to get_ref_impl
-        return get_ref_impl<ReferenceType>(*this);
-    }
-
-    /*!
-    @brief get a value (implicit)
-
-    Implicit type conversion between the JSON value and a compatible value.
-    The call is realized by calling @ref get() const.
-
-    @tparam ValueType non-pointer type compatible to the JSON value, for
-    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
-    `std::vector` types for JSON arrays. The character type of @ref string_t
-    as well as an initializer list of this type is excluded to avoid
-    ambiguities as these types implicitly convert to `std::string`.
-
-    @return copy of the JSON value, converted to type @a ValueType
-
-    @throw type_error.302 in case passed type @a ValueType is incompatible
-    to the JSON value type (e.g., the JSON value is of type boolean, but a
-    string is requested); see example below
-
-    @complexity Linear in the size of the JSON value.
-
-    @liveexample{The example below shows several conversions from JSON values
-    to other types. There a few things to note: (1) Floating-point numbers can
-    be converted to integers\, (2) A JSON array can be converted to a standard
-    `std::vector<short>`\, (3) A JSON object can be converted to C++
-    associative containers such as `std::unordered_map<std::string\,
-    json>`.,operator__ValueType}
-
-    @since version 1.0.0
-    */
-    template < typename ValueType, typename std::enable_if <
-                   !std::is_pointer<ValueType>::value&&
-                   !std::is_same<ValueType, detail::json_ref<basic_json>>::value&&
-                   !std::is_same<ValueType, typename string_t::value_type>::value&&
-                   !detail::is_basic_json<ValueType>::value
-                   && !std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
-#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
-                   && !std::is_same<ValueType, typename std::string_view>::value
-#endif
-                   && detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
-                   , int >::type = 0 >
-    JSON_EXPLICIT operator ValueType() const
-    {
-        // delegate the call to get<>() const
-        return get<ValueType>();
-    }
-
-    /*!
-    @return reference to the binary value
-
-    @throw type_error.302 if the value is not binary
-
-    @sa @ref is_binary() to check if the value is binary
-
-    @since version 3.8.0
-    */
-    binary_t& get_binary()
-    {
-        if (!is_binary())
-        {
-            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
-        }
-
-        return *get_ptr<binary_t*>();
-    }
-
-    /// @copydoc get_binary()
-    const binary_t& get_binary() const
-    {
-        if (!is_binary())
-        {
-            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
-        }
-
-        return *get_ptr<const binary_t*>();
-    }
-
-    /// @}
-
-
-    ////////////////////
-    // element access //
-    ////////////////////
-
-    /// @name element access
-    /// Access to the JSON value.
-    /// @{
-
-    /*!
-    @brief access specified array element with bounds checking
-
-    Returns a reference to the element at specified location @a idx, with
-    bounds checking.
-
-    @param[in] idx  index of the element to access
-
-    @return reference to the element at index @a idx
-
-    @throw type_error.304 if the JSON value is not an array; in this case,
-    calling `at` with an index makes no sense. See example below.
-    @throw out_of_range.401 if the index @a idx is out of range of the array;
-    that is, `idx >= size()`. See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 1.0.0
-
-    @liveexample{The example below shows how array elements can be read and
-    written using `at()`. It also demonstrates the different exceptions that
-    can be thrown.,at__size_type}
-    */
-    reference at(size_type idx)
-    {
-        // at only works for arrays
-        if (JSON_HEDLEY_LIKELY(is_array()))
-        {
-            JSON_TRY
-            {
-                return m_value.array->at(idx);
-            }
-            JSON_CATCH (std::out_of_range&)
-            {
-                // create better exception explanation
-                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
-            }
-        }
-        else
-        {
-            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
-        }
-    }
-
-    /*!
-    @brief access specified array element with bounds checking
-
-    Returns a const reference to the element at specified location @a idx,
-    with bounds checking.
-
-    @param[in] idx  index of the element to access
-
-    @return const reference to the element at index @a idx
-
-    @throw type_error.304 if the JSON value is not an array; in this case,
-    calling `at` with an index makes no sense. See example below.
-    @throw out_of_range.401 if the index @a idx is out of range of the array;
-    that is, `idx >= size()`. See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 1.0.0
-
-    @liveexample{The example below shows how array elements can be read using
-    `at()`. It also demonstrates the different exceptions that can be thrown.,
-    at__size_type_const}
-    */
-    const_reference at(size_type idx) const
-    {
-        // at only works for arrays
-        if (JSON_HEDLEY_LIKELY(is_array()))
-        {
-            JSON_TRY
-            {
-                return m_value.array->at(idx);
-            }
-            JSON_CATCH (std::out_of_range&)
-            {
-                // create better exception explanation
-                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
-            }
-        }
-        else
-        {
-            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
-        }
-    }
-
-    /*!
-    @brief access specified object element with bounds checking
-
-    Returns a reference to the element at with specified key @a key, with
-    bounds checking.
-
-    @param[in] key  key of the element to access
-
-    @return reference to the element at key @a key
-
-    @throw type_error.304 if the JSON value is not an object; in this case,
-    calling `at` with a key makes no sense. See example below.
-    @throw out_of_range.403 if the key @a key is is not stored in the object;
-    that is, `find(key) == end()`. See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Logarithmic in the size of the container.
-
-    @sa @ref operator[](const typename object_t::key_type&) for unchecked
-    access by reference
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.0.0
-
-    @liveexample{The example below shows how object elements can be read and
-    written using `at()`. It also demonstrates the different exceptions that
-    can be thrown.,at__object_t_key_type}
-    */
-    reference at(const typename object_t::key_type& key)
-    {
-        // at only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            JSON_TRY
-            {
-                return m_value.object->at(key);
-            }
-            JSON_CATCH (std::out_of_range&)
-            {
-                // create better exception explanation
-                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
-            }
-        }
-        else
-        {
-            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
-        }
-    }
-
-    /*!
-    @brief access specified object element with bounds checking
-
-    Returns a const reference to the element at with specified key @a key,
-    with bounds checking.
-
-    @param[in] key  key of the element to access
-
-    @return const reference to the element at key @a key
-
-    @throw type_error.304 if the JSON value is not an object; in this case,
-    calling `at` with a key makes no sense. See example below.
-    @throw out_of_range.403 if the key @a key is is not stored in the object;
-    that is, `find(key) == end()`. See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Logarithmic in the size of the container.
-
-    @sa @ref operator[](const typename object_t::key_type&) for unchecked
-    access by reference
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.0.0
-
-    @liveexample{The example below shows how object elements can be read using
-    `at()`. It also demonstrates the different exceptions that can be thrown.,
-    at__object_t_key_type_const}
-    */
-    const_reference at(const typename object_t::key_type& key) const
-    {
-        // at only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            JSON_TRY
-            {
-                return m_value.object->at(key);
-            }
-            JSON_CATCH (std::out_of_range&)
-            {
-                // create better exception explanation
-                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
-            }
-        }
-        else
-        {
-            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
-        }
-    }
-
-    /*!
-    @brief access specified array element
-
-    Returns a reference to the element at specified location @a idx.
-
-    @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
-    then the array is silently filled up with `null` values to make `idx` a
-    valid reference to the last stored element.
-
-    @param[in] idx  index of the element to access
-
-    @return reference to the element at index @a idx
-
-    @throw type_error.305 if the JSON value is not an array or null; in that
-    cases, using the [] operator with an index makes no sense.
-
-    @complexity Constant if @a idx is in the range of the array. Otherwise
-    linear in `idx - size()`.
-
-    @liveexample{The example below shows how array elements can be read and
-    written using `[]` operator. Note the addition of `null`
-    values.,operatorarray__size_type}
-
-    @since version 1.0.0
-    */
-    reference operator[](size_type idx)
-    {
-        // implicitly convert null value to an empty array
-        if (is_null())
-        {
-            m_type = value_t::array;
-            m_value.array = create<array_t>();
-            assert_invariant();
-        }
-
-        // operator[] only works for arrays
-        if (JSON_HEDLEY_LIKELY(is_array()))
-        {
-            // fill up array with null values if given idx is outside range
-            if (idx >= m_value.array->size())
-            {
-                m_value.array->insert(m_value.array->end(),
-                                      idx - m_value.array->size() + 1,
-                                      basic_json());
-            }
-
-            return m_value.array->operator[](idx);
-        }
-
-        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief access specified array element
-
-    Returns a const reference to the element at specified location @a idx.
-
-    @param[in] idx  index of the element to access
-
-    @return const reference to the element at index @a idx
-
-    @throw type_error.305 if the JSON value is not an array; in that case,
-    using the [] operator with an index makes no sense.
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how array elements can be read using
-    the `[]` operator.,operatorarray__size_type_const}
-
-    @since version 1.0.0
-    */
-    const_reference operator[](size_type idx) const
-    {
-        // const operator[] only works for arrays
-        if (JSON_HEDLEY_LIKELY(is_array()))
-        {
-            return m_value.array->operator[](idx);
-        }
-
-        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief access specified object element
-
-    Returns a reference to the element at with specified key @a key.
-
-    @note If @a key is not found in the object, then it is silently added to
-    the object and filled with a `null` value to make `key` a valid reference.
-    In case the value was `null` before, it is converted to an object.
-
-    @param[in] key  key of the element to access
-
-    @return reference to the element at key @a key
-
-    @throw type_error.305 if the JSON value is not an object or null; in that
-    cases, using the [] operator with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be read and
-    written using the `[]` operator.,operatorarray__key_type}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.0.0
-    */
-    reference operator[](const typename object_t::key_type& key)
-    {
-        // implicitly convert null value to an empty object
-        if (is_null())
-        {
-            m_type = value_t::object;
-            m_value.object = create<object_t>();
-            assert_invariant();
-        }
-
-        // operator[] only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            return m_value.object->operator[](key);
-        }
-
-        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief read-only access specified object element
-
-    Returns a const reference to the element at with specified key @a key. No
-    bounds checking is performed.
-
-    @warning If the element with key @a key does not exist, the behavior is
-    undefined.
-
-    @param[in] key  key of the element to access
-
-    @return const reference to the element at key @a key
-
-    @pre The element with key @a key must exist. **This precondition is
-         enforced with an assertion.**
-
-    @throw type_error.305 if the JSON value is not an object; in that case,
-    using the [] operator with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be read using
-    the `[]` operator.,operatorarray__key_type_const}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.0.0
-    */
-    const_reference operator[](const typename object_t::key_type& key) const
-    {
-        // const operator[] only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
-            return m_value.object->find(key)->second;
-        }
-
-        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief access specified object element
-
-    Returns a reference to the element at with specified key @a key.
-
-    @note If @a key is not found in the object, then it is silently added to
-    the object and filled with a `null` value to make `key` a valid reference.
-    In case the value was `null` before, it is converted to an object.
-
-    @param[in] key  key of the element to access
-
-    @return reference to the element at key @a key
-
-    @throw type_error.305 if the JSON value is not an object or null; in that
-    cases, using the [] operator with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be read and
-    written using the `[]` operator.,operatorarray__key_type}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.1.0
-    */
-    template<typename T>
-    JSON_HEDLEY_NON_NULL(2)
-    reference operator[](T* key)
-    {
-        // implicitly convert null to object
-        if (is_null())
-        {
-            m_type = value_t::object;
-            m_value = value_t::object;
-            assert_invariant();
-        }
-
-        // at only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            return m_value.object->operator[](key);
-        }
-
-        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief read-only access specified object element
-
-    Returns a const reference to the element at with specified key @a key. No
-    bounds checking is performed.
-
-    @warning If the element with key @a key does not exist, the behavior is
-    undefined.
-
-    @param[in] key  key of the element to access
-
-    @return const reference to the element at key @a key
-
-    @pre The element with key @a key must exist. **This precondition is
-         enforced with an assertion.**
-
-    @throw type_error.305 if the JSON value is not an object; in that case,
-    using the [] operator with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be read using
-    the `[]` operator.,operatorarray__key_type_const}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.1.0
-    */
-    template<typename T>
-    JSON_HEDLEY_NON_NULL(2)
-    const_reference operator[](T* key) const
-    {
-        // at only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
-            return m_value.object->find(key)->second;
-        }
-
-        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief access specified object element with default value
-
-    Returns either a copy of an object's element at the specified key @a key
-    or a given default value if no element with key @a key exists.
-
-    The function is basically equivalent to executing
-    @code {.cpp}
-    try {
-        return at(key);
-    } catch(out_of_range) {
-        return default_value;
-    }
-    @endcode
-
-    @note Unlike @ref at(const typename object_t::key_type&), this function
-    does not throw if the given key @a key was not found.
-
-    @note Unlike @ref operator[](const typename object_t::key_type& key), this
-    function does not implicitly add an element to the position defined by @a
-    key. This function is furthermore also applicable to const objects.
-
-    @param[in] key  key of the element to access
-    @param[in] default_value  the value to return if @a key is not found
-
-    @tparam ValueType type compatible to JSON values, for instance `int` for
-    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
-    JSON arrays. Note the type of the expected value at @a key and the default
-    value @a default_value must be compatible.
-
-    @return copy of the element at key @a key or @a default_value if @a key
-    is not found
-
-    @throw type_error.302 if @a default_value does not match the type of the
-    value at @a key
-    @throw type_error.306 if the JSON value is not an object; in that case,
-    using `value()` with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be queried
-    with a default value.,basic_json__value}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref operator[](const typename object_t::key_type&) for unchecked
-    access by reference
-
-    @since version 1.0.0
-    */
-    // using std::is_convertible in a std::enable_if will fail when using explicit conversions
-    template < class ValueType, typename std::enable_if <
-                   detail::is_getable<basic_json_t, ValueType>::value
-                   && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
-    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
-    {
-        // at only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            // if key is found, return value and given default value otherwise
-            const auto it = find(key);
-            if (it != end())
-            {
-                return it->template get<ValueType>();
-            }
-
-            return default_value;
-        }
-
-        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief overload for a default value of type const char*
-    @copydoc basic_json::value(const typename object_t::key_type&, const ValueType&) const
-    */
-    string_t value(const typename object_t::key_type& key, const char* default_value) const
-    {
-        return value(key, string_t(default_value));
-    }
-
-    /*!
-    @brief access specified object element via JSON Pointer with default value
-
-    Returns either a copy of an object's element at the specified key @a key
-    or a given default value if no element with key @a key exists.
-
-    The function is basically equivalent to executing
-    @code {.cpp}
-    try {
-        return at(ptr);
-    } catch(out_of_range) {
-        return default_value;
-    }
-    @endcode
-
-    @note Unlike @ref at(const json_pointer&), this function does not throw
-    if the given key @a key was not found.
-
-    @param[in] ptr  a JSON pointer to the element to access
-    @param[in] default_value  the value to return if @a ptr found no value
-
-    @tparam ValueType type compatible to JSON values, for instance `int` for
-    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
-    JSON arrays. Note the type of the expected value at @a key and the default
-    value @a default_value must be compatible.
-
-    @return copy of the element at key @a key or @a default_value if @a key
-    is not found
-
-    @throw type_error.302 if @a default_value does not match the type of the
-    value at @a ptr
-    @throw type_error.306 if the JSON value is not an object; in that case,
-    using `value()` with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be queried
-    with a default value.,basic_json__value_ptr}
-
-    @sa @ref operator[](const json_pointer&) for unchecked access by reference
-
-    @since version 2.0.2
-    */
-    template<class ValueType, typename std::enable_if<
-                 detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
-    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
-    {
-        // at only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            // if pointer resolves a value, return it or use default value
-            JSON_TRY
-            {
-                return ptr.get_checked(this).template get<ValueType>();
-            }
-            JSON_INTERNAL_CATCH (out_of_range&)
-            {
-                return default_value;
-            }
-        }
-
-        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief overload for a default value of type const char*
-    @copydoc basic_json::value(const json_pointer&, ValueType) const
-    */
-    JSON_HEDLEY_NON_NULL(3)
-    string_t value(const json_pointer& ptr, const char* default_value) const
-    {
-        return value(ptr, string_t(default_value));
-    }
-
-    /*!
-    @brief access the first element
-
-    Returns a reference to the first element in the container. For a JSON
-    container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
-
-    @return In case of a structured type (array or object), a reference to the
-    first element is returned. In case of number, string, boolean, or binary
-    values, a reference to the value is returned.
-
-    @complexity Constant.
-
-    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
-    or an empty array or object (undefined behavior, **guarded by
-    assertions**).
-    @post The JSON value remains unchanged.
-
-    @throw invalid_iterator.214 when called on `null` value
-
-    @liveexample{The following code shows an example for `front()`.,front}
-
-    @sa @ref back() -- access the last element
-
-    @since version 1.0.0
-    */
-    reference front()
-    {
-        return *begin();
-    }
-
-    /*!
-    @copydoc basic_json::front()
-    */
-    const_reference front() const
-    {
-        return *cbegin();
-    }
-
-    /*!
-    @brief access the last element
-
-    Returns a reference to the last element in the container. For a JSON
-    container `c`, the expression `c.back()` is equivalent to
-    @code {.cpp}
-    auto tmp = c.end();
-    --tmp;
-    return *tmp;
-    @endcode
-
-    @return In case of a structured type (array or object), a reference to the
-    last element is returned. In case of number, string, boolean, or binary
-    values, a reference to the value is returned.
-
-    @complexity Constant.
-
-    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
-    or an empty array or object (undefined behavior, **guarded by
-    assertions**).
-    @post The JSON value remains unchanged.
-
-    @throw invalid_iterator.214 when called on a `null` value. See example
-    below.
-
-    @liveexample{The following code shows an example for `back()`.,back}
-
-    @sa @ref front() -- access the first element
-
-    @since version 1.0.0
-    */
-    reference back()
-    {
-        auto tmp = end();
-        --tmp;
-        return *tmp;
-    }
-
-    /*!
-    @copydoc basic_json::back()
-    */
-    const_reference back() const
-    {
-        auto tmp = cend();
-        --tmp;
-        return *tmp;
-    }
-
-    /*!
-    @brief remove element given an iterator
-
-    Removes the element specified by iterator @a pos. The iterator @a pos must
-    be valid and dereferenceable. Thus the `end()` iterator (which is valid,
-    but is not dereferenceable) cannot be used as a value for @a pos.
-
-    If called on a primitive type other than `null`, the resulting JSON value
-    will be `null`.
-
-    @param[in] pos iterator to the element to remove
-    @return Iterator following the last removed element. If the iterator @a
-    pos refers to the last element, the `end()` iterator is returned.
-
-    @tparam IteratorType an @ref iterator or @ref const_iterator
-
-    @post Invalidates iterators and references at or after the point of the
-    erase, including the `end()` iterator.
-
-    @throw type_error.307 if called on a `null` value; example: `"cannot use
-    erase() with null"`
-    @throw invalid_iterator.202 if called on an iterator which does not belong
-    to the current JSON value; example: `"iterator does not fit current
-    value"`
-    @throw invalid_iterator.205 if called on a primitive type with invalid
-    iterator (i.e., any iterator which is not `begin()`); example: `"iterator
-    out of range"`
-
-    @complexity The complexity depends on the type:
-    - objects: amortized constant
-    - arrays: linear in distance between @a pos and the end of the container
-    - strings and binary: linear in the length of the member
-    - other types: constant
-
-    @liveexample{The example shows the result of `erase()` for different JSON
-    types.,erase__IteratorType}
-
-    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
-    the given range
-    @sa @ref erase(const typename object_t::key_type&) -- removes the element
-    from an object at the given key
-    @sa @ref erase(const size_type) -- removes the element from an array at
-    the given index
-
-    @since version 1.0.0
-    */
-    template < class IteratorType, typename std::enable_if <
-                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
-                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
-               = 0 >
-    IteratorType erase(IteratorType pos)
-    {
-        // make sure iterator fits the current value
-        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
-        {
-            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-        }
-
-        IteratorType result = end();
-
-        switch (m_type)
-        {
-            case value_t::boolean:
-            case value_t::number_float:
-            case value_t::number_integer:
-            case value_t::number_unsigned:
-            case value_t::string:
-            case value_t::binary:
-            {
-                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
-                {
-                    JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
-                }
-
-                if (is_string())
-                {
-                    AllocatorType<string_t> alloc;
-                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
-                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
-                    m_value.string = nullptr;
-                }
-                else if (is_binary())
-                {
-                    AllocatorType<binary_t> alloc;
-                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
-                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
-                    m_value.binary = nullptr;
-                }
-
-                m_type = value_t::null;
-                assert_invariant();
-                break;
-            }
-
-            case value_t::object:
-            {
-                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
-                break;
-            }
-
-            case value_t::array:
-            {
-                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
-                break;
-            }
-
-            default:
-                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
-        }
-
-        return result;
-    }
-
-    /*!
-    @brief remove elements given an iterator range
-
-    Removes the element specified by the range `[first; last)`. The iterator
-    @a first does not need to be dereferenceable if `first == last`: erasing
-    an empty range is a no-op.
-
-    If called on a primitive type other than `null`, the resulting JSON value
-    will be `null`.
-
-    @param[in] first iterator to the beginning of the range to remove
-    @param[in] last iterator past the end of the range to remove
-    @return Iterator following the last removed element. If the iterator @a
-    second refers to the last element, the `end()` iterator is returned.
-
-    @tparam IteratorType an @ref iterator or @ref const_iterator
-
-    @post Invalidates iterators and references at or after the point of the
-    erase, including the `end()` iterator.
-
-    @throw type_error.307 if called on a `null` value; example: `"cannot use
-    erase() with null"`
-    @throw invalid_iterator.203 if called on iterators which does not belong
-    to the current JSON value; example: `"iterators do not fit current value"`
-    @throw invalid_iterator.204 if called on a primitive type with invalid
-    iterators (i.e., if `first != begin()` and `last != end()`); example:
-    `"iterators out of range"`
-
-    @complexity The complexity depends on the type:
-    - objects: `log(size()) + std::distance(first, last)`
-    - arrays: linear in the distance between @a first and @a last, plus linear
-      in the distance between @a last and end of the container
-    - strings and binary: linear in the length of the member
-    - other types: constant
-
-    @liveexample{The example shows the result of `erase()` for different JSON
-    types.,erase__IteratorType_IteratorType}
-
-    @sa @ref erase(IteratorType) -- removes the element at a given position
-    @sa @ref erase(const typename object_t::key_type&) -- removes the element
-    from an object at the given key
-    @sa @ref erase(const size_type) -- removes the element from an array at
-    the given index
-
-    @since version 1.0.0
-    */
-    template < class IteratorType, typename std::enable_if <
-                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
-                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
-               = 0 >
-    IteratorType erase(IteratorType first, IteratorType last)
-    {
-        // make sure iterator fits the current value
-        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
-        {
-            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
-        }
-
-        IteratorType result = end();
-
-        switch (m_type)
-        {
-            case value_t::boolean:
-            case value_t::number_float:
-            case value_t::number_integer:
-            case value_t::number_unsigned:
-            case value_t::string:
-            case value_t::binary:
-            {
-                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
-                                       || !last.m_it.primitive_iterator.is_end()))
-                {
-                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
-                }
-
-                if (is_string())
-                {
-                    AllocatorType<string_t> alloc;
-                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
-                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
-                    m_value.string = nullptr;
-                }
-                else if (is_binary())
-                {
-                    AllocatorType<binary_t> alloc;
-                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
-                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
-                    m_value.binary = nullptr;
-                }
-
-                m_type = value_t::null;
-                assert_invariant();
-                break;
-            }
-
-            case value_t::object:
-            {
-                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
-                                              last.m_it.object_iterator);
-                break;
-            }
-
-            case value_t::array:
-            {
-                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
-                                             last.m_it.array_iterator);
-                break;
-            }
-
-            default:
-                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
-        }
-
-        return result;
-    }
-
-    /*!
-    @brief remove element from a JSON object given a key
-
-    Removes elements from a JSON object with the key value @a key.
-
-    @param[in] key value of the elements to remove
-
-    @return Number of elements removed. If @a ObjectType is the default
-    `std::map` type, the return value will always be `0` (@a key was not
-    found) or `1` (@a key was found).
-
-    @post References and iterators to the erased elements are invalidated.
-    Other references and iterators are not affected.
-
-    @throw type_error.307 when called on a type other than JSON object;
-    example: `"cannot use erase() with null"`
-
-    @complexity `log(size()) + count(key)`
-
-    @liveexample{The example shows the effect of `erase()`.,erase__key_type}
-
-    @sa @ref erase(IteratorType) -- removes the element at a given position
-    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
-    the given range
-    @sa @ref erase(const size_type) -- removes the element from an array at
-    the given index
-
-    @since version 1.0.0
-    */
-    size_type erase(const typename object_t::key_type& key)
-    {
-        // this erase only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            return m_value.object->erase(key);
-        }
-
-        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief remove element from a JSON array given an index
-
-    Removes element from a JSON array at the index @a idx.
-
-    @param[in] idx index of the element to remove
-
-    @throw type_error.307 when called on a type other than JSON object;
-    example: `"cannot use erase() with null"`
-    @throw out_of_range.401 when `idx >= size()`; example: `"array index 17
-    is out of range"`
-
-    @complexity Linear in distance between @a idx and the end of the container.
-
-    @liveexample{The example shows the effect of `erase()`.,erase__size_type}
-
-    @sa @ref erase(IteratorType) -- removes the element at a given position
-    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
-    the given range
-    @sa @ref erase(const typename object_t::key_type&) -- removes the element
-    from an object at the given key
-
-    @since version 1.0.0
-    */
-    void erase(const size_type idx)
-    {
-        // this erase only works for arrays
-        if (JSON_HEDLEY_LIKELY(is_array()))
-        {
-            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
-            {
-                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
-            }
-
-            m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
-        }
-        else
-        {
-            JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
-        }
-    }
-
-    /// @}
-
-
-    ////////////
-    // lookup //
-    ////////////
-
-    /// @name lookup
-    /// @{
-
-    /*!
-    @brief find an element in a JSON object
-
-    Finds an element in a JSON object with key equivalent to @a key. If the
-    element is not found or the JSON value is not an object, end() is
-    returned.
-
-    @note This method always returns @ref end() when executed on a JSON type
-          that is not an object.
-
-    @param[in] key key value of the element to search for.
-
-    @return Iterator to an element with key equivalent to @a key. If no such
-    element is found or the JSON value is not an object, past-the-end (see
-    @ref end()) iterator is returned.
-
-    @complexity Logarithmic in the size of the JSON object.
-
-    @liveexample{The example shows how `find()` is used.,find__key_type}
-
-    @sa @ref contains(KeyT&&) const -- checks whether a key exists
-
-    @since version 1.0.0
-    */
-    template<typename KeyT>
-    iterator find(KeyT&& key)
-    {
-        auto result = end();
-
-        if (is_object())
-        {
-            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
-        }
-
-        return result;
-    }
-
-    /*!
-    @brief find an element in a JSON object
-    @copydoc find(KeyT&&)
-    */
-    template<typename KeyT>
-    const_iterator find(KeyT&& key) const
-    {
-        auto result = cend();
-
-        if (is_object())
-        {
-            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
-        }
-
-        return result;
-    }
-
-    /*!
-    @brief returns the number of occurrences of a key in a JSON object
-
-    Returns the number of elements with key @a key. If ObjectType is the
-    default `std::map` type, the return value will always be `0` (@a key was
-    not found) or `1` (@a key was found).
-
-    @note This method always returns `0` when executed on a JSON type that is
-          not an object.
-
-    @param[in] key key value of the element to count
-
-    @return Number of elements with key @a key. If the JSON value is not an
-    object, the return value will be `0`.
-
-    @complexity Logarithmic in the size of the JSON object.
-
-    @liveexample{The example shows how `count()` is used.,count}
-
-    @since version 1.0.0
-    */
-    template<typename KeyT>
-    size_type count(KeyT&& key) const
-    {
-        // return 0 for all nonobject types
-        return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
-    }
-
-    /*!
-    @brief check the existence of an element in a JSON object
-
-    Check whether an element exists in a JSON object with key equivalent to
-    @a key. If the element is not found or the JSON value is not an object,
-    false is returned.
-
-    @note This method always returns false when executed on a JSON type
-          that is not an object.
-
-    @param[in] key key value to check its existence.
-
-    @return true if an element with specified @a key exists. If no such
-    element with such key is found or the JSON value is not an object,
-    false is returned.
-
-    @complexity Logarithmic in the size of the JSON object.
-
-    @liveexample{The following code shows an example for `contains()`.,contains}
-
-    @sa @ref find(KeyT&&) -- returns an iterator to an object element
-    @sa @ref contains(const json_pointer&) const -- checks the existence for a JSON pointer
-
-    @since version 3.6.0
-    */
-    template < typename KeyT, typename std::enable_if <
-                   !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
-    bool contains(KeyT && key) const
-    {
-        return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
-    }
-
-    /*!
-    @brief check the existence of an element in a JSON object given a JSON pointer
-
-    Check whether the given JSON pointer @a ptr can be resolved in the current
-    JSON value.
-
-    @note This method can be executed on any JSON value type.
-
-    @param[in] ptr JSON pointer to check its existence.
-
-    @return true if the JSON pointer can be resolved to a stored value, false
-    otherwise.
-
-    @post If `j.contains(ptr)` returns true, it is safe to call `j[ptr]`.
-
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-
-    @complexity Logarithmic in the size of the JSON object.
-
-    @liveexample{The following code shows an example for `contains()`.,contains_json_pointer}
-
-    @sa @ref contains(KeyT &&) const -- checks the existence of a key
-
-    @since version 3.7.0
-    */
-    bool contains(const json_pointer& ptr) const
-    {
-        return ptr.contains(this);
-    }
-
-    /// @}
-
-
-    ///////////////
-    // iterators //
-    ///////////////
-
-    /// @name iterators
-    /// @{
-
-    /*!
-    @brief returns an iterator to the first element
-
-    Returns an iterator to the first element.
-
-    @image html range-begin-end.svg "Illustration from cppreference.com"
-
-    @return iterator to the first element
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is constant.
-
-    @liveexample{The following code shows an example for `begin()`.,begin}
-
-    @sa @ref cbegin() -- returns a const iterator to the beginning
-    @sa @ref end() -- returns an iterator to the end
-    @sa @ref cend() -- returns a const iterator to the end
-
-    @since version 1.0.0
-    */
-    iterator begin() noexcept
-    {
-        iterator result(this);
-        result.set_begin();
-        return result;
-    }
-
-    /*!
-    @copydoc basic_json::cbegin()
-    */
-    const_iterator begin() const noexcept
-    {
-        return cbegin();
-    }
-
-    /*!
-    @brief returns a const iterator to the first element
-
-    Returns a const iterator to the first element.
-
-    @image html range-begin-end.svg "Illustration from cppreference.com"
-
-    @return const iterator to the first element
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
-
-    @liveexample{The following code shows an example for `cbegin()`.,cbegin}
-
-    @sa @ref begin() -- returns an iterator to the beginning
-    @sa @ref end() -- returns an iterator to the end
-    @sa @ref cend() -- returns a const iterator to the end
-
-    @since version 1.0.0
-    */
-    const_iterator cbegin() const noexcept
-    {
-        const_iterator result(this);
-        result.set_begin();
-        return result;
-    }
-
-    /*!
-    @brief returns an iterator to one past the last element
-
-    Returns an iterator to one past the last element.
-
-    @image html range-begin-end.svg "Illustration from cppreference.com"
-
-    @return iterator one past the last element
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is constant.
-
-    @liveexample{The following code shows an example for `end()`.,end}
-
-    @sa @ref cend() -- returns a const iterator to the end
-    @sa @ref begin() -- returns an iterator to the beginning
-    @sa @ref cbegin() -- returns a const iterator to the beginning
-
-    @since version 1.0.0
-    */
-    iterator end() noexcept
-    {
-        iterator result(this);
-        result.set_end();
-        return result;
-    }
-
-    /*!
-    @copydoc basic_json::cend()
-    */
-    const_iterator end() const noexcept
-    {
-        return cend();
-    }
-
-    /*!
-    @brief returns a const iterator to one past the last element
-
-    Returns a const iterator to one past the last element.
-
-    @image html range-begin-end.svg "Illustration from cppreference.com"
-
-    @return const iterator one past the last element
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
-
-    @liveexample{The following code shows an example for `cend()`.,cend}
-
-    @sa @ref end() -- returns an iterator to the end
-    @sa @ref begin() -- returns an iterator to the beginning
-    @sa @ref cbegin() -- returns a const iterator to the beginning
-
-    @since version 1.0.0
-    */
-    const_iterator cend() const noexcept
-    {
-        const_iterator result(this);
-        result.set_end();
-        return result;
-    }
-
-    /*!
-    @brief returns an iterator to the reverse-beginning
-
-    Returns an iterator to the reverse-beginning; that is, the last element.
-
-    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `reverse_iterator(end())`.
-
-    @liveexample{The following code shows an example for `rbegin()`.,rbegin}
-
-    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
-    @sa @ref rend() -- returns a reverse iterator to the end
-    @sa @ref crend() -- returns a const reverse iterator to the end
-
-    @since version 1.0.0
-    */
-    reverse_iterator rbegin() noexcept
-    {
-        return reverse_iterator(end());
-    }
-
-    /*!
-    @copydoc basic_json::crbegin()
-    */
-    const_reverse_iterator rbegin() const noexcept
-    {
-        return crbegin();
-    }
-
-    /*!
-    @brief returns an iterator to the reverse-end
-
-    Returns an iterator to the reverse-end; that is, one before the first
-    element.
-
-    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `reverse_iterator(begin())`.
-
-    @liveexample{The following code shows an example for `rend()`.,rend}
-
-    @sa @ref crend() -- returns a const reverse iterator to the end
-    @sa @ref rbegin() -- returns a reverse iterator to the beginning
-    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
-
-    @since version 1.0.0
-    */
-    reverse_iterator rend() noexcept
-    {
-        return reverse_iterator(begin());
-    }
-
-    /*!
-    @copydoc basic_json::crend()
-    */
-    const_reverse_iterator rend() const noexcept
-    {
-        return crend();
-    }
-
-    /*!
-    @brief returns a const reverse iterator to the last element
-
-    Returns a const iterator to the reverse-beginning; that is, the last
-    element.
-
-    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
-
-    @liveexample{The following code shows an example for `crbegin()`.,crbegin}
-
-    @sa @ref rbegin() -- returns a reverse iterator to the beginning
-    @sa @ref rend() -- returns a reverse iterator to the end
-    @sa @ref crend() -- returns a const reverse iterator to the end
-
-    @since version 1.0.0
-    */
-    const_reverse_iterator crbegin() const noexcept
-    {
-        return const_reverse_iterator(cend());
-    }
-
-    /*!
-    @brief returns a const reverse iterator to one before the first
-
-    Returns a const reverse iterator to the reverse-end; that is, one before
-    the first element.
-
-    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
-
-    @liveexample{The following code shows an example for `crend()`.,crend}
-
-    @sa @ref rend() -- returns a reverse iterator to the end
-    @sa @ref rbegin() -- returns a reverse iterator to the beginning
-    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
-
-    @since version 1.0.0
-    */
-    const_reverse_iterator crend() const noexcept
-    {
-        return const_reverse_iterator(cbegin());
-    }
-
-  public:
-    /*!
-    @brief wrapper to access iterator member functions in range-based for
-
-    This function allows to access @ref iterator::key() and @ref
-    iterator::value() during range-based for loops. In these loops, a
-    reference to the JSON values is returned, so there is no access to the
-    underlying iterator.
-
-    For loop without iterator_wrapper:
-
-    @code{cpp}
-    for (auto it = j_object.begin(); it != j_object.end(); ++it)
-    {
-        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
-    }
-    @endcode
-
-    Range-based for loop without iterator proxy:
-
-    @code{cpp}
-    for (auto it : j_object)
-    {
-        // "it" is of type json::reference and has no key() member
-        std::cout << "value: " << it << '\n';
-    }
-    @endcode
-
-    Range-based for loop with iterator proxy:
-
-    @code{cpp}
-    for (auto it : json::iterator_wrapper(j_object))
-    {
-        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
-    }
-    @endcode
-
-    @note When iterating over an array, `key()` will return the index of the
-          element as string (see example).
-
-    @param[in] ref  reference to a JSON value
-    @return iteration proxy object wrapping @a ref with an interface to use in
-            range-based for loops
-
-    @liveexample{The following code shows how the wrapper is used,iterator_wrapper}
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @note The name of this function is not yet final and may change in the
-    future.
-
-    @deprecated This stream operator is deprecated and will be removed in
-                future 4.0.0 of the library. Please use @ref items() instead;
-                that is, replace `json::iterator_wrapper(j)` with `j.items()`.
-    */
-    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
-    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
-    {
-        return ref.items();
-    }
-
-    /*!
-    @copydoc iterator_wrapper(reference)
-    */
-    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
-    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
-    {
-        return ref.items();
-    }
-
-    /*!
-    @brief helper to access iterator member functions in range-based for
-
-    This function allows to access @ref iterator::key() and @ref
-    iterator::value() during range-based for loops. In these loops, a
-    reference to the JSON values is returned, so there is no access to the
-    underlying iterator.
-
-    For loop without `items()` function:
-
-    @code{cpp}
-    for (auto it = j_object.begin(); it != j_object.end(); ++it)
-    {
-        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
-    }
-    @endcode
-
-    Range-based for loop without `items()` function:
-
-    @code{cpp}
-    for (auto it : j_object)
-    {
-        // "it" is of type json::reference and has no key() member
-        std::cout << "value: " << it << '\n';
-    }
-    @endcode
-
-    Range-based for loop with `items()` function:
-
-    @code{cpp}
-    for (auto& el : j_object.items())
-    {
-        std::cout << "key: " << el.key() << ", value:" << el.value() << '\n';
-    }
-    @endcode
-
-    The `items()` function also allows to use
-    [structured bindings](https://en.cppreference.com/w/cpp/language/structured_binding)
-    (C++17):
-
-    @code{cpp}
-    for (auto& [key, val] : j_object.items())
-    {
-        std::cout << "key: " << key << ", value:" << val << '\n';
-    }
-    @endcode
-
-    @note When iterating over an array, `key()` will return the index of the
-          element as string (see example). For primitive types (e.g., numbers),
-          `key()` returns an empty string.
-
-    @warning Using `items()` on temporary objects is dangerous. Make sure the
-             object's lifetime exeeds the iteration. See
-             <https://github.com/nlohmann/json/issues/2040> for more
-             information.
-
-    @return iteration proxy object wrapping @a ref with an interface to use in
-            range-based for loops
-
-    @liveexample{The following code shows how the function is used.,items}
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 3.1.0, structured bindings support since 3.5.0.
-    */
-    iteration_proxy<iterator> items() noexcept
-    {
-        return iteration_proxy<iterator>(*this);
-    }
-
-    /*!
-    @copydoc items()
-    */
-    iteration_proxy<const_iterator> items() const noexcept
-    {
-        return iteration_proxy<const_iterator>(*this);
-    }
-
-    /// @}
-
-
-    //////////////
-    // capacity //
-    //////////////
-
-    /// @name capacity
-    /// @{
-
-    /*!
-    @brief checks whether the container is empty.
-
-    Checks if a JSON value has no elements (i.e. whether its @ref size is `0`).
-
-    @return The return value depends on the different types and is
-            defined as follows:
-            Value type  | return value
-            ----------- | -------------
-            null        | `true`
-            boolean     | `false`
-            string      | `false`
-            number      | `false`
-            binary      | `false`
-            object      | result of function `object_t::empty()`
-            array       | result of function `array_t::empty()`
-
-    @liveexample{The following code uses `empty()` to check if a JSON
-    object contains any elements.,empty}
-
-    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
-    the Container concept; that is, their `empty()` functions have constant
-    complexity.
-
-    @iterators No changes.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @note This function does not return whether a string stored as JSON value
-    is empty - it returns whether the JSON container itself is empty which is
-    false in the case of a string.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `begin() == end()`.
-
-    @sa @ref size() -- returns the number of elements
-
-    @since version 1.0.0
-    */
-    bool empty() const noexcept
-    {
-        switch (m_type)
-        {
-            case value_t::null:
-            {
-                // null values are empty
-                return true;
-            }
-
-            case value_t::array:
-            {
-                // delegate call to array_t::empty()
-                return m_value.array->empty();
-            }
-
-            case value_t::object:
-            {
-                // delegate call to object_t::empty()
-                return m_value.object->empty();
-            }
-
-            default:
-            {
-                // all other types are nonempty
-                return false;
-            }
-        }
-    }
-
-    /*!
-    @brief returns the number of elements
-
-    Returns the number of elements in a JSON value.
-
-    @return The return value depends on the different types and is
-            defined as follows:
-            Value type  | return value
-            ----------- | -------------
-            null        | `0`
-            boolean     | `1`
-            string      | `1`
-            number      | `1`
-            binary      | `1`
-            object      | result of function object_t::size()
-            array       | result of function array_t::size()
-
-    @liveexample{The following code calls `size()` on the different value
-    types.,size}
-
-    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
-    the Container concept; that is, their size() functions have constant
-    complexity.
-
-    @iterators No changes.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @note This function does not return the length of a string stored as JSON
-    value - it returns the number of elements in the JSON value which is 1 in
-    the case of a string.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `std::distance(begin(), end())`.
-
-    @sa @ref empty() -- checks whether the container is empty
-    @sa @ref max_size() -- returns the maximal number of elements
-
-    @since version 1.0.0
-    */
-    size_type size() const noexcept
-    {
-        switch (m_type)
-        {
-            case value_t::null:
-            {
-                // null values are empty
-                return 0;
-            }
-
-            case value_t::array:
-            {
-                // delegate call to array_t::size()
-                return m_value.array->size();
-            }
-
-            case value_t::object:
-            {
-                // delegate call to object_t::size()
-                return m_value.object->size();
-            }
-
-            default:
-            {
-                // all other types have size 1
-                return 1;
-            }
-        }
-    }
-
-    /*!
-    @brief returns the maximum possible number of elements
-
-    Returns the maximum number of elements a JSON value is able to hold due to
-    system or library implementation limitations, i.e. `std::distance(begin(),
-    end())` for the JSON value.
-
-    @return The return value depends on the different types and is
-            defined as follows:
-            Value type  | return value
-            ----------- | -------------
-            null        | `0` (same as `size()`)
-            boolean     | `1` (same as `size()`)
-            string      | `1` (same as `size()`)
-            number      | `1` (same as `size()`)
-            binary      | `1` (same as `size()`)
-            object      | result of function `object_t::max_size()`
-            array       | result of function `array_t::max_size()`
-
-    @liveexample{The following code calls `max_size()` on the different value
-    types. Note the output is implementation specific.,max_size}
-
-    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
-    the Container concept; that is, their `max_size()` functions have constant
-    complexity.
-
-    @iterators No changes.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of returning `b.size()` where `b` is the largest
-      possible JSON value.
-
-    @sa @ref size() -- returns the number of elements
-
-    @since version 1.0.0
-    */
-    size_type max_size() const noexcept
-    {
-        switch (m_type)
-        {
-            case value_t::array:
-            {
-                // delegate call to array_t::max_size()
-                return m_value.array->max_size();
-            }
-
-            case value_t::object:
-            {
-                // delegate call to object_t::max_size()
-                return m_value.object->max_size();
-            }
-
-            default:
-            {
-                // all other types have max_size() == size()
-                return size();
-            }
-        }
-    }
-
-    /// @}
-
-
-    ///////////////
-    // modifiers //
-    ///////////////
-
-    /// @name modifiers
-    /// @{
-
-    /*!
-    @brief clears the contents
-
-    Clears the content of a JSON value and resets it to the default value as
-    if @ref basic_json(value_t) would have been called with the current value
-    type from @ref type():
-
-    Value type  | initial value
-    ----------- | -------------
-    null        | `null`
-    boolean     | `false`
-    string      | `""`
-    number      | `0`
-    binary      | An empty byte vector
-    object      | `{}`
-    array       | `[]`
-
-    @post Has the same effect as calling
-    @code {.cpp}
-    *this = basic_json(type());
-    @endcode
-
-    @liveexample{The example below shows the effect of `clear()` to different
-    JSON types.,clear}
-
-    @complexity Linear in the size of the JSON value.
-
-    @iterators All iterators, pointers and references related to this container
-               are invalidated.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @sa @ref basic_json(value_t) -- constructor that creates an object with the
-        same value than calling `clear()`
-
-    @since version 1.0.0
-    */
-    void clear() noexcept
-    {
-        switch (m_type)
-        {
-            case value_t::number_integer:
-            {
-                m_value.number_integer = 0;
-                break;
-            }
-
-            case value_t::number_unsigned:
-            {
-                m_value.number_unsigned = 0;
-                break;
-            }
-
-            case value_t::number_float:
-            {
-                m_value.number_float = 0.0;
-                break;
-            }
-
-            case value_t::boolean:
-            {
-                m_value.boolean = false;
-                break;
-            }
-
-            case value_t::string:
-            {
-                m_value.string->clear();
-                break;
-            }
-
-            case value_t::binary:
-            {
-                m_value.binary->clear();
-                break;
-            }
-
-            case value_t::array:
-            {
-                m_value.array->clear();
-                break;
-            }
-
-            case value_t::object:
-            {
-                m_value.object->clear();
-                break;
-            }
-
-            default:
-                break;
-        }
-    }
-
-    /*!
-    @brief add an object to an array
-
-    Appends the given element @a val to the end of the JSON value. If the
-    function is called on a JSON null value, an empty array is created before
-    appending @a val.
-
-    @param[in] val the value to add to the JSON array
-
-    @throw type_error.308 when called on a type other than JSON array or
-    null; example: `"cannot use push_back() with number"`
-
-    @complexity Amortized constant.
-
-    @liveexample{The example shows how `push_back()` and `+=` can be used to
-    add elements to a JSON array. Note how the `null` value was silently
-    converted to a JSON array.,push_back}
-
-    @since version 1.0.0
-    */
-    void push_back(basic_json&& val)
-    {
-        // push_back only works for null objects or arrays
-        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
-        {
-            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
-        }
-
-        // transform null object into an array
-        if (is_null())
-        {
-            m_type = value_t::array;
-            m_value = value_t::array;
-            assert_invariant();
-        }
-
-        // add element to array (move semantics)
-        m_value.array->push_back(std::move(val));
-        // if val is moved from, basic_json move constructor marks it null so we do not call the destructor
-    }
-
-    /*!
-    @brief add an object to an array
-    @copydoc push_back(basic_json&&)
-    */
-    reference operator+=(basic_json&& val)
-    {
-        push_back(std::move(val));
-        return *this;
-    }
-
-    /*!
-    @brief add an object to an array
-    @copydoc push_back(basic_json&&)
-    */
-    void push_back(const basic_json& val)
-    {
-        // push_back only works for null objects or arrays
-        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
-        {
-            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
-        }
-
-        // transform null object into an array
-        if (is_null())
-        {
-            m_type = value_t::array;
-            m_value = value_t::array;
-            assert_invariant();
-        }
-
-        // add element to array
-        m_value.array->push_back(val);
-    }
-
-    /*!
-    @brief add an object to an array
-    @copydoc push_back(basic_json&&)
-    */
-    reference operator+=(const basic_json& val)
-    {
-        push_back(val);
-        return *this;
-    }
-
-    /*!
-    @brief add an object to an object
-
-    Inserts the given element @a val to the JSON object. If the function is
-    called on a JSON null value, an empty object is created before inserting
-    @a val.
-
-    @param[in] val the value to add to the JSON object
-
-    @throw type_error.308 when called on a type other than JSON object or
-    null; example: `"cannot use push_back() with number"`
-
-    @complexity Logarithmic in the size of the container, O(log(`size()`)).
-
-    @liveexample{The example shows how `push_back()` and `+=` can be used to
-    add elements to a JSON object. Note how the `null` value was silently
-    converted to a JSON object.,push_back__object_t__value}
-
-    @since version 1.0.0
-    */
-    void push_back(const typename object_t::value_type& val)
-    {
-        // push_back only works for null objects or objects
-        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
-        {
-            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
-        }
-
-        // transform null object into an object
-        if (is_null())
-        {
-            m_type = value_t::object;
-            m_value = value_t::object;
-            assert_invariant();
-        }
-
-        // add element to array
-        m_value.object->insert(val);
-    }
-
-    /*!
-    @brief add an object to an object
-    @copydoc push_back(const typename object_t::value_type&)
-    */
-    reference operator+=(const typename object_t::value_type& val)
-    {
-        push_back(val);
-        return *this;
-    }
-
-    /*!
-    @brief add an object to an object
-
-    This function allows to use `push_back` with an initializer list. In case
-
-    1. the current value is an object,
-    2. the initializer list @a init contains only two elements, and
-    3. the first element of @a init is a string,
-
-    @a init is converted into an object element and added using
-    @ref push_back(const typename object_t::value_type&). Otherwise, @a init
-    is converted to a JSON value and added using @ref push_back(basic_json&&).
-
-    @param[in] init  an initializer list
-
-    @complexity Linear in the size of the initializer list @a init.
-
-    @note This function is required to resolve an ambiguous overload error,
-          because pairs like `{"key", "value"}` can be both interpreted as
-          `object_t::value_type` or `std::initializer_list<basic_json>`, see
-          https://github.com/nlohmann/json/issues/235 for more information.
-
-    @liveexample{The example shows how initializer lists are treated as
-    objects when possible.,push_back__initializer_list}
-    */
-    void push_back(initializer_list_t init)
-    {
-        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
-        {
-            basic_json&& key = init.begin()->moved_or_copied();
-            push_back(typename object_t::value_type(
-                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
-        }
-        else
-        {
-            push_back(basic_json(init));
-        }
-    }
-
-    /*!
-    @brief add an object to an object
-    @copydoc push_back(initializer_list_t)
-    */
-    reference operator+=(initializer_list_t init)
-    {
-        push_back(init);
-        return *this;
-    }
-
-    /*!
-    @brief add an object to an array
-
-    Creates a JSON value from the passed parameters @a args to the end of the
-    JSON value. If the function is called on a JSON null value, an empty array
-    is created before appending the value created from @a args.
-
-    @param[in] args arguments to forward to a constructor of @ref basic_json
-    @tparam Args compatible types to create a @ref basic_json object
-
-    @return reference to the inserted element
-
-    @throw type_error.311 when called on a type other than JSON array or
-    null; example: `"cannot use emplace_back() with number"`
-
-    @complexity Amortized constant.
-
-    @liveexample{The example shows how `push_back()` can be used to add
-    elements to a JSON array. Note how the `null` value was silently converted
-    to a JSON array.,emplace_back}
-
-    @since version 2.0.8, returns reference since 3.7.0
-    */
-    template<class... Args>
-    reference emplace_back(Args&& ... args)
-    {
-        // emplace_back only works for null objects or arrays
-        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
-        {
-            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
-        }
-
-        // transform null object into an array
-        if (is_null())
-        {
-            m_type = value_t::array;
-            m_value = value_t::array;
-            assert_invariant();
-        }
-
-        // add element to array (perfect forwarding)
-#ifdef JSON_HAS_CPP_17
-        return m_value.array->emplace_back(std::forward<Args>(args)...);
-#else
-        m_value.array->emplace_back(std::forward<Args>(args)...);
-        return m_value.array->back();
-#endif
-    }
-
-    /*!
-    @brief add an object to an object if key does not exist
-
-    Inserts a new element into a JSON object constructed in-place with the
-    given @a args if there is no element with the key in the container. If the
-    function is called on a JSON null value, an empty object is created before
-    appending the value created from @a args.
-
-    @param[in] args arguments to forward to a constructor of @ref basic_json
-    @tparam Args compatible types to create a @ref basic_json object
-
-    @return a pair consisting of an iterator to the inserted element, or the
-            already-existing element if no insertion happened, and a bool
-            denoting whether the insertion took place.
-
-    @throw type_error.311 when called on a type other than JSON object or
-    null; example: `"cannot use emplace() with number"`
-
-    @complexity Logarithmic in the size of the container, O(log(`size()`)).
-
-    @liveexample{The example shows how `emplace()` can be used to add elements
-    to a JSON object. Note how the `null` value was silently converted to a
-    JSON object. Further note how no value is added if there was already one
-    value stored with the same key.,emplace}
-
-    @since version 2.0.8
-    */
-    template<class... Args>
-    std::pair<iterator, bool> emplace(Args&& ... args)
-    {
-        // emplace only works for null objects or arrays
-        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
-        {
-            JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
-        }
-
-        // transform null object into an object
-        if (is_null())
-        {
-            m_type = value_t::object;
-            m_value = value_t::object;
-            assert_invariant();
-        }
-
-        // add element to array (perfect forwarding)
-        auto res = m_value.object->emplace(std::forward<Args>(args)...);
-        // create result iterator and set iterator to the result of emplace
-        auto it = begin();
-        it.m_it.object_iterator = res.first;
-
-        // return pair of iterator and boolean
-        return {it, res.second};
-    }
-
-    /// Helper for insertion of an iterator
-    /// @note: This uses std::distance to support GCC 4.8,
-    ///        see https://github.com/nlohmann/json/pull/1257
-    template<typename... Args>
-    iterator insert_iterator(const_iterator pos, Args&& ... args)
-    {
-        iterator result(this);
-        JSON_ASSERT(m_value.array != nullptr);
-
-        auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
-        m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
-        result.m_it.array_iterator = m_value.array->begin() + insert_pos;
-
-        // This could have been written as:
-        // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
-        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
-
-        return result;
-    }
-
-    /*!
-    @brief inserts element
-
-    Inserts element @a val before iterator @a pos.
-
-    @param[in] pos iterator before which the content will be inserted; may be
-    the end() iterator
-    @param[in] val element to insert
-    @return iterator pointing to the inserted @a val.
-
-    @throw type_error.309 if called on JSON values other than arrays;
-    example: `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
-    example: `"iterator does not fit current value"`
-
-    @complexity Constant plus linear in the distance between @a pos and end of
-    the container.
-
-    @liveexample{The example shows how `insert()` is used.,insert}
-
-    @since version 1.0.0
-    */
-    iterator insert(const_iterator pos, const basic_json& val)
-    {
-        // insert only works for arrays
-        if (JSON_HEDLEY_LIKELY(is_array()))
-        {
-            // check if iterator pos fits to this JSON value
-            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
-            {
-                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-            }
-
-            // insert to array and return iterator
-            return insert_iterator(pos, val);
-        }
-
-        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief inserts element
-    @copydoc insert(const_iterator, const basic_json&)
-    */
-    iterator insert(const_iterator pos, basic_json&& val)
-    {
-        return insert(pos, val);
-    }
-
-    /*!
-    @brief inserts elements
-
-    Inserts @a cnt copies of @a val before iterator @a pos.
-
-    @param[in] pos iterator before which the content will be inserted; may be
-    the end() iterator
-    @param[in] cnt number of copies of @a val to insert
-    @param[in] val element to insert
-    @return iterator pointing to the first element inserted, or @a pos if
-    `cnt==0`
-
-    @throw type_error.309 if called on JSON values other than arrays; example:
-    `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
-    example: `"iterator does not fit current value"`
-
-    @complexity Linear in @a cnt plus linear in the distance between @a pos
-    and end of the container.
-
-    @liveexample{The example shows how `insert()` is used.,insert__count}
-
-    @since version 1.0.0
-    */
-    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
-    {
-        // insert only works for arrays
-        if (JSON_HEDLEY_LIKELY(is_array()))
-        {
-            // check if iterator pos fits to this JSON value
-            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
-            {
-                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-            }
-
-            // insert to array and return iterator
-            return insert_iterator(pos, cnt, val);
-        }
-
-        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-    }
-
-    /*!
-    @brief inserts elements
-
-    Inserts elements from range `[first, last)` before iterator @a pos.
-
-    @param[in] pos iterator before which the content will be inserted; may be
-    the end() iterator
-    @param[in] first begin of the range of elements to insert
-    @param[in] last end of the range of elements to insert
-
-    @throw type_error.309 if called on JSON values other than arrays; example:
-    `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
-    example: `"iterator does not fit current value"`
-    @throw invalid_iterator.210 if @a first and @a last do not belong to the
-    same JSON value; example: `"iterators do not fit"`
-    @throw invalid_iterator.211 if @a first or @a last are iterators into
-    container for which insert is called; example: `"passed iterators may not
-    belong to container"`
-
-    @return iterator pointing to the first element inserted, or @a pos if
-    `first==last`
-
-    @complexity Linear in `std::distance(first, last)` plus linear in the
-    distance between @a pos and end of the container.
-
-    @liveexample{The example shows how `insert()` is used.,insert__range}
-
-    @since version 1.0.0
-    */
-    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
-    {
-        // insert only works for arrays
-        if (JSON_HEDLEY_UNLIKELY(!is_array()))
-        {
-            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-        }
-
-        // check if iterator pos fits to this JSON value
-        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
-        {
-            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-        }
-
-        // check if range iterators belong to the same JSON object
-        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
-        {
-            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
-        {
-            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
-        }
-
-        // insert to array and return iterator
-        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
-    }
-
-    /*!
-    @brief inserts elements
-
-    Inserts elements from initializer list @a ilist before iterator @a pos.
-
-    @param[in] pos iterator before which the content will be inserted; may be
-    the end() iterator
-    @param[in] ilist initializer list to insert the values from
-
-    @throw type_error.309 if called on JSON values other than arrays; example:
-    `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
-    example: `"iterator does not fit current value"`
-
-    @return iterator pointing to the first element inserted, or @a pos if
-    `ilist` is empty
-
-    @complexity Linear in `ilist.size()` plus linear in the distance between
-    @a pos and end of the container.
-
-    @liveexample{The example shows how `insert()` is used.,insert__ilist}
-
-    @since version 1.0.0
-    */
-    iterator insert(const_iterator pos, initializer_list_t ilist)
-    {
-        // insert only works for arrays
-        if (JSON_HEDLEY_UNLIKELY(!is_array()))
-        {
-            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-        }
-
-        // check if iterator pos fits to this JSON value
-        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
-        {
-            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-        }
-
-        // insert to array and return iterator
-        return insert_iterator(pos, ilist.begin(), ilist.end());
-    }
-
-    /*!
-    @brief inserts elements
-
-    Inserts elements from range `[first, last)`.
-
-    @param[in] first begin of the range of elements to insert
-    @param[in] last end of the range of elements to insert
-
-    @throw type_error.309 if called on JSON values other than objects; example:
-    `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if iterator @a first or @a last does does not
-    point to an object; example: `"iterators first and last must point to
-    objects"`
-    @throw invalid_iterator.210 if @a first and @a last do not belong to the
-    same JSON value; example: `"iterators do not fit"`
-
-    @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number
-    of elements to insert.
-
-    @liveexample{The example shows how `insert()` is used.,insert__range_object}
-
-    @since version 3.0.0
-    */
-    void insert(const_iterator first, const_iterator last)
-    {
-        // insert only works for objects
-        if (JSON_HEDLEY_UNLIKELY(!is_object()))
-        {
-            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-        }
-
-        // check if range iterators belong to the same JSON object
-        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
-        {
-            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
-        }
-
-        // passed iterators must belong to objects
-        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
-        {
-            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
-        }
-
-        m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
-    }
-
-    /*!
-    @brief updates a JSON object from another object, overwriting existing keys
-
-    Inserts all values from JSON object @a j and overwrites existing keys.
-
-    @param[in] j  JSON object to read values from
-
-    @throw type_error.312 if called on JSON values other than objects; example:
-    `"cannot use update() with string"`
-
-    @complexity O(N*log(size() + N)), where N is the number of elements to
-                insert.
-
-    @liveexample{The example shows how `update()` is used.,update}
-
-    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
-
-    @since version 3.0.0
-    */
-    void update(const_reference j)
-    {
-        // implicitly convert null value to an empty object
-        if (is_null())
-        {
-            m_type = value_t::object;
-            m_value.object = create<object_t>();
-            assert_invariant();
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(!is_object()))
-        {
-            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
-        }
-        if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
-        {
-            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
-        }
-
-        for (auto it = j.cbegin(); it != j.cend(); ++it)
-        {
-            m_value.object->operator[](it.key()) = it.value();
-        }
-    }
-
-    /*!
-    @brief updates a JSON object from another object, overwriting existing keys
-
-    Inserts all values from from range `[first, last)` and overwrites existing
-    keys.
-
-    @param[in] first begin of the range of elements to insert
-    @param[in] last end of the range of elements to insert
-
-    @throw type_error.312 if called on JSON values other than objects; example:
-    `"cannot use update() with string"`
-    @throw invalid_iterator.202 if iterator @a first or @a last does does not
-    point to an object; example: `"iterators first and last must point to
-    objects"`
-    @throw invalid_iterator.210 if @a first and @a last do not belong to the
-    same JSON value; example: `"iterators do not fit"`
-
-    @complexity O(N*log(size() + N)), where N is the number of elements to
-                insert.
-
-    @liveexample{The example shows how `update()` is used__range.,update}
-
-    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
-
-    @since version 3.0.0
-    */
-    void update(const_iterator first, const_iterator last)
-    {
-        // implicitly convert null value to an empty object
-        if (is_null())
-        {
-            m_type = value_t::object;
-            m_value.object = create<object_t>();
-            assert_invariant();
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(!is_object()))
-        {
-            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
-        }
-
-        // check if range iterators belong to the same JSON object
-        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
-        {
-            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
-        }
-
-        // passed iterators must belong to objects
-        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
-                                 || !last.m_object->is_object()))
-        {
-            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
-        }
-
-        for (auto it = first; it != last; ++it)
-        {
-            m_value.object->operator[](it.key()) = it.value();
-        }
-    }
-
-    /*!
-    @brief exchanges the values
-
-    Exchanges the contents of the JSON value with those of @a other. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated.
-
-    @param[in,out] other JSON value to exchange the contents with
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how JSON values can be swapped with
-    `swap()`.,swap__reference}
-
-    @since version 1.0.0
-    */
-    void swap(reference other) noexcept (
-        std::is_nothrow_move_constructible<value_t>::value&&
-        std::is_nothrow_move_assignable<value_t>::value&&
-        std::is_nothrow_move_constructible<json_value>::value&&
-        std::is_nothrow_move_assignable<json_value>::value
-    )
-    {
-        std::swap(m_type, other.m_type);
-        std::swap(m_value, other.m_value);
-        assert_invariant();
-    }
-
-    /*!
-    @brief exchanges the values
-
-    Exchanges the contents of the JSON value from @a left with those of @a right. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated. implemented as a friend function callable via ADL.
-
-    @param[in,out] left JSON value to exchange the contents with
-    @param[in,out] right JSON value to exchange the contents with
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how JSON values can be swapped with
-    `swap()`.,swap__reference}
-
-    @since version 1.0.0
-    */
-    friend void swap(reference left, reference right) noexcept (
-        std::is_nothrow_move_constructible<value_t>::value&&
-        std::is_nothrow_move_assignable<value_t>::value&&
-        std::is_nothrow_move_constructible<json_value>::value&&
-        std::is_nothrow_move_assignable<json_value>::value
-    )
-    {
-        left.swap(right);
-    }
-
-    /*!
-    @brief exchanges the values
-
-    Exchanges the contents of a JSON array with those of @a other. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated.
-
-    @param[in,out] other array to exchange the contents with
-
-    @throw type_error.310 when JSON value is not an array; example: `"cannot
-    use swap() with string"`
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how arrays can be swapped with
-    `swap()`.,swap__array_t}
-
-    @since version 1.0.0
-    */
-    void swap(array_t& other)
-    {
-        // swap only works for arrays
-        if (JSON_HEDLEY_LIKELY(is_array()))
-        {
-            std::swap(*(m_value.array), other);
-        }
-        else
-        {
-            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
-        }
-    }
-
-    /*!
-    @brief exchanges the values
-
-    Exchanges the contents of a JSON object with those of @a other. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated.
-
-    @param[in,out] other object to exchange the contents with
-
-    @throw type_error.310 when JSON value is not an object; example:
-    `"cannot use swap() with string"`
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how objects can be swapped with
-    `swap()`.,swap__object_t}
-
-    @since version 1.0.0
-    */
-    void swap(object_t& other)
-    {
-        // swap only works for objects
-        if (JSON_HEDLEY_LIKELY(is_object()))
-        {
-            std::swap(*(m_value.object), other);
-        }
-        else
-        {
-            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
-        }
-    }
-
-    /*!
-    @brief exchanges the values
-
-    Exchanges the contents of a JSON string with those of @a other. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated.
-
-    @param[in,out] other string to exchange the contents with
-
-    @throw type_error.310 when JSON value is not a string; example: `"cannot
-    use swap() with boolean"`
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how strings can be swapped with
-    `swap()`.,swap__string_t}
-
-    @since version 1.0.0
-    */
-    void swap(string_t& other)
-    {
-        // swap only works for strings
-        if (JSON_HEDLEY_LIKELY(is_string()))
-        {
-            std::swap(*(m_value.string), other);
-        }
-        else
-        {
-            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
-        }
-    }
-
-    /*!
-    @brief exchanges the values
-
-    Exchanges the contents of a JSON string with those of @a other. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated.
-
-    @param[in,out] other binary to exchange the contents with
-
-    @throw type_error.310 when JSON value is not a string; example: `"cannot
-    use swap() with boolean"`
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how strings can be swapped with
-    `swap()`.,swap__binary_t}
-
-    @since version 3.8.0
-    */
-    void swap(binary_t& other)
-    {
-        // swap only works for strings
-        if (JSON_HEDLEY_LIKELY(is_binary()))
-        {
-            std::swap(*(m_value.binary), other);
-        }
-        else
-        {
-            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
-        }
-    }
-
-    /// @copydoc swap(binary_t)
-    void swap(typename binary_t::container_type& other)
-    {
-        // swap only works for strings
-        if (JSON_HEDLEY_LIKELY(is_binary()))
-        {
-            std::swap(*(m_value.binary), other);
-        }
-        else
-        {
-            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
-        }
-    }
-
-    /// @}
-
-  public:
-    //////////////////////////////////////////
-    // lexicographical comparison operators //
-    //////////////////////////////////////////
-
-    /// @name lexicographical comparison operators
-    /// @{
-
-    /*!
-    @brief comparison: equal
-
-    Compares two JSON values for equality according to the following rules:
-    - Two JSON values are equal if (1) they are from the same type and (2)
-      their stored values are the same according to their respective
-      `operator==`.
-    - Integer and floating-point numbers are automatically converted before
-      comparison. Note that two NaN values are always treated as unequal.
-    - Two JSON null values are equal.
-
-    @note Floating-point inside JSON values numbers are compared with
-    `json::number_float_t::operator==` which is `double::operator==` by
-    default. To compare floating-point while respecting an epsilon, an alternative
-    [comparison function](https://github.com/mariokonrad/marnav/blob/master/include/marnav/math/floatingpoint.hpp#L34-#L39)
-    could be used, for instance
-    @code {.cpp}
-    template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
-    inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
-    {
-        return std::abs(a - b) <= epsilon;
-    }
-    @endcode
-    Or you can self-defined operator equal function like this:
-    @code {.cpp}
-    bool my_equal(const_reference lhs, const_reference rhs) {
-    const auto lhs_type lhs.type();
-    const auto rhs_type rhs.type();
-    if (lhs_type == rhs_type) {
-        switch(lhs_type)
-            // self_defined case
-            case value_t::number_float:
-                return std::abs(lhs - rhs) <= std::numeric_limits<float>::epsilon();
-            // other cases remain the same with the original
-            ...
-    }
-    ...
-    }
-    @endcode
-
-    @note NaN values never compare equal to themselves or to other NaN values.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether the values @a lhs and @a rhs are equal
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @complexity Linear.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__equal}
-
-    @since version 1.0.0
-    */
-    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
-    {
-        const auto lhs_type = lhs.type();
-        const auto rhs_type = rhs.type();
-
-        if (lhs_type == rhs_type)
-        {
-            switch (lhs_type)
-            {
-                case value_t::array:
-                    return *lhs.m_value.array == *rhs.m_value.array;
-
-                case value_t::object:
-                    return *lhs.m_value.object == *rhs.m_value.object;
-
-                case value_t::null:
-                    return true;
-
-                case value_t::string:
-                    return *lhs.m_value.string == *rhs.m_value.string;
-
-                case value_t::boolean:
-                    return lhs.m_value.boolean == rhs.m_value.boolean;
-
-                case value_t::number_integer:
-                    return lhs.m_value.number_integer == rhs.m_value.number_integer;
-
-                case value_t::number_unsigned:
-                    return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
-
-                case value_t::number_float:
-                    return lhs.m_value.number_float == rhs.m_value.number_float;
-
-                case value_t::binary:
-                    return *lhs.m_value.binary == *rhs.m_value.binary;
-
-                default:
-                    return false;
-            }
-        }
-        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
-        {
-            return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
-        }
-        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
-        {
-            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
-        }
-        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
-        {
-            return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
-        }
-        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
-        {
-            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
-        }
-        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
-        {
-            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
-        }
-        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
-        {
-            return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
-        }
-
-        return false;
-    }
-
-    /*!
-    @brief comparison: equal
-    @copydoc operator==(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
-    {
-        return lhs == basic_json(rhs);
-    }
-
-    /*!
-    @brief comparison: equal
-    @copydoc operator==(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
-    {
-        return basic_json(lhs) == rhs;
-    }
-
-    /*!
-    @brief comparison: not equal
-
-    Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether the values @a lhs and @a rhs are not equal
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__notequal}
-
-    @since version 1.0.0
-    */
-    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
-    {
-        return !(lhs == rhs);
-    }
-
-    /*!
-    @brief comparison: not equal
-    @copydoc operator!=(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
-    {
-        return lhs != basic_json(rhs);
-    }
-
-    /*!
-    @brief comparison: not equal
-    @copydoc operator!=(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
-    {
-        return basic_json(lhs) != rhs;
-    }
-
-    /*!
-    @brief comparison: less than
-
-    Compares whether one JSON value @a lhs is less than another JSON value @a
-    rhs according to the following rules:
-    - If @a lhs and @a rhs have the same type, the values are compared using
-      the default `<` operator.
-    - Integer and floating-point numbers are automatically converted before
-      comparison
-    - In case @a lhs and @a rhs have different types, the values are ignored
-      and the order of the types is considered, see
-      @ref operator<(const value_t, const value_t).
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether @a lhs is less than @a rhs
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__less}
-
-    @since version 1.0.0
-    */
-    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
-    {
-        const auto lhs_type = lhs.type();
-        const auto rhs_type = rhs.type();
-
-        if (lhs_type == rhs_type)
-        {
-            switch (lhs_type)
-            {
-                case value_t::array:
-                    // note parentheses are necessary, see
-                    // https://github.com/nlohmann/json/issues/1530
-                    return (*lhs.m_value.array) < (*rhs.m_value.array);
-
-                case value_t::object:
-                    return (*lhs.m_value.object) < (*rhs.m_value.object);
-
-                case value_t::null:
-                    return false;
-
-                case value_t::string:
-                    return (*lhs.m_value.string) < (*rhs.m_value.string);
-
-                case value_t::boolean:
-                    return (lhs.m_value.boolean) < (rhs.m_value.boolean);
-
-                case value_t::number_integer:
-                    return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
-
-                case value_t::number_unsigned:
-                    return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
-
-                case value_t::number_float:
-                    return (lhs.m_value.number_float) < (rhs.m_value.number_float);
-
-                case value_t::binary:
-                    return (*lhs.m_value.binary) < (*rhs.m_value.binary);
-
-                default:
-                    return false;
-            }
-        }
-        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
-        {
-            return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
-        }
-        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
-        {
-            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
-        }
-        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
-        {
-            return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
-        }
-        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
-        {
-            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
-        }
-        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
-        {
-            return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
-        }
-        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
-        {
-            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
-        }
-
-        // We only reach this line if we cannot compare values. In that case,
-        // we compare types. Note we have to call the operator explicitly,
-        // because MSVC has problems otherwise.
-        return operator<(lhs_type, rhs_type);
-    }
-
-    /*!
-    @brief comparison: less than
-    @copydoc operator<(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
-    {
-        return lhs < basic_json(rhs);
-    }
-
-    /*!
-    @brief comparison: less than
-    @copydoc operator<(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
-    {
-        return basic_json(lhs) < rhs;
-    }
-
-    /*!
-    @brief comparison: less than or equal
-
-    Compares whether one JSON value @a lhs is less than or equal to another
-    JSON value by calculating `not (rhs < lhs)`.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether @a lhs is less than or equal to @a rhs
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__greater}
-
-    @since version 1.0.0
-    */
-    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
-    {
-        return !(rhs < lhs);
-    }
-
-    /*!
-    @brief comparison: less than or equal
-    @copydoc operator<=(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
-    {
-        return lhs <= basic_json(rhs);
-    }
-
-    /*!
-    @brief comparison: less than or equal
-    @copydoc operator<=(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
-    {
-        return basic_json(lhs) <= rhs;
-    }
-
-    /*!
-    @brief comparison: greater than
-
-    Compares whether one JSON value @a lhs is greater than another
-    JSON value by calculating `not (lhs <= rhs)`.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether @a lhs is greater than to @a rhs
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__lessequal}
-
-    @since version 1.0.0
-    */
-    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
-    {
-        return !(lhs <= rhs);
-    }
-
-    /*!
-    @brief comparison: greater than
-    @copydoc operator>(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
-    {
-        return lhs > basic_json(rhs);
-    }
-
-    /*!
-    @brief comparison: greater than
-    @copydoc operator>(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
-    {
-        return basic_json(lhs) > rhs;
-    }
-
-    /*!
-    @brief comparison: greater than or equal
-
-    Compares whether one JSON value @a lhs is greater than or equal to another
-    JSON value by calculating `not (lhs < rhs)`.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether @a lhs is greater than or equal to @a rhs
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__greaterequal}
-
-    @since version 1.0.0
-    */
-    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
-    {
-        return !(lhs < rhs);
-    }
-
-    /*!
-    @brief comparison: greater than or equal
-    @copydoc operator>=(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
-    {
-        return lhs >= basic_json(rhs);
-    }
-
-    /*!
-    @brief comparison: greater than or equal
-    @copydoc operator>=(const_reference, const_reference)
-    */
-    template<typename ScalarType, typename std::enable_if<
-                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
-    {
-        return basic_json(lhs) >= rhs;
-    }
-
-    /// @}
-
-    ///////////////////
-    // serialization //
-    ///////////////////
-
-    /// @name serialization
-    /// @{
-
-    /*!
-    @brief serialize to stream
-
-    Serialize the given JSON value @a j to the output stream @a o. The JSON
-    value will be serialized using the @ref dump member function.
-
-    - The indentation of the output can be controlled with the member variable
-      `width` of the output stream @a o. For instance, using the manipulator
-      `std::setw(4)` on @a o sets the indentation level to `4` and the
-      serialization result is the same as calling `dump(4)`.
-
-    - The indentation character can be controlled with the member variable
-      `fill` of the output stream @a o. For instance, the manipulator
-      `std::setfill('\\t')` sets indentation to use a tab character rather than
-      the default space character.
-
-    @param[in,out] o  stream to serialize to
-    @param[in] j  JSON value to serialize
-
-    @return the stream @a o
-
-    @throw type_error.316 if a string stored inside the JSON value is not
-                          UTF-8 encoded
-
-    @complexity Linear.
-
-    @liveexample{The example below shows the serialization with different
-    parameters to `width` to adjust the indentation level.,operator_serialize}
-
-    @since version 1.0.0; indentation character added in version 3.0.0
-    */
-    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
-    {
-        // read width member and use it as indentation parameter if nonzero
-        const bool pretty_print = o.width() > 0;
-        const auto indentation = pretty_print ? o.width() : 0;
-
-        // reset width to 0 for subsequent calls to this stream
-        o.width(0);
-
-        // do the actual serialization
-        serializer s(detail::output_adapter<char>(o), o.fill());
-        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
-        return o;
-    }
-
-    /*!
-    @brief serialize to stream
-    @deprecated This stream operator is deprecated and will be removed in
-                future 4.0.0 of the library. Please use
-                @ref operator<<(std::ostream&, const basic_json&)
-                instead; that is, replace calls like `j >> o;` with `o << j;`.
-    @since version 1.0.0; deprecated since version 3.0.0
-    */
-    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
-    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
-    {
-        return o << j;
-    }
-
-    /// @}
-
-
-    /////////////////////
-    // deserialization //
-    /////////////////////
-
-    /// @name deserialization
-    /// @{
-
-    /*!
-    @brief deserialize from a compatible input
-
-    @tparam InputType A compatible input, for instance
-    - an std::istream object
-    - a FILE pointer
-    - a C-style array of characters
-    - a pointer to a null-terminated string of single byte characters
-    - an object obj for which begin(obj) and end(obj) produces a valid pair of
-      iterators.
-
-    @param[in] i  input to read from
-    @param[in] cb  a parser callback function of type @ref parser_callback_t
-    which is used to control the deserialization by filtering unwanted values
-    (optional)
-    @param[in] allow_exceptions  whether to throw exceptions in case of a
-    parse error (optional, true by default)
-    @param[in] ignore_comments  whether comments should be ignored and treated
-    like whitespace (true) or yield a parse error (true); (optional, false by
-    default)
-
-    @return deserialized JSON value; in case of a parse error and
-            @a allow_exceptions set to `false`, the return value will be
-            value_t::discarded.
-
-    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
-    of input; expected string literal""`
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-
-    @complexity Linear in the length of the input. The parser is a predictive
-    LL(1) parser. The complexity can be higher if the parser callback function
-    @a cb or reading from the input @a i has a super-linear complexity.
-
-    @note A UTF-8 byte order mark is silently ignored.
-
-    @liveexample{The example below demonstrates the `parse()` function reading
-    from an array.,parse__array__parser_callback_t}
-
-    @liveexample{The example below demonstrates the `parse()` function with
-    and without callback function.,parse__string__parser_callback_t}
-
-    @liveexample{The example below demonstrates the `parse()` function with
-    and without callback function.,parse__istream__parser_callback_t}
-
-    @liveexample{The example below demonstrates the `parse()` function reading
-    from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
-
-    @since version 2.0.3 (contiguous containers); version 3.9.0 allowed to
-    ignore comments.
-    */
-    template<typename InputType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json parse(InputType&& i,
-                            const parser_callback_t cb = nullptr,
-                            const bool allow_exceptions = true,
-                            const bool ignore_comments = false)
-    {
-        basic_json result;
-        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
-        return result;
-    }
-
-    /*!
-    @brief deserialize from a pair of character iterators
-
-    The value_type of the iterator must be a integral type with size of 1, 2 or
-    4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.
-
-    @param[in] first iterator to start of character range
-    @param[in] last  iterator to end of character range
-    @param[in] cb  a parser callback function of type @ref parser_callback_t
-    which is used to control the deserialization by filtering unwanted values
-    (optional)
-    @param[in] allow_exceptions  whether to throw exceptions in case of a
-    parse error (optional, true by default)
-    @param[in] ignore_comments  whether comments should be ignored and treated
-    like whitespace (true) or yield a parse error (true); (optional, false by
-    default)
-
-    @return deserialized JSON value; in case of a parse error and
-            @a allow_exceptions set to `false`, the return value will be
-            value_t::discarded.
-
-    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
-    of input; expected string literal""`
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-    */
-    template<typename IteratorType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json parse(IteratorType first,
-                            IteratorType last,
-                            const parser_callback_t cb = nullptr,
-                            const bool allow_exceptions = true,
-                            const bool ignore_comments = false)
-    {
-        basic_json result;
-        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
-        return result;
-    }
-
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
-    static basic_json parse(detail::span_input_adapter&& i,
-                            const parser_callback_t cb = nullptr,
-                            const bool allow_exceptions = true,
-                            const bool ignore_comments = false)
-    {
-        basic_json result;
-        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
-        return result;
-    }
-
-    /*!
-    @brief check if the input is valid JSON
-
-    Unlike the @ref parse(InputType&&, const parser_callback_t,const bool)
-    function, this function neither throws an exception in case of invalid JSON
-    input (i.e., a parse error) nor creates diagnostic information.
-
-    @tparam InputType A compatible input, for instance
-    - an std::istream object
-    - a FILE pointer
-    - a C-style array of characters
-    - a pointer to a null-terminated string of single byte characters
-    - an object obj for which begin(obj) and end(obj) produces a valid pair of
-      iterators.
-
-    @param[in] i input to read from
-    @param[in] ignore_comments  whether comments should be ignored and treated
-    like whitespace (true) or yield a parse error (true); (optional, false by
-    default)
-
-    @return Whether the input read from @a i is valid JSON.
-
-    @complexity Linear in the length of the input. The parser is a predictive
-    LL(1) parser.
-
-    @note A UTF-8 byte order mark is silently ignored.
-
-    @liveexample{The example below demonstrates the `accept()` function reading
-    from a string.,accept__string}
-    */
-    template<typename InputType>
-    static bool accept(InputType&& i,
-                       const bool ignore_comments = false)
-    {
-        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
-    }
-
-    template<typename IteratorType>
-    static bool accept(IteratorType first, IteratorType last,
-                       const bool ignore_comments = false)
-    {
-        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
-    }
-
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
-    static bool accept(detail::span_input_adapter&& i,
-                       const bool ignore_comments = false)
-    {
-        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
-    }
-
-    /*!
-    @brief generate SAX events
-
-    The SAX event lister must follow the interface of @ref json_sax.
-
-    This function reads from a compatible input. Examples are:
-    - an std::istream object
-    - a FILE pointer
-    - a C-style array of characters
-    - a pointer to a null-terminated string of single byte characters
-    - an object obj for which begin(obj) and end(obj) produces a valid pair of
-      iterators.
-
-    @param[in] i  input to read from
-    @param[in,out] sax  SAX event listener
-    @param[in] format  the format to parse (JSON, CBOR, MessagePack, or UBJSON)
-    @param[in] strict  whether the input has to be consumed completely
-    @param[in] ignore_comments  whether comments should be ignored and treated
-    like whitespace (true) or yield a parse error (true); (optional, false by
-    default); only applies to the JSON file format.
-
-    @return return value of the last processed SAX event
-
-    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
-    of input; expected string literal""`
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-
-    @complexity Linear in the length of the input. The parser is a predictive
-    LL(1) parser. The complexity can be higher if the SAX consumer @a sax has
-    a super-linear complexity.
-
-    @note A UTF-8 byte order mark is silently ignored.
-
-    @liveexample{The example below demonstrates the `sax_parse()` function
-    reading from string and processing the events with a user-defined SAX
-    event consumer.,sax_parse}
-
-    @since version 3.2.0
-    */
-    template <typename InputType, typename SAX>
-    JSON_HEDLEY_NON_NULL(2)
-    static bool sax_parse(InputType&& i, SAX* sax,
-                          input_format_t format = input_format_t::json,
-                          const bool strict = true,
-                          const bool ignore_comments = false)
-    {
-        auto ia = detail::input_adapter(std::forward<InputType>(i));
-        return format == input_format_t::json
-               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
-    }
-
-    template<class IteratorType, class SAX>
-    JSON_HEDLEY_NON_NULL(3)
-    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
-                          input_format_t format = input_format_t::json,
-                          const bool strict = true,
-                          const bool ignore_comments = false)
-    {
-        auto ia = detail::input_adapter(std::move(first), std::move(last));
-        return format == input_format_t::json
-               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
-    }
-
-    template <typename SAX>
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
-    JSON_HEDLEY_NON_NULL(2)
-    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
-                          input_format_t format = input_format_t::json,
-                          const bool strict = true,
-                          const bool ignore_comments = false)
-    {
-        auto ia = i.get();
-        return format == input_format_t::json
-               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
-    }
-
-    /*!
-    @brief deserialize from stream
-    @deprecated This stream operator is deprecated and will be removed in
-                version 4.0.0 of the library. Please use
-                @ref operator>>(std::istream&, basic_json&)
-                instead; that is, replace calls like `j << i;` with `i >> j;`.
-    @since version 1.0.0; deprecated since version 3.0.0
-    */
-    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
-    friend std::istream& operator<<(basic_json& j, std::istream& i)
-    {
-        return operator>>(i, j);
-    }
-
-    /*!
-    @brief deserialize from stream
-
-    Deserializes an input stream to a JSON value.
-
-    @param[in,out] i  input stream to read a serialized JSON value from
-    @param[in,out] j  JSON value to write the deserialized input to
-
-    @throw parse_error.101 in case of an unexpected token
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-
-    @complexity Linear in the length of the input. The parser is a predictive
-    LL(1) parser.
-
-    @note A UTF-8 byte order mark is silently ignored.
-
-    @liveexample{The example below shows how a JSON value is constructed by
-    reading a serialization from a stream.,operator_deserialize}
-
-    @sa parse(std::istream&, const parser_callback_t) for a variant with a
-    parser callback function to filter values while parsing
-
-    @since version 1.0.0
-    */
-    friend std::istream& operator>>(std::istream& i, basic_json& j)
-    {
-        parser(detail::input_adapter(i)).parse(false, j);
-        return i;
-    }
-
-    /// @}
-
-    ///////////////////////////
-    // convenience functions //
-    ///////////////////////////
-
-    /*!
-    @brief return the type as string
-
-    Returns the type name as string to be used in error messages - usually to
-    indicate that a function was called on a wrong JSON type.
-
-    @return a string representation of a the @a m_type member:
-            Value type  | return value
-            ----------- | -------------
-            null        | `"null"`
-            boolean     | `"boolean"`
-            string      | `"string"`
-            number      | `"number"` (for all number types)
-            object      | `"object"`
-            array       | `"array"`
-            binary      | `"binary"`
-            discarded   | `"discarded"`
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @complexity Constant.
-
-    @liveexample{The following code exemplifies `type_name()` for all JSON
-    types.,type_name}
-
-    @sa @ref type() -- return the type of the JSON value
-    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
-
-    @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
-    since 3.0.0
-    */
-    JSON_HEDLEY_RETURNS_NON_NULL
-    const char* type_name() const noexcept
-    {
-        {
-            switch (m_type)
-            {
-                case value_t::null:
-                    return "null";
-                case value_t::object:
-                    return "object";
-                case value_t::array:
-                    return "array";
-                case value_t::string:
-                    return "string";
-                case value_t::boolean:
-                    return "boolean";
-                case value_t::binary:
-                    return "binary";
-                case value_t::discarded:
-                    return "discarded";
-                default:
-                    return "number";
-            }
-        }
-    }
-
-
-  private:
-    //////////////////////
-    // member variables //
-    //////////////////////
-
-    /// the type of the current element
-    value_t m_type = value_t::null;
-
-    /// the value of the current element
-    json_value m_value = {};
-
-    //////////////////////////////////////////
-    // binary serialization/deserialization //
-    //////////////////////////////////////////
-
-    /// @name binary serialization/deserialization support
-    /// @{
-
-  public:
-    /*!
-    @brief create a CBOR serialization of a given JSON value
-
-    Serializes a given JSON value @a j to a byte vector using the CBOR (Concise
-    Binary Object Representation) serialization format. CBOR is a binary
-    serialization format which aims to be more compact than JSON itself, yet
-    more efficient to parse.
-
-    The library uses the following mapping from JSON values types to
-    CBOR types according to the CBOR specification (RFC 7049):
-
-    JSON value type | value/range                                | CBOR type                          | first byte
-    --------------- | ------------------------------------------ | ---------------------------------- | ---------------
-    null            | `null`                                     | Null                               | 0xF6
-    boolean         | `true`                                     | True                               | 0xF5
-    boolean         | `false`                                    | False                              | 0xF4
-    number_integer  | -9223372036854775808..-2147483649          | Negative integer (8 bytes follow)  | 0x3B
-    number_integer  | -2147483648..-32769                        | Negative integer (4 bytes follow)  | 0x3A
-    number_integer  | -32768..-129                               | Negative integer (2 bytes follow)  | 0x39
-    number_integer  | -128..-25                                  | Negative integer (1 byte follow)   | 0x38
-    number_integer  | -24..-1                                    | Negative integer                   | 0x20..0x37
-    number_integer  | 0..23                                      | Integer                            | 0x00..0x17
-    number_integer  | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
-    number_integer  | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
-    number_integer  | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
-    number_integer  | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
-    number_unsigned | 0..23                                      | Integer                            | 0x00..0x17
-    number_unsigned | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
-    number_unsigned | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
-    number_unsigned | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
-    number_unsigned | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
-    number_float    | *any value representable by a float*       | Single-Precision Float             | 0xFA
-    number_float    | *any value NOT representable by a float*   | Double-Precision Float             | 0xFB
-    string          | *length*: 0..23                            | UTF-8 string                       | 0x60..0x77
-    string          | *length*: 23..255                          | UTF-8 string (1 byte follow)       | 0x78
-    string          | *length*: 256..65535                       | UTF-8 string (2 bytes follow)      | 0x79
-    string          | *length*: 65536..4294967295                | UTF-8 string (4 bytes follow)      | 0x7A
-    string          | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow)      | 0x7B
-    array           | *size*: 0..23                              | array                              | 0x80..0x97
-    array           | *size*: 23..255                            | array (1 byte follow)              | 0x98
-    array           | *size*: 256..65535                         | array (2 bytes follow)             | 0x99
-    array           | *size*: 65536..4294967295                  | array (4 bytes follow)             | 0x9A
-    array           | *size*: 4294967296..18446744073709551615   | array (8 bytes follow)             | 0x9B
-    object          | *size*: 0..23                              | map                                | 0xA0..0xB7
-    object          | *size*: 23..255                            | map (1 byte follow)                | 0xB8
-    object          | *size*: 256..65535                         | map (2 bytes follow)               | 0xB9
-    object          | *size*: 65536..4294967295                  | map (4 bytes follow)               | 0xBA
-    object          | *size*: 4294967296..18446744073709551615   | map (8 bytes follow)               | 0xBB
-    binary          | *size*: 0..23                              | byte string                        | 0x40..0x57
-    binary          | *size*: 23..255                            | byte string (1 byte follow)        | 0x58
-    binary          | *size*: 256..65535                         | byte string (2 bytes follow)       | 0x59
-    binary          | *size*: 65536..4294967295                  | byte string (4 bytes follow)       | 0x5A
-    binary          | *size*: 4294967296..18446744073709551615   | byte string (8 bytes follow)       | 0x5B
-
-    @note The mapping is **complete** in the sense that any JSON value type
-          can be converted to a CBOR value.
-
-    @note If NaN or Infinity are stored inside a JSON number, they are
-          serialized properly. This behavior differs from the @ref dump()
-          function which serializes NaN or Infinity to `null`.
-
-    @note The following CBOR types are not used in the conversion:
-          - UTF-8 strings terminated by "break" (0x7F)
-          - arrays terminated by "break" (0x9F)
-          - maps terminated by "break" (0xBF)
-          - byte strings terminated by "break" (0x5F)
-          - date/time (0xC0..0xC1)
-          - bignum (0xC2..0xC3)
-          - decimal fraction (0xC4)
-          - bigfloat (0xC5)
-          - expected conversions (0xD5..0xD7)
-          - simple values (0xE0..0xF3, 0xF8)
-          - undefined (0xF7)
-          - half-precision floats (0xF9)
-          - break (0xFF)
-
-    @param[in] j  JSON value to serialize
-    @return CBOR serialization as byte vector
-
-    @complexity Linear in the size of the JSON value @a j.
-
-    @liveexample{The example shows the serialization of a JSON value to a byte
-    vector in CBOR format.,to_cbor}
-
-    @sa http://cbor.io
-    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
-        analogous deserialization
-    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
-    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
-             related UBJSON format
-
-    @since version 2.0.9; compact representation of floating-point numbers
-           since version 3.8.0
-    */
-    static std::vector<uint8_t> to_cbor(const basic_json& j)
-    {
-        std::vector<uint8_t> result;
-        to_cbor(j, result);
-        return result;
-    }
-
-    static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)
-    {
-        binary_writer<uint8_t>(o).write_cbor(j);
-    }
-
-    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
-    {
-        binary_writer<char>(o).write_cbor(j);
-    }
-
-    /*!
-    @brief create a MessagePack serialization of a given JSON value
-
-    Serializes a given JSON value @a j to a byte vector using the MessagePack
-    serialization format. MessagePack is a binary serialization format which
-    aims to be more compact than JSON itself, yet more efficient to parse.
-
-    The library uses the following mapping from JSON values types to
-    MessagePack types according to the MessagePack specification:
-
-    JSON value type | value/range                       | MessagePack type | first byte
-    --------------- | --------------------------------- | ---------------- | ----------
-    null            | `null`                            | nil              | 0xC0
-    boolean         | `true`                            | true             | 0xC3
-    boolean         | `false`                           | false            | 0xC2
-    number_integer  | -9223372036854775808..-2147483649 | int64            | 0xD3
-    number_integer  | -2147483648..-32769               | int32            | 0xD2
-    number_integer  | -32768..-129                      | int16            | 0xD1
-    number_integer  | -128..-33                         | int8             | 0xD0
-    number_integer  | -32..-1                           | negative fixint  | 0xE0..0xFF
-    number_integer  | 0..127                            | positive fixint  | 0x00..0x7F
-    number_integer  | 128..255                          | uint 8           | 0xCC
-    number_integer  | 256..65535                        | uint 16          | 0xCD
-    number_integer  | 65536..4294967295                 | uint 32          | 0xCE
-    number_integer  | 4294967296..18446744073709551615  | uint 64          | 0xCF
-    number_unsigned | 0..127                            | positive fixint  | 0x00..0x7F
-    number_unsigned | 128..255                          | uint 8           | 0xCC
-    number_unsigned | 256..65535                        | uint 16          | 0xCD
-    number_unsigned | 65536..4294967295                 | uint 32          | 0xCE
-    number_unsigned | 4294967296..18446744073709551615  | uint 64          | 0xCF
-    number_float    | *any value representable by a float*     | float 32 | 0xCA
-    number_float    | *any value NOT representable by a float* | float 64 | 0xCB
-    string          | *length*: 0..31                   | fixstr           | 0xA0..0xBF
-    string          | *length*: 32..255                 | str 8            | 0xD9
-    string          | *length*: 256..65535              | str 16           | 0xDA
-    string          | *length*: 65536..4294967295       | str 32           | 0xDB
-    array           | *size*: 0..15                     | fixarray         | 0x90..0x9F
-    array           | *size*: 16..65535                 | array 16         | 0xDC
-    array           | *size*: 65536..4294967295         | array 32         | 0xDD
-    object          | *size*: 0..15                     | fix map          | 0x80..0x8F
-    object          | *size*: 16..65535                 | map 16           | 0xDE
-    object          | *size*: 65536..4294967295         | map 32           | 0xDF
-    binary          | *size*: 0..255                    | bin 8            | 0xC4
-    binary          | *size*: 256..65535                | bin 16           | 0xC5
-    binary          | *size*: 65536..4294967295         | bin 32           | 0xC6
-
-    @note The mapping is **complete** in the sense that any JSON value type
-          can be converted to a MessagePack value.
-
-    @note The following values can **not** be converted to a MessagePack value:
-          - strings with more than 4294967295 bytes
-          - byte strings with more than 4294967295 bytes
-          - arrays with more than 4294967295 elements
-          - objects with more than 4294967295 elements
-
-    @note Any MessagePack output created @ref to_msgpack can be successfully
-          parsed by @ref from_msgpack.
-
-    @note If NaN or Infinity are stored inside a JSON number, they are
-          serialized properly. This behavior differs from the @ref dump()
-          function which serializes NaN or Infinity to `null`.
-
-    @param[in] j  JSON value to serialize
-    @return MessagePack serialization as byte vector
-
-    @complexity Linear in the size of the JSON value @a j.
-
-    @liveexample{The example shows the serialization of a JSON value to a byte
-    vector in MessagePack format.,to_msgpack}
-
-    @sa http://msgpack.org
-    @sa @ref from_msgpack for the analogous deserialization
-    @sa @ref to_cbor(const basic_json& for the related CBOR format
-    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
-             related UBJSON format
-
-    @since version 2.0.9
-    */
-    static std::vector<uint8_t> to_msgpack(const basic_json& j)
-    {
-        std::vector<uint8_t> result;
-        to_msgpack(j, result);
-        return result;
-    }
-
-    static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)
-    {
-        binary_writer<uint8_t>(o).write_msgpack(j);
-    }
-
-    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
-    {
-        binary_writer<char>(o).write_msgpack(j);
-    }
-
-    /*!
-    @brief create a UBJSON serialization of a given JSON value
-
-    Serializes a given JSON value @a j to a byte vector using the UBJSON
-    (Universal Binary JSON) serialization format. UBJSON aims to be more compact
-    than JSON itself, yet more efficient to parse.
-
-    The library uses the following mapping from JSON values types to
-    UBJSON types according to the UBJSON specification:
-
-    JSON value type | value/range                       | UBJSON type | marker
-    --------------- | --------------------------------- | ----------- | ------
-    null            | `null`                            | null        | `Z`
-    boolean         | `true`                            | true        | `T`
-    boolean         | `false`                           | false       | `F`
-    number_integer  | -9223372036854775808..-2147483649 | int64       | `L`
-    number_integer  | -2147483648..-32769               | int32       | `l`
-    number_integer  | -32768..-129                      | int16       | `I`
-    number_integer  | -128..127                         | int8        | `i`
-    number_integer  | 128..255                          | uint8       | `U`
-    number_integer  | 256..32767                        | int16       | `I`
-    number_integer  | 32768..2147483647                 | int32       | `l`
-    number_integer  | 2147483648..9223372036854775807   | int64       | `L`
-    number_unsigned | 0..127                            | int8        | `i`
-    number_unsigned | 128..255                          | uint8       | `U`
-    number_unsigned | 256..32767                        | int16       | `I`
-    number_unsigned | 32768..2147483647                 | int32       | `l`
-    number_unsigned | 2147483648..9223372036854775807   | int64       | `L`
-    number_unsigned | 2147483649..18446744073709551615  | high-precision | `H`
-    number_float    | *any value*                       | float64     | `D`
-    string          | *with shortest length indicator*  | string      | `S`
-    array           | *see notes on optimized format*   | array       | `[`
-    object          | *see notes on optimized format*   | map         | `{`
-
-    @note The mapping is **complete** in the sense that any JSON value type
-          can be converted to a UBJSON value.
-
-    @note The following values can **not** be converted to a UBJSON value:
-          - strings with more than 9223372036854775807 bytes (theoretical)
-
-    @note The following markers are not used in the conversion:
-          - `Z`: no-op values are not created.
-          - `C`: single-byte strings are serialized with `S` markers.
-
-    @note Any UBJSON output created @ref to_ubjson can be successfully parsed
-          by @ref from_ubjson.
-
-    @note If NaN or Infinity are stored inside a JSON number, they are
-          serialized properly. This behavior differs from the @ref dump()
-          function which serializes NaN or Infinity to `null`.
-
-    @note The optimized formats for containers are supported: Parameter
-          @a use_size adds size information to the beginning of a container and
-          removes the closing marker. Parameter @a use_type further checks
-          whether all elements of a container have the same type and adds the
-          type marker to the beginning of the container. The @a use_type
-          parameter must only be used together with @a use_size = true. Note
-          that @a use_size = true alone may result in larger representations -
-          the benefit of this parameter is that the receiving side is
-          immediately informed on the number of elements of the container.
-
-    @note If the JSON data contains the binary type, the value stored is a list
-          of integers, as suggested by the UBJSON documentation.  In particular,
-          this means that serialization and the deserialization of a JSON
-          containing binary values into UBJSON and back will result in a
-          different JSON object.
-
-    @param[in] j  JSON value to serialize
-    @param[in] use_size  whether to add size annotations to container types
-    @param[in] use_type  whether to add type annotations to container types
-                         (must be combined with @a use_size = true)
-    @return UBJSON serialization as byte vector
-
-    @complexity Linear in the size of the JSON value @a j.
-
-    @liveexample{The example shows the serialization of a JSON value to a byte
-    vector in UBJSON format.,to_ubjson}
-
-    @sa http://ubjson.org
-    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
-        analogous deserialization
-    @sa @ref to_cbor(const basic_json& for the related CBOR format
-    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
-
-    @since version 3.1.0
-    */
-    static std::vector<uint8_t> to_ubjson(const basic_json& j,
-                                          const bool use_size = false,
-                                          const bool use_type = false)
-    {
-        std::vector<uint8_t> result;
-        to_ubjson(j, result, use_size, use_type);
-        return result;
-    }
-
-    static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
-                          const bool use_size = false, const bool use_type = false)
-    {
-        binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
-    }
-
-    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
-                          const bool use_size = false, const bool use_type = false)
-    {
-        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
-    }
-
-
-    /*!
-    @brief Serializes the given JSON object `j` to BSON and returns a vector
-           containing the corresponding BSON-representation.
-
-    BSON (Binary JSON) is a binary format in which zero or more ordered key/value pairs are
-    stored as a single entity (a so-called document).
-
-    The library uses the following mapping from JSON values types to BSON types:
-
-    JSON value type | value/range                       | BSON type   | marker
-    --------------- | --------------------------------- | ----------- | ------
-    null            | `null`                            | null        | 0x0A
-    boolean         | `true`, `false`                   | boolean     | 0x08
-    number_integer  | -9223372036854775808..-2147483649 | int64       | 0x12
-    number_integer  | -2147483648..2147483647           | int32       | 0x10
-    number_integer  | 2147483648..9223372036854775807   | int64       | 0x12
-    number_unsigned | 0..2147483647                     | int32       | 0x10
-    number_unsigned | 2147483648..9223372036854775807   | int64       | 0x12
-    number_unsigned | 9223372036854775808..18446744073709551615| --   | --
-    number_float    | *any value*                       | double      | 0x01
-    string          | *any value*                       | string      | 0x02
-    array           | *any value*                       | document    | 0x04
-    object          | *any value*                       | document    | 0x03
-    binary          | *any value*                       | binary      | 0x05
-
-    @warning The mapping is **incomplete**, since only JSON-objects (and things
-    contained therein) can be serialized to BSON.
-    Also, integers larger than 9223372036854775807 cannot be serialized to BSON,
-    and the keys may not contain U+0000, since they are serialized a
-    zero-terminated c-strings.
-
-    @throw out_of_range.407  if `j.is_number_unsigned() && j.get<std::uint64_t>() > 9223372036854775807`
-    @throw out_of_range.409  if a key in `j` contains a NULL (U+0000)
-    @throw type_error.317    if `!j.is_object()`
-
-    @pre The input `j` is required to be an object: `j.is_object() == true`.
-
-    @note Any BSON output created via @ref to_bson can be successfully parsed
-          by @ref from_bson.
-
-    @param[in] j  JSON value to serialize
-    @return BSON serialization as byte vector
-
-    @complexity Linear in the size of the JSON value @a j.
-
-    @liveexample{The example shows the serialization of a JSON value to a byte
-    vector in BSON format.,to_bson}
-
-    @sa http://bsonspec.org/spec.html
-    @sa @ref from_bson(detail::input_adapter&&, const bool strict) for the
-        analogous deserialization
-    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
-             related UBJSON format
-    @sa @ref to_cbor(const basic_json&) for the related CBOR format
-    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
-    */
-    static std::vector<uint8_t> to_bson(const basic_json& j)
-    {
-        std::vector<uint8_t> result;
-        to_bson(j, result);
-        return result;
-    }
-
-    /*!
-    @brief Serializes the given JSON object `j` to BSON and forwards the
-           corresponding BSON-representation to the given output_adapter `o`.
-    @param j The JSON object to convert to BSON.
-    @param o The output adapter that receives the binary BSON representation.
-    @pre The input `j` shall be an object: `j.is_object() == true`
-    @sa @ref to_bson(const basic_json&)
-    */
-    static void to_bson(const basic_json& j, detail::output_adapter<uint8_t> o)
-    {
-        binary_writer<uint8_t>(o).write_bson(j);
-    }
-
-    /*!
-    @copydoc to_bson(const basic_json&, detail::output_adapter<uint8_t>)
-    */
-    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
-    {
-        binary_writer<char>(o).write_bson(j);
-    }
-
-
-    /*!
-    @brief create a JSON value from an input in CBOR format
-
-    Deserializes a given input @a i to a JSON value using the CBOR (Concise
-    Binary Object Representation) serialization format.
-
-    The library maps CBOR types to JSON value types as follows:
-
-    CBOR type              | JSON value type | first byte
-    ---------------------- | --------------- | ----------
-    Integer                | number_unsigned | 0x00..0x17
-    Unsigned integer       | number_unsigned | 0x18
-    Unsigned integer       | number_unsigned | 0x19
-    Unsigned integer       | number_unsigned | 0x1A
-    Unsigned integer       | number_unsigned | 0x1B
-    Negative integer       | number_integer  | 0x20..0x37
-    Negative integer       | number_integer  | 0x38
-    Negative integer       | number_integer  | 0x39
-    Negative integer       | number_integer  | 0x3A
-    Negative integer       | number_integer  | 0x3B
-    Byte string            | binary          | 0x40..0x57
-    Byte string            | binary          | 0x58
-    Byte string            | binary          | 0x59
-    Byte string            | binary          | 0x5A
-    Byte string            | binary          | 0x5B
-    UTF-8 string           | string          | 0x60..0x77
-    UTF-8 string           | string          | 0x78
-    UTF-8 string           | string          | 0x79
-    UTF-8 string           | string          | 0x7A
-    UTF-8 string           | string          | 0x7B
-    UTF-8 string           | string          | 0x7F
-    array                  | array           | 0x80..0x97
-    array                  | array           | 0x98
-    array                  | array           | 0x99
-    array                  | array           | 0x9A
-    array                  | array           | 0x9B
-    array                  | array           | 0x9F
-    map                    | object          | 0xA0..0xB7
-    map                    | object          | 0xB8
-    map                    | object          | 0xB9
-    map                    | object          | 0xBA
-    map                    | object          | 0xBB
-    map                    | object          | 0xBF
-    False                  | `false`         | 0xF4
-    True                   | `true`          | 0xF5
-    Null                   | `null`          | 0xF6
-    Half-Precision Float   | number_float    | 0xF9
-    Single-Precision Float | number_float    | 0xFA
-    Double-Precision Float | number_float    | 0xFB
-
-    @warning The mapping is **incomplete** in the sense that not all CBOR
-             types can be converted to a JSON value. The following CBOR types
-             are not supported and will yield parse errors (parse_error.112):
-             - date/time (0xC0..0xC1)
-             - bignum (0xC2..0xC3)
-             - decimal fraction (0xC4)
-             - bigfloat (0xC5)
-             - expected conversions (0xD5..0xD7)
-             - simple values (0xE0..0xF3, 0xF8)
-             - undefined (0xF7)
-
-    @warning CBOR allows map keys of any type, whereas JSON only allows
-             strings as keys in object values. Therefore, CBOR maps with keys
-             other than UTF-8 strings are rejected (parse_error.113).
-
-    @note Any CBOR output created @ref to_cbor can be successfully parsed by
-          @ref from_cbor.
-
-    @param[in] i  an input in CBOR format convertible to an input adapter
-    @param[in] strict  whether to expect the input to be consumed until EOF
-                       (true by default)
-    @param[in] allow_exceptions  whether to throw exceptions in case of a
-    parse error (optional, true by default)
-    @param[in] tag_handler how to treat CBOR tags (optional, error by default)
-
-    @return deserialized JSON value; in case of a parse error and
-            @a allow_exceptions set to `false`, the return value will be
-            value_t::discarded.
-
-    @throw parse_error.110 if the given input ends prematurely or the end of
-    file was not reached when @a strict was set to true
-    @throw parse_error.112 if unsupported features from CBOR were
-    used in the given input @a v or if the input is not valid CBOR
-    @throw parse_error.113 if a string was expected as map key, but not found
-
-    @complexity Linear in the size of the input @a i.
-
-    @liveexample{The example shows the deserialization of a byte vector in CBOR
-    format to a JSON value.,from_cbor}
-
-    @sa http://cbor.io
-    @sa @ref to_cbor(const basic_json&) for the analogous serialization
-    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for the
-        related MessagePack format
-    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
-        related UBJSON format
-
-    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
-           consume input adapters, removed start_index parameter, and added
-           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
-           since 3.2.0; added @a tag_handler parameter since 3.9.0.
-    */
-    template<typename InputType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json from_cbor(InputType&& i,
-                                const bool strict = true,
-                                const bool allow_exceptions = true,
-                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = detail::input_adapter(std::forward<InputType>(i));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-    /*!
-    @copydoc from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t)
-    */
-    template<typename IteratorType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json from_cbor(IteratorType first, IteratorType last,
-                                const bool strict = true,
-                                const bool allow_exceptions = true,
-                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = detail::input_adapter(std::move(first), std::move(last));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
-    static basic_json from_cbor(const T* ptr, std::size_t len,
-                                const bool strict = true,
-                                const bool allow_exceptions = true,
-                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-    {
-        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
-    }
-
-
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
-    static basic_json from_cbor(detail::span_input_adapter&& i,
-                                const bool strict = true,
-                                const bool allow_exceptions = true,
-                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = i.get();
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-    /*!
-    @brief create a JSON value from an input in MessagePack format
-
-    Deserializes a given input @a i to a JSON value using the MessagePack
-    serialization format.
-
-    The library maps MessagePack types to JSON value types as follows:
-
-    MessagePack type | JSON value type | first byte
-    ---------------- | --------------- | ----------
-    positive fixint  | number_unsigned | 0x00..0x7F
-    fixmap           | object          | 0x80..0x8F
-    fixarray         | array           | 0x90..0x9F
-    fixstr           | string          | 0xA0..0xBF
-    nil              | `null`          | 0xC0
-    false            | `false`         | 0xC2
-    true             | `true`          | 0xC3
-    float 32         | number_float    | 0xCA
-    float 64         | number_float    | 0xCB
-    uint 8           | number_unsigned | 0xCC
-    uint 16          | number_unsigned | 0xCD
-    uint 32          | number_unsigned | 0xCE
-    uint 64          | number_unsigned | 0xCF
-    int 8            | number_integer  | 0xD0
-    int 16           | number_integer  | 0xD1
-    int 32           | number_integer  | 0xD2
-    int 64           | number_integer  | 0xD3
-    str 8            | string          | 0xD9
-    str 16           | string          | 0xDA
-    str 32           | string          | 0xDB
-    array 16         | array           | 0xDC
-    array 32         | array           | 0xDD
-    map 16           | object          | 0xDE
-    map 32           | object          | 0xDF
-    bin 8            | binary          | 0xC4
-    bin 16           | binary          | 0xC5
-    bin 32           | binary          | 0xC6
-    ext 8            | binary          | 0xC7
-    ext 16           | binary          | 0xC8
-    ext 32           | binary          | 0xC9
-    fixext 1         | binary          | 0xD4
-    fixext 2         | binary          | 0xD5
-    fixext 4         | binary          | 0xD6
-    fixext 8         | binary          | 0xD7
-    fixext 16        | binary          | 0xD8
-    negative fixint  | number_integer  | 0xE0-0xFF
-
-    @note Any MessagePack output created @ref to_msgpack can be successfully
-          parsed by @ref from_msgpack.
-
-    @param[in] i  an input in MessagePack format convertible to an input
-                  adapter
-    @param[in] strict  whether to expect the input to be consumed until EOF
-                       (true by default)
-    @param[in] allow_exceptions  whether to throw exceptions in case of a
-    parse error (optional, true by default)
-
-    @return deserialized JSON value; in case of a parse error and
-            @a allow_exceptions set to `false`, the return value will be
-            value_t::discarded.
-
-    @throw parse_error.110 if the given input ends prematurely or the end of
-    file was not reached when @a strict was set to true
-    @throw parse_error.112 if unsupported features from MessagePack were
-    used in the given input @a i or if the input is not valid MessagePack
-    @throw parse_error.113 if a string was expected as map key, but not found
-
-    @complexity Linear in the size of the input @a i.
-
-    @liveexample{The example shows the deserialization of a byte vector in
-    MessagePack format to a JSON value.,from_msgpack}
-
-    @sa http://msgpack.org
-    @sa @ref to_msgpack(const basic_json&) for the analogous serialization
-    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
-        related CBOR format
-    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for
-        the related UBJSON format
-    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
-        the related BSON format
-
-    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
-           consume input adapters, removed start_index parameter, and added
-           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
-           since 3.2.0
-    */
-    template<typename InputType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json from_msgpack(InputType&& i,
-                                   const bool strict = true,
-                                   const bool allow_exceptions = true)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = detail::input_adapter(std::forward<InputType>(i));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-    /*!
-    @copydoc from_msgpack(detail::input_adapter&&, const bool, const bool)
-    */
-    template<typename IteratorType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json from_msgpack(IteratorType first, IteratorType last,
-                                   const bool strict = true,
-                                   const bool allow_exceptions = true)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = detail::input_adapter(std::move(first), std::move(last));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-
-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
-    static basic_json from_msgpack(const T* ptr, std::size_t len,
-                                   const bool strict = true,
-                                   const bool allow_exceptions = true)
-    {
-        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
-    }
-
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
-    static basic_json from_msgpack(detail::span_input_adapter&& i,
-                                   const bool strict = true,
-                                   const bool allow_exceptions = true)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = i.get();
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-
-    /*!
-    @brief create a JSON value from an input in UBJSON format
-
-    Deserializes a given input @a i to a JSON value using the UBJSON (Universal
-    Binary JSON) serialization format.
-
-    The library maps UBJSON types to JSON value types as follows:
-
-    UBJSON type | JSON value type                         | marker
-    ----------- | --------------------------------------- | ------
-    no-op       | *no value, next value is read*          | `N`
-    null        | `null`                                  | `Z`
-    false       | `false`                                 | `F`
-    true        | `true`                                  | `T`
-    float32     | number_float                            | `d`
-    float64     | number_float                            | `D`
-    uint8       | number_unsigned                         | `U`
-    int8        | number_integer                          | `i`
-    int16       | number_integer                          | `I`
-    int32       | number_integer                          | `l`
-    int64       | number_integer                          | `L`
-    high-precision number | number_integer, number_unsigned, or number_float - depends on number string | 'H'
-    string      | string                                  | `S`
-    char        | string                                  | `C`
-    array       | array (optimized values are supported)  | `[`
-    object      | object (optimized values are supported) | `{`
-
-    @note The mapping is **complete** in the sense that any UBJSON value can
-          be converted to a JSON value.
-
-    @param[in] i  an input in UBJSON format convertible to an input adapter
-    @param[in] strict  whether to expect the input to be consumed until EOF
-                       (true by default)
-    @param[in] allow_exceptions  whether to throw exceptions in case of a
-    parse error (optional, true by default)
-
-    @return deserialized JSON value; in case of a parse error and
-            @a allow_exceptions set to `false`, the return value will be
-            value_t::discarded.
-
-    @throw parse_error.110 if the given input ends prematurely or the end of
-    file was not reached when @a strict was set to true
-    @throw parse_error.112 if a parse error occurs
-    @throw parse_error.113 if a string could not be parsed successfully
-
-    @complexity Linear in the size of the input @a i.
-
-    @liveexample{The example shows the deserialization of a byte vector in
-    UBJSON format to a JSON value.,from_ubjson}
-
-    @sa http://ubjson.org
-    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
-             analogous serialization
-    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
-        related CBOR format
-    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
-        the related MessagePack format
-    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
-        the related BSON format
-
-    @since version 3.1.0; added @a allow_exceptions parameter since 3.2.0
-    */
-    template<typename InputType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json from_ubjson(InputType&& i,
-                                  const bool strict = true,
-                                  const bool allow_exceptions = true)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = detail::input_adapter(std::forward<InputType>(i));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-    /*!
-    @copydoc from_ubjson(detail::input_adapter&&, const bool, const bool)
-    */
-    template<typename IteratorType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json from_ubjson(IteratorType first, IteratorType last,
-                                  const bool strict = true,
-                                  const bool allow_exceptions = true)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = detail::input_adapter(std::move(first), std::move(last));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
-    static basic_json from_ubjson(const T* ptr, std::size_t len,
-                                  const bool strict = true,
-                                  const bool allow_exceptions = true)
-    {
-        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
-    }
-
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
-    static basic_json from_ubjson(detail::span_input_adapter&& i,
-                                  const bool strict = true,
-                                  const bool allow_exceptions = true)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = i.get();
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-
-    /*!
-    @brief Create a JSON value from an input in BSON format
-
-    Deserializes a given input @a i to a JSON value using the BSON (Binary JSON)
-    serialization format.
-
-    The library maps BSON record types to JSON value types as follows:
-
-    BSON type       | BSON marker byte | JSON value type
-    --------------- | ---------------- | ---------------------------
-    double          | 0x01             | number_float
-    string          | 0x02             | string
-    document        | 0x03             | object
-    array           | 0x04             | array
-    binary          | 0x05             | still unsupported
-    undefined       | 0x06             | still unsupported
-    ObjectId        | 0x07             | still unsupported
-    boolean         | 0x08             | boolean
-    UTC Date-Time   | 0x09             | still unsupported
-    null            | 0x0A             | null
-    Regular Expr.   | 0x0B             | still unsupported
-    DB Pointer      | 0x0C             | still unsupported
-    JavaScript Code | 0x0D             | still unsupported
-    Symbol          | 0x0E             | still unsupported
-    JavaScript Code | 0x0F             | still unsupported
-    int32           | 0x10             | number_integer
-    Timestamp       | 0x11             | still unsupported
-    128-bit decimal float | 0x13       | still unsupported
-    Max Key         | 0x7F             | still unsupported
-    Min Key         | 0xFF             | still unsupported
-
-    @warning The mapping is **incomplete**. The unsupported mappings
-             are indicated in the table above.
-
-    @param[in] i  an input in BSON format convertible to an input adapter
-    @param[in] strict  whether to expect the input to be consumed until EOF
-                       (true by default)
-    @param[in] allow_exceptions  whether to throw exceptions in case of a
-    parse error (optional, true by default)
-
-    @return deserialized JSON value; in case of a parse error and
-            @a allow_exceptions set to `false`, the return value will be
-            value_t::discarded.
-
-    @throw parse_error.114 if an unsupported BSON record type is encountered
-
-    @complexity Linear in the size of the input @a i.
-
-    @liveexample{The example shows the deserialization of a byte vector in
-    BSON format to a JSON value.,from_bson}
-
-    @sa http://bsonspec.org/spec.html
-    @sa @ref to_bson(const basic_json&) for the analogous serialization
-    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
-        related CBOR format
-    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
-        the related MessagePack format
-    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
-        related UBJSON format
-    */
-    template<typename InputType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json from_bson(InputType&& i,
-                                const bool strict = true,
-                                const bool allow_exceptions = true)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = detail::input_adapter(std::forward<InputType>(i));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-    /*!
-    @copydoc from_bson(detail::input_adapter&&, const bool, const bool)
-    */
-    template<typename IteratorType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json from_bson(IteratorType first, IteratorType last,
-                                const bool strict = true,
-                                const bool allow_exceptions = true)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = detail::input_adapter(std::move(first), std::move(last));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
-        return res ? result : basic_json(value_t::discarded);
-    }
-
-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
-    static basic_json from_bson(const T* ptr, std::size_t len,
-                                const bool strict = true,
-                                const bool allow_exceptions = true)
-    {
-        return from_bson(ptr, ptr + len, strict, allow_exceptions);
-    }
-
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
-    static basic_json from_bson(detail::span_input_adapter&& i,
-                                const bool strict = true,
-                                const bool allow_exceptions = true)
-    {
-        basic_json result;
-        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-        auto ia = i.get();
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
-        return res ? result : basic_json(value_t::discarded);
-    }
-    /// @}
-
-    //////////////////////////
-    // JSON Pointer support //
-    //////////////////////////
-
-    /// @name JSON Pointer functions
-    /// @{
-
-    /*!
-    @brief access specified element via JSON Pointer
-
-    Uses a JSON pointer to retrieve a reference to the respective JSON value.
-    No bound checking is performed. Similar to @ref operator[](const typename
-    object_t::key_type&), `null` values are created in arrays and objects if
-    necessary.
-
-    In particular:
-    - If the JSON pointer points to an object key that does not exist, it
-      is created an filled with a `null` value before a reference to it
-      is returned.
-    - If the JSON pointer points to an array index that does not exist, it
-      is created an filled with a `null` value before a reference to it
-      is returned. All indices between the current maximum and the given
-      index are also filled with `null`.
-    - The special value `-` is treated as a synonym for the index past the
-      end.
-
-    @param[in] ptr  a JSON pointer
-
-    @return reference to the element pointed to by @a ptr
-
-    @complexity Constant.
-
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-
-    @liveexample{The behavior is shown in the example.,operatorjson_pointer}
-
-    @since version 2.0.0
-    */
-    reference operator[](const json_pointer& ptr)
-    {
-        return ptr.get_unchecked(this);
-    }
-
-    /*!
-    @brief access specified element via JSON Pointer
-
-    Uses a JSON pointer to retrieve a reference to the respective JSON value.
-    No bound checking is performed. The function does not change the JSON
-    value; no `null` values are created. In particular, the special value
-    `-` yields an exception.
-
-    @param[in] ptr  JSON pointer to the desired element
-
-    @return const reference to the element pointed to by @a ptr
-
-    @complexity Constant.
-
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.402  if the array index '-' is used
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-
-    @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
-
-    @since version 2.0.0
-    */
-    const_reference operator[](const json_pointer& ptr) const
-    {
-        return ptr.get_unchecked(this);
-    }
-
-    /*!
-    @brief access specified element via JSON Pointer
-
-    Returns a reference to the element at with specified JSON pointer @a ptr,
-    with bounds checking.
-
-    @param[in] ptr  JSON pointer to the desired element
-
-    @return reference to the element pointed to by @a ptr
-
-    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
-    begins with '0'. See example below.
-
-    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
-    is not a number. See example below.
-
-    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
-    is out of range. See example below.
-
-    @throw out_of_range.402 if the array index '-' is used in the passed JSON
-    pointer @a ptr. As `at` provides checked access (and no elements are
-    implicitly inserted), the index '-' is always invalid. See example below.
-
-    @throw out_of_range.403 if the JSON pointer describes a key of an object
-    which cannot be found. See example below.
-
-    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
-    See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 2.0.0
-
-    @liveexample{The behavior is shown in the example.,at_json_pointer}
-    */
-    reference at(const json_pointer& ptr)
-    {
-        return ptr.get_checked(this);
-    }
-
-    /*!
-    @brief access specified element via JSON Pointer
-
-    Returns a const reference to the element at with specified JSON pointer @a
-    ptr, with bounds checking.
-
-    @param[in] ptr  JSON pointer to the desired element
-
-    @return reference to the element pointed to by @a ptr
-
-    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
-    begins with '0'. See example below.
-
-    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
-    is not a number. See example below.
-
-    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
-    is out of range. See example below.
-
-    @throw out_of_range.402 if the array index '-' is used in the passed JSON
-    pointer @a ptr. As `at` provides checked access (and no elements are
-    implicitly inserted), the index '-' is always invalid. See example below.
-
-    @throw out_of_range.403 if the JSON pointer describes a key of an object
-    which cannot be found. See example below.
-
-    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
-    See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 2.0.0
-
-    @liveexample{The behavior is shown in the example.,at_json_pointer_const}
-    */
-    const_reference at(const json_pointer& ptr) const
-    {
-        return ptr.get_checked(this);
-    }
-
-    /*!
-    @brief return flattened JSON value
-
-    The function creates a JSON object whose keys are JSON pointers (see [RFC
-    6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
-    primitive. The original JSON value can be restored using the @ref
-    unflatten() function.
-
-    @return an object that maps JSON pointers to primitive values
-
-    @note Empty objects and arrays are flattened to `null` and will not be
-          reconstructed correctly by the @ref unflatten() function.
-
-    @complexity Linear in the size the JSON value.
-
-    @liveexample{The following code shows how a JSON object is flattened to an
-    object whose keys consist of JSON pointers.,flatten}
-
-    @sa @ref unflatten() for the reverse function
-
-    @since version 2.0.0
-    */
-    basic_json flatten() const
-    {
-        basic_json result(value_t::object);
-        json_pointer::flatten("", *this, result);
-        return result;
-    }
-
-    /*!
-    @brief unflatten a previously flattened JSON value
-
-    The function restores the arbitrary nesting of a JSON value that has been
-    flattened before using the @ref flatten() function. The JSON value must
-    meet certain constraints:
-    1. The value must be an object.
-    2. The keys must be JSON pointers (see
-       [RFC 6901](https://tools.ietf.org/html/rfc6901))
-    3. The mapped values must be primitive JSON types.
-
-    @return the original JSON from a flattened version
-
-    @note Empty objects and arrays are flattened by @ref flatten() to `null`
-          values and can not unflattened to their original type. Apart from
-          this example, for a JSON value `j`, the following is always true:
-          `j == j.flatten().unflatten()`.
-
-    @complexity Linear in the size the JSON value.
-
-    @throw type_error.314  if value is not an object
-    @throw type_error.315  if object values are not primitive
-
-    @liveexample{The following code shows how a flattened JSON object is
-    unflattened into the original nested JSON object.,unflatten}
-
-    @sa @ref flatten() for the reverse function
-
-    @since version 2.0.0
-    */
-    basic_json unflatten() const
-    {
-        return json_pointer::unflatten(*this);
-    }
-
-    /// @}
-
-    //////////////////////////
-    // JSON Patch functions //
-    //////////////////////////
-
-    /// @name JSON Patch functions
-    /// @{
-
-    /*!
-    @brief applies a JSON patch
-
-    [JSON Patch](http://jsonpatch.com) defines a JSON document structure for
-    expressing a sequence of operations to apply to a JSON) document. With
-    this function, a JSON Patch is applied to the current JSON value by
-    executing all operations from the patch.
-
-    @param[in] json_patch  JSON patch document
-    @return patched document
-
-    @note The application of a patch is atomic: Either all operations succeed
-          and the patched document is returned or an exception is thrown. In
-          any case, the original value is not changed: the patch is applied
-          to a copy of the value.
-
-    @throw parse_error.104 if the JSON patch does not consist of an array of
-    objects
-
-    @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory
-    attributes are missing); example: `"operation add must have member path"`
-
-    @throw out_of_range.401 if an array index is out of range.
-
-    @throw out_of_range.403 if a JSON pointer inside the patch could not be
-    resolved successfully in the current JSON value; example: `"key baz not
-    found"`
-
-    @throw out_of_range.405 if JSON pointer has no parent ("add", "remove",
-    "move")
-
-    @throw other_error.501 if "test" operation was unsuccessful
-
-    @complexity Linear in the size of the JSON value and the length of the
-    JSON patch. As usually only a fraction of the JSON value is affected by
-    the patch, the complexity can usually be neglected.
-
-    @liveexample{The following code shows how a JSON patch is applied to a
-    value.,patch}
-
-    @sa @ref diff -- create a JSON patch by comparing two JSON values
-
-    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
-    @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)
-
-    @since version 2.0.0
-    */
-    basic_json patch(const basic_json& json_patch) const
-    {
-        // make a working copy to apply the patch to
-        basic_json result = *this;
-
-        // the valid JSON Patch operations
-        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
-
-        const auto get_op = [](const std::string & op)
-        {
-            if (op == "add")
-            {
-                return patch_operations::add;
-            }
-            if (op == "remove")
-            {
-                return patch_operations::remove;
-            }
-            if (op == "replace")
-            {
-                return patch_operations::replace;
-            }
-            if (op == "move")
-            {
-                return patch_operations::move;
-            }
-            if (op == "copy")
-            {
-                return patch_operations::copy;
-            }
-            if (op == "test")
-            {
-                return patch_operations::test;
-            }
-
-            return patch_operations::invalid;
-        };
-
-        // wrapper for "add" operation; add value at ptr
-        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
-        {
-            // adding to the root of the target document means replacing it
-            if (ptr.empty())
-            {
-                result = val;
-                return;
-            }
-
-            // make sure the top element of the pointer exists
-            json_pointer top_pointer = ptr.top();
-            if (top_pointer != ptr)
-            {
-                result.at(top_pointer);
-            }
-
-            // get reference to parent of JSON pointer ptr
-            const auto last_path = ptr.back();
-            ptr.pop_back();
-            basic_json& parent = result[ptr];
-
-            switch (parent.m_type)
-            {
-                case value_t::null:
-                case value_t::object:
-                {
-                    // use operator[] to add value
-                    parent[last_path] = val;
-                    break;
-                }
-
-                case value_t::array:
-                {
-                    if (last_path == "-")
-                    {
-                        // special case: append to back
-                        parent.push_back(val);
-                    }
-                    else
-                    {
-                        const auto idx = json_pointer::array_index(last_path);
-                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
-                        {
-                            // avoid undefined behavior
-                            JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
-                        }
-
-                        // default case: insert add offset
-                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
-                    }
-                    break;
-                }
-
-                // if there exists a parent it cannot be primitive
-                default:            // LCOV_EXCL_LINE
-                    JSON_ASSERT(false);  // LCOV_EXCL_LINE
-            }
-        };
-
-        // wrapper for "remove" operation; remove value at ptr
-        const auto operation_remove = [&result](json_pointer & ptr)
-        {
-            // get reference to parent of JSON pointer ptr
-            const auto last_path = ptr.back();
-            ptr.pop_back();
-            basic_json& parent = result.at(ptr);
-
-            // remove child
-            if (parent.is_object())
-            {
-                // perform range check
-                auto it = parent.find(last_path);
-                if (JSON_HEDLEY_LIKELY(it != parent.end()))
-                {
-                    parent.erase(it);
-                }
-                else
-                {
-                    JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
-                }
-            }
-            else if (parent.is_array())
-            {
-                // note erase performs range check
-                parent.erase(json_pointer::array_index(last_path));
-            }
-        };
-
-        // type check: top level value must be an array
-        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
-        {
-            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
-        }
-
-        // iterate and apply the operations
-        for (const auto& val : json_patch)
-        {
-            // wrapper to get a value for an operation
-            const auto get_value = [&val](const std::string & op,
-                                          const std::string & member,
-                                          bool string_type) -> basic_json &
-            {
-                // find value
-                auto it = val.m_value.object->find(member);
-
-                // context-sensitive error message
-                const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
-
-                // check if desired value is present
-                if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
-                {
-                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
-                }
-
-                // check if result is of type string
-                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
-                {
-                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
-                }
-
-                // no error: return value
-                return it->second;
-            };
-
-            // type check: every element of the array must be an object
-            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
-            {
-                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
-            }
-
-            // collect mandatory members
-            const auto op = get_value("op", "op", true).template get<std::string>();
-            const auto path = get_value(op, "path", true).template get<std::string>();
-            json_pointer ptr(path);
-
-            switch (get_op(op))
-            {
-                case patch_operations::add:
-                {
-                    operation_add(ptr, get_value("add", "value", false));
-                    break;
-                }
-
-                case patch_operations::remove:
-                {
-                    operation_remove(ptr);
-                    break;
-                }
-
-                case patch_operations::replace:
-                {
-                    // the "path" location must exist - use at()
-                    result.at(ptr) = get_value("replace", "value", false);
-                    break;
-                }
-
-                case patch_operations::move:
-                {
-                    const auto from_path = get_value("move", "from", true).template get<std::string>();
-                    json_pointer from_ptr(from_path);
-
-                    // the "from" location must exist - use at()
-                    basic_json v = result.at(from_ptr);
-
-                    // The move operation is functionally identical to a
-                    // "remove" operation on the "from" location, followed
-                    // immediately by an "add" operation at the target
-                    // location with the value that was just removed.
-                    operation_remove(from_ptr);
-                    operation_add(ptr, v);
-                    break;
-                }
-
-                case patch_operations::copy:
-                {
-                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
-                    const json_pointer from_ptr(from_path);
-
-                    // the "from" location must exist - use at()
-                    basic_json v = result.at(from_ptr);
-
-                    // The copy is functionally identical to an "add"
-                    // operation at the target location using the value
-                    // specified in the "from" member.
-                    operation_add(ptr, v);
-                    break;
-                }
-
-                case patch_operations::test:
-                {
-                    bool success = false;
-                    JSON_TRY
-                    {
-                        // check if "value" matches the one at "path"
-                        // the "path" location must exist - use at()
-                        success = (result.at(ptr) == get_value("test", "value", false));
-                    }
-                    JSON_INTERNAL_CATCH (out_of_range&)
-                    {
-                        // ignore out of range errors: success remains false
-                    }
-
-                    // throw an exception if test fails
-                    if (JSON_HEDLEY_UNLIKELY(!success))
-                    {
-                        JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
-                    }
-
-                    break;
-                }
-
-                default:
-                {
-                    // op must be "add", "remove", "replace", "move", "copy", or
-                    // "test"
-                    JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
-                }
-            }
-        }
-
-        return result;
-    }
-
-    /*!
-    @brief creates a diff as a JSON patch
-
-    Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can
-    be changed into the value @a target by calling @ref patch function.
-
-    @invariant For two JSON values @a source and @a target, the following code
-    yields always `true`:
-    @code {.cpp}
-    source.patch(diff(source, target)) == target;
-    @endcode
-
-    @note Currently, only `remove`, `add`, and `replace` operations are
-          generated.
-
-    @param[in] source  JSON value to compare from
-    @param[in] target  JSON value to compare against
-    @param[in] path    helper value to create JSON pointers
-
-    @return a JSON patch to convert the @a source to @a target
-
-    @complexity Linear in the lengths of @a source and @a target.
-
-    @liveexample{The following code shows how a JSON patch is created as a
-    diff for two JSON values.,diff}
-
-    @sa @ref patch -- apply a JSON patch
-    @sa @ref merge_patch -- apply a JSON Merge Patch
-
-    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
-
-    @since version 2.0.0
-    */
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json diff(const basic_json& source, const basic_json& target,
-                           const std::string& path = "")
-    {
-        // the patch
-        basic_json result(value_t::array);
-
-        // if the values are the same, return empty patch
-        if (source == target)
-        {
-            return result;
-        }
-
-        if (source.type() != target.type())
-        {
-            // different types: replace value
-            result.push_back(
-            {
-                {"op", "replace"}, {"path", path}, {"value", target}
-            });
-            return result;
-        }
-
-        switch (source.type())
-        {
-            case value_t::array:
-            {
-                // first pass: traverse common elements
-                std::size_t i = 0;
-                while (i < source.size() && i < target.size())
-                {
-                    // recursive call to compare array values at index i
-                    auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
-                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
-                    ++i;
-                }
-
-                // i now reached the end of at least one array
-                // in a second pass, traverse the remaining elements
-
-                // remove my remaining elements
-                const auto end_index = static_cast<difference_type>(result.size());
-                while (i < source.size())
-                {
-                    // add operations in reverse order to avoid invalid
-                    // indices
-                    result.insert(result.begin() + end_index, object(
-                    {
-                        {"op", "remove"},
-                        {"path", path + "/" + std::to_string(i)}
-                    }));
-                    ++i;
-                }
-
-                // add other remaining elements
-                while (i < target.size())
-                {
-                    result.push_back(
-                    {
-                        {"op", "add"},
-                        {"path", path + "/-"},
-                        {"value", target[i]}
-                    });
-                    ++i;
-                }
-
-                break;
-            }
-
-            case value_t::object:
-            {
-                // first pass: traverse this object's elements
-                for (auto it = source.cbegin(); it != source.cend(); ++it)
-                {
-                    // escape the key name to be used in a JSON patch
-                    const auto key = json_pointer::escape(it.key());
-
-                    if (target.find(it.key()) != target.end())
-                    {
-                        // recursive call to compare object values at key it
-                        auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
-                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
-                    }
-                    else
-                    {
-                        // found a key that is not in o -> remove it
-                        result.push_back(object(
-                        {
-                            {"op", "remove"}, {"path", path + "/" + key}
-                        }));
-                    }
-                }
-
-                // second pass: traverse other object's elements
-                for (auto it = target.cbegin(); it != target.cend(); ++it)
-                {
-                    if (source.find(it.key()) == source.end())
-                    {
-                        // found a key that is not in this -> add it
-                        const auto key = json_pointer::escape(it.key());
-                        result.push_back(
-                        {
-                            {"op", "add"}, {"path", path + "/" + key},
-                            {"value", it.value()}
-                        });
-                    }
-                }
-
-                break;
-            }
-
-            default:
-            {
-                // both primitive type: replace value
-                result.push_back(
-                {
-                    {"op", "replace"}, {"path", path}, {"value", target}
-                });
-                break;
-            }
-        }
-
-        return result;
-    }
-
-    /// @}
-
-    ////////////////////////////////
-    // JSON Merge Patch functions //
-    ////////////////////////////////
-
-    /// @name JSON Merge Patch functions
-    /// @{
-
-    /*!
-    @brief applies a JSON Merge Patch
-
-    The merge patch format is primarily intended for use with the HTTP PATCH
-    method as a means of describing a set of modifications to a target
-    resource's content. This function applies a merge patch to the current
-    JSON value.
-
-    The function implements the following algorithm from Section 2 of
-    [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396):
-
-    ```
-    define MergePatch(Target, Patch):
-      if Patch is an Object:
-        if Target is not an Object:
-          Target = {} // Ignore the contents and set it to an empty Object
-        for each Name/Value pair in Patch:
-          if Value is null:
-            if Name exists in Target:
-              remove the Name/Value pair from Target
-          else:
-            Target[Name] = MergePatch(Target[Name], Value)
-        return Target
-      else:
-        return Patch
-    ```
-
-    Thereby, `Target` is the current object; that is, the patch is applied to
-    the current value.
-
-    @param[in] apply_patch  the patch to apply
-
-    @complexity Linear in the lengths of @a patch.
-
-    @liveexample{The following code shows how a JSON Merge Patch is applied to
-    a JSON document.,merge_patch}
-
-    @sa @ref patch -- apply a JSON patch
-    @sa [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
-
-    @since version 3.0.0
-    */
-    void merge_patch(const basic_json& apply_patch)
-    {
-        if (apply_patch.is_object())
-        {
-            if (!is_object())
-            {
-                *this = object();
-            }
-            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
-            {
-                if (it.value().is_null())
-                {
-                    erase(it.key());
-                }
-                else
-                {
-                    operator[](it.key()).merge_patch(it.value());
-                }
-            }
-        }
-        else
-        {
-            *this = apply_patch;
-        }
-    }
-
-    /// @}
-};
-
-/*!
-@brief user-defined to_string function for JSON values
-
-This function implements a user-defined to_string  for JSON objects.
-
-@param[in] j  a JSON object
-@return a std::string object
-*/
-
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
-{
-    return j.dump();
-}
-} // namespace nlohmann
-
-///////////////////////
-// nonmember support //
-///////////////////////
-
-// specialization of std::swap, and std::hash
-namespace std
-{
-
-/// hash value for JSON objects
-template<>
-struct hash<nlohmann::json>
-{
-    /*!
-    @brief return a hash value for a JSON object
-
-    @since version 1.0.0
-    */
-    std::size_t operator()(const nlohmann::json& j) const
-    {
-        return nlohmann::detail::hash(j);
-    }
-};
-
-/// specialization for std::less<value_t>
-/// @note: do not remove the space after '<',
-///        see https://github.com/nlohmann/json/pull/679
-template<>
-struct less<::nlohmann::detail::value_t>
-{
-    /*!
-    @brief compare two value_t enum values
-    @since version 3.0.0
-    */
-    bool operator()(nlohmann::detail::value_t lhs,
-                    nlohmann::detail::value_t rhs) const noexcept
-    {
-        return nlohmann::detail::operator<(lhs, rhs);
-    }
-};
-
-// C++20 prohibit function specialization in the std namespace.
-#ifndef JSON_HAS_CPP_20
-
-/*!
-@brief exchanges the values of two JSON objects
-
-@since version 1.0.0
-*/
-template<>
-inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
-    is_nothrow_move_constructible<nlohmann::json>::value&&
-    is_nothrow_move_assignable<nlohmann::json>::value
-                              )
-{
-    j1.swap(j2);
-}
-
-#endif
-
-} // namespace std
-
-/*!
-@brief user-defined string literal for JSON values
-
-This operator implements a user-defined string literal for JSON objects. It
-can be used by adding `"_json"` to a string literal and returns a JSON object
-if no parse error occurred.
-
-@param[in] s  a string representation of a JSON object
-@param[in] n  the length of string @a s
-@return a JSON object
-
-@since version 1.0.0
-*/
-JSON_HEDLEY_NON_NULL(1)
-inline nlohmann::json operator "" _json(const char* s, std::size_t n)
-{
-    return nlohmann::json::parse(s, s + n);
-}
-
-/*!
-@brief user-defined string literal for JSON pointer
-
-This operator implements a user-defined string literal for JSON Pointers. It
-can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer
-object if no parse error occurred.
-
-@param[in] s  a string representation of a JSON Pointer
-@param[in] n  the length of string @a s
-@return a JSON pointer object
-
-@since version 2.0.0
-*/
-JSON_HEDLEY_NON_NULL(1)
-inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
-{
-    return nlohmann::json::json_pointer(std::string(s, n));
-}
-
-// #include <nlohmann/detail/macro_unscope.hpp>
-
-
-// restore GCC/clang diagnostic settings
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
-    #pragma GCC diagnostic pop
-#endif
-#if defined(__clang__)
-    #pragma GCC diagnostic pop
-#endif
-
-// clean up
-#undef JSON_ASSERT
-#undef JSON_INTERNAL_CATCH
-#undef JSON_CATCH
-#undef JSON_THROW
-#undef JSON_TRY
-#undef JSON_HAS_CPP_14
-#undef JSON_HAS_CPP_17
-#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
-#undef NLOHMANN_BASIC_JSON_TPL
-#undef JSON_EXPLICIT
-
-// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
-#undef JSON_HEDLEY_ALWAYS_INLINE
-#undef JSON_HEDLEY_ARM_VERSION
-#undef JSON_HEDLEY_ARM_VERSION_CHECK
-#undef JSON_HEDLEY_ARRAY_PARAM
-#undef JSON_HEDLEY_ASSUME
-#undef JSON_HEDLEY_BEGIN_C_DECLS
-#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
-#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
-#undef JSON_HEDLEY_CLANG_HAS_FEATURE
-#undef JSON_HEDLEY_CLANG_HAS_WARNING
-#undef JSON_HEDLEY_COMPCERT_VERSION
-#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
-#undef JSON_HEDLEY_CONCAT
-#undef JSON_HEDLEY_CONCAT3
-#undef JSON_HEDLEY_CONCAT3_EX
-#undef JSON_HEDLEY_CONCAT_EX
-#undef JSON_HEDLEY_CONST
-#undef JSON_HEDLEY_CONSTEXPR
-#undef JSON_HEDLEY_CONST_CAST
-#undef JSON_HEDLEY_CPP_CAST
-#undef JSON_HEDLEY_CRAY_VERSION
-#undef JSON_HEDLEY_CRAY_VERSION_CHECK
-#undef JSON_HEDLEY_C_DECL
-#undef JSON_HEDLEY_DEPRECATED
-#undef JSON_HEDLEY_DEPRECATED_FOR
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#undef JSON_HEDLEY_DIAGNOSTIC_POP
-#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
-#undef JSON_HEDLEY_DMC_VERSION
-#undef JSON_HEDLEY_DMC_VERSION_CHECK
-#undef JSON_HEDLEY_EMPTY_BASES
-#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
-#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
-#undef JSON_HEDLEY_END_C_DECLS
-#undef JSON_HEDLEY_FLAGS
-#undef JSON_HEDLEY_FLAGS_CAST
-#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_GCC_HAS_BUILTIN
-#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_GCC_HAS_EXTENSION
-#undef JSON_HEDLEY_GCC_HAS_FEATURE
-#undef JSON_HEDLEY_GCC_HAS_WARNING
-#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
-#undef JSON_HEDLEY_GCC_VERSION
-#undef JSON_HEDLEY_GCC_VERSION_CHECK
-#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
-#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
-#undef JSON_HEDLEY_GNUC_HAS_FEATURE
-#undef JSON_HEDLEY_GNUC_HAS_WARNING
-#undef JSON_HEDLEY_GNUC_VERSION
-#undef JSON_HEDLEY_GNUC_VERSION_CHECK
-#undef JSON_HEDLEY_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_HAS_BUILTIN
-#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
-#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_HAS_EXTENSION
-#undef JSON_HEDLEY_HAS_FEATURE
-#undef JSON_HEDLEY_HAS_WARNING
-#undef JSON_HEDLEY_IAR_VERSION
-#undef JSON_HEDLEY_IAR_VERSION_CHECK
-#undef JSON_HEDLEY_IBM_VERSION
-#undef JSON_HEDLEY_IBM_VERSION_CHECK
-#undef JSON_HEDLEY_IMPORT
-#undef JSON_HEDLEY_INLINE
-#undef JSON_HEDLEY_INTEL_VERSION
-#undef JSON_HEDLEY_INTEL_VERSION_CHECK
-#undef JSON_HEDLEY_IS_CONSTANT
-#undef JSON_HEDLEY_IS_CONSTEXPR_
-#undef JSON_HEDLEY_LIKELY
-#undef JSON_HEDLEY_MALLOC
-#undef JSON_HEDLEY_MESSAGE
-#undef JSON_HEDLEY_MSVC_VERSION
-#undef JSON_HEDLEY_MSVC_VERSION_CHECK
-#undef JSON_HEDLEY_NEVER_INLINE
-#undef JSON_HEDLEY_NON_NULL
-#undef JSON_HEDLEY_NO_ESCAPE
-#undef JSON_HEDLEY_NO_RETURN
-#undef JSON_HEDLEY_NO_THROW
-#undef JSON_HEDLEY_NULL
-#undef JSON_HEDLEY_PELLES_VERSION
-#undef JSON_HEDLEY_PELLES_VERSION_CHECK
-#undef JSON_HEDLEY_PGI_VERSION
-#undef JSON_HEDLEY_PGI_VERSION_CHECK
-#undef JSON_HEDLEY_PREDICT
-#undef JSON_HEDLEY_PRINTF_FORMAT
-#undef JSON_HEDLEY_PRIVATE
-#undef JSON_HEDLEY_PUBLIC
-#undef JSON_HEDLEY_PURE
-#undef JSON_HEDLEY_REINTERPRET_CAST
-#undef JSON_HEDLEY_REQUIRE
-#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
-#undef JSON_HEDLEY_REQUIRE_MSG
-#undef JSON_HEDLEY_RESTRICT
-#undef JSON_HEDLEY_RETURNS_NON_NULL
-#undef JSON_HEDLEY_SENTINEL
-#undef JSON_HEDLEY_STATIC_ASSERT
-#undef JSON_HEDLEY_STATIC_CAST
-#undef JSON_HEDLEY_STRINGIFY
-#undef JSON_HEDLEY_STRINGIFY_EX
-#undef JSON_HEDLEY_SUNPRO_VERSION
-#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
-#undef JSON_HEDLEY_TINYC_VERSION
-#undef JSON_HEDLEY_TINYC_VERSION_CHECK
-#undef JSON_HEDLEY_TI_ARMCL_VERSION
-#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CL2000_VERSION
-#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CL430_VERSION
-#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CL6X_VERSION
-#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CL7X_VERSION
-#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CLPRU_VERSION
-#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
-#undef JSON_HEDLEY_TI_VERSION
-#undef JSON_HEDLEY_TI_VERSION_CHECK
-#undef JSON_HEDLEY_UNAVAILABLE
-#undef JSON_HEDLEY_UNLIKELY
-#undef JSON_HEDLEY_UNPREDICTABLE
-#undef JSON_HEDLEY_UNREACHABLE
-#undef JSON_HEDLEY_UNREACHABLE_RETURN
-#undef JSON_HEDLEY_VERSION
-#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
-#undef JSON_HEDLEY_VERSION_DECODE_MINOR
-#undef JSON_HEDLEY_VERSION_DECODE_REVISION
-#undef JSON_HEDLEY_VERSION_ENCODE
-#undef JSON_HEDLEY_WARNING
-#undef JSON_HEDLEY_WARN_UNUSED_RESULT
-#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
-#undef JSON_HEDLEY_FALL_THROUGH
-
-
-
-#endif  // INCLUDE_NLOHMANN_JSON_HPP_
diff --git a/thirdparty/lz4/LICENSE b/thirdparty/lz4/LICENSE
deleted file mode 100644
index 4884916..0000000
--- a/thirdparty/lz4/LICENSE
+++ /dev/null
@@ -1,24 +0,0 @@
-LZ4 Library
-Copyright (c) 2011-2020, Yann Collet
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice, this
-  list of conditions and the following disclaimer in the documentation and/or
-  other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/thirdparty/lz4/README.md b/thirdparty/lz4/README.md
deleted file mode 100644
index e2af868..0000000
--- a/thirdparty/lz4/README.md
+++ /dev/null
@@ -1,137 +0,0 @@
-LZ4 - Library Files
-================================
-
-The `/lib` directory contains many files, but depending on project's objectives,
-not all of them are necessary.
-
-#### Minimal LZ4 build
-
-The minimum required is **`lz4.c`** and **`lz4.h`**,
-which provides the fast compression and decompression algorithms.
-They generate and decode data using the [LZ4 block format].
-
-
-#### High Compression variant
-
-For more compression ratio at the cost of compression speed,
-the High Compression variant called **lz4hc** is available.
-Add files **`lz4hc.c`** and **`lz4hc.h`**.
-This variant also compresses data using the [LZ4 block format],
-and depends on regular `lib/lz4.*` source files.
-
-
-#### Frame support, for interoperability
-
-In order to produce compressed data compatible with `lz4` command line utility,
-it's necessary to use the [official interoperable frame format].
-This format is generated and decoded automatically by the **lz4frame** library.
-Its public API is described in `lib/lz4frame.h`.
-In order to work properly, lz4frame needs all other modules present in `/lib`,
-including, lz4 and lz4hc, and also **xxhash**.
-So it's necessary to include all `*.c` and `*.h` files present in `/lib`.
-
-
-#### Advanced / Experimental API
-
-Definitions which are not guaranteed to remain stable in future versions,
-are protected behind macros, such as `LZ4_STATIC_LINKING_ONLY`.
-As the name strongly implies, these definitions should only be invoked
-in the context of static linking ***only***.
-Otherwise, dependent application may fail on API or ABI break in the future.
-The associated symbols are also not exposed by the dynamic library by default.
-Should they be nonetheless needed, it's possible to force their publication
-by using build macros `LZ4_PUBLISH_STATIC_FUNCTIONS`
-and `LZ4F_PUBLISH_STATIC_FUNCTIONS`.
-
-
-#### Build macros
-
-The following build macro can be selected to adjust source code behavior at compilation time :
-
-- `LZ4_FAST_DEC_LOOP` : this triggers a speed optimized decompression loop, more powerful on modern cpus.
-  This loop works great on `x86`, `x64` and `aarch64` cpus, and is automatically enabled for them.
-  It's also possible to enable or disable it manually, by passing `LZ4_FAST_DEC_LOOP=1` or `0` to the preprocessor.
-  For example, with `gcc` : `-DLZ4_FAST_DEC_LOOP=1`,
-  and with `make` : `CPPFLAGS+=-DLZ4_FAST_DEC_LOOP=1 make lz4`.
-
-- `LZ4_DISTANCE_MAX` : control the maximum offset that the compressor will allow.
-  Set to 65535 by default, which is the maximum value supported by lz4 format.
-  Reducing maximum distance will reduce opportunities for LZ4 to find matches,
-  hence will produce a worse compression ratio.
-  However, a smaller max distance can allow compatibility with specific decoders using limited memory budget.
-  This build macro only influences the compressed output of the compressor.
-
-- `LZ4_DISABLE_DEPRECATE_WARNINGS` : invoking a deprecated function will make the compiler generate a warning.
-  This is meant to invite users to update their source code.
-  Should this be a problem, it's generally possible to make the compiler ignore these warnings,
-  for example with `-Wno-deprecated-declarations` on `gcc`,
-  or `_CRT_SECURE_NO_WARNINGS` for Visual Studio.
-  This build macro offers another project-specific method
-  by defining `LZ4_DISABLE_DEPRECATE_WARNINGS` before including the LZ4 header files.
-
-- `LZ4_USER_MEMORY_FUNCTIONS` : replace calls to <stdlib>'s `malloc`, `calloc` and `free`
-  by user-defined functions, which must be called `LZ4_malloc()`, `LZ4_calloc()` and `LZ4_free()`.
-  User functions must be available at link time.
-
-- `LZ4_FORCE_SW_BITCOUNT` : by default, the compression algorithm tries to determine lengths
-  by using bitcount instructions, generally implemented as fast single instructions in many cpus.
-  In case the target cpus doesn't support it, or compiler intrinsic doesn't work, or feature bad performance,
-  it's possible to use an optimized software path instead.
-  This is achieved by setting this build macros .
-  In most cases, it's not expected to be necessary,
-  but it can be legitimately considered for less common platforms.
-
-- `LZ4_ALIGN_TEST` : alignment test ensures that the memory area
-  passed as argument to become a compression state is suitably aligned.
-  This test can be disabled if it proves flaky, by setting this value to 0.
-
-
-#### Amalgamation
-
-lz4 source code can be amalgamated into a single file.
-One can combine all source code into `lz4_all.c` by using following command:
-```
-cat lz4.c lz4hc.c lz4frame.c > lz4_all.c
-```
-(`cat` file order is important) then compile `lz4_all.c`.
-All `*.h` files present in `/lib` remain necessary to compile `lz4_all.c`.
-
-
-#### Windows : using MinGW+MSYS to create DLL
-
-DLL can be created using MinGW+MSYS with the `make liblz4` command.
-This command creates `dll\liblz4.dll` and the import library `dll\liblz4.lib`.
-To override the `dlltool` command  when cross-compiling on Linux, just set the `DLLTOOL` variable. Example of cross compilation on Linux with mingw-w64 64 bits:
-```
-make BUILD_STATIC=no CC=x86_64-w64-mingw32-gcc DLLTOOL=x86_64-w64-mingw32-dlltool OS=Windows_NT
-```
-The import library is only required with Visual C++.
-The header files `lz4.h`, `lz4hc.h`, `lz4frame.h` and the dynamic library
-`dll\liblz4.dll` are required to compile a project using gcc/MinGW.
-The dynamic library has to be added to linking options.
-It means that if a project that uses LZ4 consists of a single `test-dll.c`
-file it should be linked with `dll\liblz4.dll`. For example:
-```
-    $(CC) $(CFLAGS) -Iinclude/ test-dll.c -o test-dll dll\liblz4.dll
-```
-The compiled executable will require LZ4 DLL which is available at `dll\liblz4.dll`.
-
-
-#### Miscellaneous
-
-Other files present in the directory are not source code. They are :
-
- - `LICENSE` : contains the BSD license text
- - `Makefile` : `make` script to compile and install lz4 library (static and dynamic)
- - `liblz4.pc.in` : for `pkg-config` (used in `make install`)
- - `README.md` : this file
-
-[official interoperable frame format]: ../doc/lz4_Frame_format.md
-[LZ4 block format]: ../doc/lz4_Block_format.md
-
-
-#### License
-
-All source material within __lib__ directory are BSD 2-Clause licensed.
-See [LICENSE](LICENSE) for details.
-The license is also reminded at the top of each source file.
diff --git a/thirdparty/lz4/lz4.c b/thirdparty/lz4/lz4.c
deleted file mode 100644
index 9f8cecb..0000000
--- a/thirdparty/lz4/lz4.c
+++ /dev/null
@@ -1,2495 +0,0 @@
-/*
-   LZ4 - Fast LZ compression algorithm
-   Copyright (C) 2011-2020, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-    - LZ4 homepage : http://www.lz4.org
-    - LZ4 source repository : https://github.com/lz4/lz4
-*/
-
-/*-************************************
-*  Tuning parameters
-**************************************/
-/*
- * LZ4_HEAPMODE :
- * Select how default compression functions will allocate memory for their hash table,
- * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).
- */
-#ifndef LZ4_HEAPMODE
-#  define LZ4_HEAPMODE 0
-#endif
-
-/*
- * LZ4_ACCELERATION_DEFAULT :
- * Select "acceleration" for LZ4_compress_fast() when parameter value <= 0
- */
-#define LZ4_ACCELERATION_DEFAULT 1
-/*
- * LZ4_ACCELERATION_MAX :
- * Any "acceleration" value higher than this threshold
- * get treated as LZ4_ACCELERATION_MAX instead (fix #876)
- */
-#define LZ4_ACCELERATION_MAX 65537
-
-
-/*-************************************
-*  CPU Feature Detection
-**************************************/
-/* LZ4_FORCE_MEMORY_ACCESS
- * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
- * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
- * The below switch allow to select different access method for improved performance.
- * Method 0 (default) : use `memcpy()`. Safe and portable.
- * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
- *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
- * Method 2 : direct access. This method is portable but violate C standard.
- *            It can generate buggy code on targets which assembly generation depends on alignment.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally */
-#  if defined(__GNUC__) && \
-  ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \
-  || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
-#    define LZ4_FORCE_MEMORY_ACCESS 2
-#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__)
-#    define LZ4_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-/*
- * LZ4_FORCE_SW_BITCOUNT
- * Define this parameter if your target system or compiler does not support hardware bit count
- */
-#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for WinCE doesn't support Hardware bit count */
-#  undef  LZ4_FORCE_SW_BITCOUNT  /* avoid double def */
-#  define LZ4_FORCE_SW_BITCOUNT
-#endif
-
-
-
-/*-************************************
-*  Dependency
-**************************************/
-/*
- * LZ4_SRC_INCLUDED:
- * Amalgamation flag, whether lz4.c is included
- */
-#ifndef LZ4_SRC_INCLUDED
-#  define LZ4_SRC_INCLUDED 1
-#endif
-
-#ifndef LZ4_STATIC_LINKING_ONLY
-#define LZ4_STATIC_LINKING_ONLY
-#endif
-
-#ifndef LZ4_DISABLE_DEPRECATE_WARNINGS
-#define LZ4_DISABLE_DEPRECATE_WARNINGS /* due to LZ4_decompress_safe_withPrefix64k */
-#endif
-
-#define LZ4_STATIC_LINKING_ONLY  /* LZ4_DISTANCE_MAX */
-#include "lz4.h"
-/* see also "memory routines" below */
-
-
-/*-************************************
-*  Compiler Options
-**************************************/
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)  /* Visual Studio 2005+ */
-#  include <intrin.h>               /* only present in VS2005+ */
-#  pragma warning(disable : 4127)   /* disable: C4127: conditional expression is constant */
-#endif  /* _MSC_VER */
-
-#ifndef LZ4_FORCE_INLINE
-#  ifdef _MSC_VER    /* Visual Studio */
-#    define LZ4_FORCE_INLINE static __forceinline
-#  else
-#    if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#      ifdef __GNUC__
-#        define LZ4_FORCE_INLINE static inline __attribute__((always_inline))
-#      else
-#        define LZ4_FORCE_INLINE static inline
-#      endif
-#    else
-#      define LZ4_FORCE_INLINE static
-#    endif /* __STDC_VERSION__ */
-#  endif  /* _MSC_VER */
-#endif /* LZ4_FORCE_INLINE */
-
-/* LZ4_FORCE_O2 and LZ4_FORCE_INLINE
- * gcc on ppc64le generates an unrolled SIMDized loop for LZ4_wildCopy8,
- * together with a simple 8-byte copy loop as a fall-back path.
- * However, this optimization hurts the decompression speed by >30%,
- * because the execution does not go to the optimized loop
- * for typical compressible data, and all of the preamble checks
- * before going to the fall-back path become useless overhead.
- * This optimization happens only with the -O3 flag, and -O2 generates
- * a simple 8-byte copy loop.
- * With gcc on ppc64le, all of the LZ4_decompress_* and LZ4_wildCopy8
- * functions are annotated with __attribute__((optimize("O2"))),
- * and also LZ4_wildCopy8 is forcibly inlined, so that the O2 attribute
- * of LZ4_wildCopy8 does not affect the compression speed.
- */
-#if defined(__PPC64__) && defined(__LITTLE_ENDIAN__) && defined(__GNUC__) && !defined(__clang__)
-#  define LZ4_FORCE_O2  __attribute__((optimize("O2")))
-#  undef LZ4_FORCE_INLINE
-#  define LZ4_FORCE_INLINE  static __inline __attribute__((optimize("O2"),always_inline))
-#else
-#  define LZ4_FORCE_O2
-#endif
-
-#if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)
-#  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
-#else
-#  define expect(expr,value)    (expr)
-#endif
-
-#ifndef likely
-#define likely(expr)     expect((expr) != 0, 1)
-#endif
-#ifndef unlikely
-#define unlikely(expr)   expect((expr) != 0, 0)
-#endif
-
-/* Should the alignment test prove unreliable, for some reason,
- * it can be disabled by setting LZ4_ALIGN_TEST to 0 */
-#ifndef LZ4_ALIGN_TEST  /* can be externally provided */
-# define LZ4_ALIGN_TEST 1
-#endif
-
-
-/*-************************************
-*  Memory routines
-**************************************/
-#ifdef LZ4_USER_MEMORY_FUNCTIONS
-/* memory management functions can be customized by user project.
- * Below functions must exist somewhere in the Project
- * and be available at link time */
-void* LZ4_malloc(size_t s);
-void* LZ4_calloc(size_t n, size_t s);
-void  LZ4_free(void* p);
-# define ALLOC(s)          LZ4_malloc(s)
-# define ALLOC_AND_ZERO(s) LZ4_calloc(1,s)
-# define FREEMEM(p)        LZ4_free(p)
-#else
-# include <stdlib.h>   /* malloc, calloc, free */
-# define ALLOC(s)          malloc(s)
-# define ALLOC_AND_ZERO(s) calloc(1,s)
-# define FREEMEM(p)        free(p)
-#endif
-
-#include <string.h>   /* memset, memcpy */
-#define MEM_INIT(p,v,s)   memset((p),(v),(s))
-
-
-/*-************************************
-*  Common Constants
-**************************************/
-#define MINMATCH 4
-
-#define WILDCOPYLENGTH 8
-#define LASTLITERALS   5   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
-#define MFLIMIT       12   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
-#define MATCH_SAFEGUARD_DISTANCE  ((2*WILDCOPYLENGTH) - MINMATCH)   /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */
-#define FASTLOOP_SAFE_DISTANCE 64
-static const int LZ4_minLength = (MFLIMIT+1);
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define LZ4_DISTANCE_ABSOLUTE_MAX 65535
-#if (LZ4_DISTANCE_MAX > LZ4_DISTANCE_ABSOLUTE_MAX)   /* max supported by LZ4 format */
-#  error "LZ4_DISTANCE_MAX is too big : must be <= 65535"
-#endif
-
-#define ML_BITS  4
-#define ML_MASK  ((1U<<ML_BITS)-1)
-#define RUN_BITS (8-ML_BITS)
-#define RUN_MASK ((1U<<RUN_BITS)-1)
-
-
-/*-************************************
-*  Error detection
-**************************************/
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=1)
-#  include <assert.h>
-#else
-#  ifndef assert
-#    define assert(condition) ((void)0)
-#  endif
-#endif
-
-#define LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use after variable declarations */
-
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2)
-#  include <stdio.h>
-   static int g_debuglog_enable = 1;
-#  define DEBUGLOG(l, ...) {                          \
-        if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \
-            fprintf(stderr, __FILE__ ": ");           \
-            fprintf(stderr, __VA_ARGS__);             \
-            fprintf(stderr, " \n");                   \
-    }   }
-#else
-#  define DEBUGLOG(l, ...) {}    /* disabled */
-#endif
-
-static int LZ4_isAligned(const void* ptr, size_t alignment)
-{
-    return ((size_t)ptr & (alignment -1)) == 0;
-}
-
-
-/*-************************************
-*  Types
-**************************************/
-#include <limits.h>
-#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-  typedef uintptr_t uptrval;
-#else
-# if UINT_MAX != 4294967295UL
-#   error "LZ4 code (when not C++ or C99) assumes that sizeof(int) == 4"
-# endif
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-  typedef size_t              uptrval;   /* generally true, except OpenVMS-64 */
-#endif
-
-#if defined(__x86_64__)
-  typedef U64    reg_t;   /* 64-bits in x32 mode */
-#else
-  typedef size_t reg_t;   /* 32-bits in x32 mode */
-#endif
-
-typedef enum {
-    notLimited = 0,
-    limitedOutput = 1,
-    fillOutput = 2
-} limitedOutput_directive;
-
-
-/*-************************************
-*  Reading and writing into memory
-**************************************/
-
-/**
- * LZ4 relies on memcpy with a constant size being inlined. In freestanding
- * environments, the compiler can't assume the implementation of memcpy() is
- * standard compliant, so it can't apply its specialized memcpy() inlining
- * logic. When possible, use __builtin_memcpy() to tell the compiler to analyze
- * memcpy() as if it were standard compliant, so it can inline it in freestanding
- * environments. This is needed when decompressing the Linux Kernel, for example.
- */
-#if defined(__GNUC__) && (__GNUC__ >= 4)
-#define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size)
-#else
-#define LZ4_memcpy(dst, src, size) memcpy(dst, src, size)
-#endif
-
-static unsigned LZ4_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
-    return one.c[0];
-}
-
-
-#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)
-/* lie to the compiler about data alignment; use with caution */
-
-static U16 LZ4_read16(const void* memPtr) { return *(const U16*) memPtr; }
-static U32 LZ4_read32(const void* memPtr) { return *(const U32*) memPtr; }
-static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*) memPtr; }
-
-static void LZ4_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
-static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
-
-#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1)
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-typedef union { U16 u16; U32 u32; reg_t uArch; } __attribute__((packed)) unalign;
-
-static U16 LZ4_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
-static U32 LZ4_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-static reg_t LZ4_read_ARCH(const void* ptr) { return ((const unalign*)ptr)->uArch; }
-
-static void LZ4_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
-static void LZ4_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
-
-#else  /* safe and portable access using memcpy() */
-
-static U16 LZ4_read16(const void* memPtr)
-{
-    U16 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static U32 LZ4_read32(const void* memPtr)
-{
-    U32 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static reg_t LZ4_read_ARCH(const void* memPtr)
-{
-    reg_t val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static void LZ4_write16(void* memPtr, U16 value)
-{
-    LZ4_memcpy(memPtr, &value, sizeof(value));
-}
-
-static void LZ4_write32(void* memPtr, U32 value)
-{
-    LZ4_memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif /* LZ4_FORCE_MEMORY_ACCESS */
-
-
-static U16 LZ4_readLE16(const void* memPtr)
-{
-    if (LZ4_isLittleEndian()) {
-        return LZ4_read16(memPtr);
-    } else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)((U16)p[0] + (p[1]<<8));
-    }
-}
-
-static void LZ4_writeLE16(void* memPtr, U16 value)
-{
-    if (LZ4_isLittleEndian()) {
-        LZ4_write16(memPtr, value);
-    } else {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE) value;
-        p[1] = (BYTE)(value>>8);
-    }
-}
-
-/* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */
-LZ4_FORCE_INLINE
-void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd)
-{
-    BYTE* d = (BYTE*)dstPtr;
-    const BYTE* s = (const BYTE*)srcPtr;
-    BYTE* const e = (BYTE*)dstEnd;
-
-    do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d<e);
-}
-
-static const unsigned inc32table[8] = {0, 1, 2,  1,  0,  4, 4, 4};
-static const int      dec64table[8] = {0, 0, 0, -1, -4,  1, 2, 3};
-
-
-#ifndef LZ4_FAST_DEC_LOOP
-#  if defined __i386__ || defined _M_IX86 || defined __x86_64__ || defined _M_X64
-#    define LZ4_FAST_DEC_LOOP 1
-#  elif defined(__aarch64__) && !defined(__clang__)
-     /* On aarch64, we disable this optimization for clang because on certain
-      * mobile chipsets, performance is reduced with clang. For information
-      * refer to https://github.com/lz4/lz4/pull/707 */
-#    define LZ4_FAST_DEC_LOOP 1
-#  else
-#    define LZ4_FAST_DEC_LOOP 0
-#  endif
-#endif
-
-#if LZ4_FAST_DEC_LOOP
-
-LZ4_FORCE_INLINE void
-LZ4_memcpy_using_offset_base(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
-{
-    assert(srcPtr + offset == dstPtr);
-    if (offset < 8) {
-        LZ4_write32(dstPtr, 0);   /* silence an msan warning when offset==0 */
-        dstPtr[0] = srcPtr[0];
-        dstPtr[1] = srcPtr[1];
-        dstPtr[2] = srcPtr[2];
-        dstPtr[3] = srcPtr[3];
-        srcPtr += inc32table[offset];
-        LZ4_memcpy(dstPtr+4, srcPtr, 4);
-        srcPtr -= dec64table[offset];
-        dstPtr += 8;
-    } else {
-        LZ4_memcpy(dstPtr, srcPtr, 8);
-        dstPtr += 8;
-        srcPtr += 8;
-    }
-
-    LZ4_wildCopy8(dstPtr, srcPtr, dstEnd);
-}
-
-/* customized variant of memcpy, which can overwrite up to 32 bytes beyond dstEnd
- * this version copies two times 16 bytes (instead of one time 32 bytes)
- * because it must be compatible with offsets >= 16. */
-LZ4_FORCE_INLINE void
-LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd)
-{
-    BYTE* d = (BYTE*)dstPtr;
-    const BYTE* s = (const BYTE*)srcPtr;
-    BYTE* const e = (BYTE*)dstEnd;
-
-    do { LZ4_memcpy(d,s,16); LZ4_memcpy(d+16,s+16,16); d+=32; s+=32; } while (d<e);
-}
-
-/* LZ4_memcpy_using_offset()  presumes :
- * - dstEnd >= dstPtr + MINMATCH
- * - there is at least 8 bytes available to write after dstEnd */
-LZ4_FORCE_INLINE void
-LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
-{
-    BYTE v[8];
-
-    assert(dstEnd >= dstPtr + MINMATCH);
-
-    switch(offset) {
-    case 1:
-        MEM_INIT(v, *srcPtr, 8);
-        break;
-    case 2:
-        LZ4_memcpy(v, srcPtr, 2);
-        LZ4_memcpy(&v[2], srcPtr, 2);
-        LZ4_memcpy(&v[4], v, 4);
-        break;
-    case 4:
-        LZ4_memcpy(v, srcPtr, 4);
-        LZ4_memcpy(&v[4], srcPtr, 4);
-        break;
-    default:
-        LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset);
-        return;
-    }
-
-    LZ4_memcpy(dstPtr, v, 8);
-    dstPtr += 8;
-    while (dstPtr < dstEnd) {
-        LZ4_memcpy(dstPtr, v, 8);
-        dstPtr += 8;
-    }
-}
-#endif
-
-
-/*-************************************
-*  Common functions
-**************************************/
-static unsigned LZ4_NbCommonBytes (reg_t val)
-{
-    assert(val != 0);
-    if (LZ4_isLittleEndian()) {
-        if (sizeof(val) == 8) {
-#       if defined(_MSC_VER) && (_MSC_VER >= 1800) && defined(_M_AMD64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            /* x64 CPUS without BMI support interpret `TZCNT` as `REP BSF` */
-            return (unsigned)_tzcnt_u64(val) >> 3;
-#       elif defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanForward64(&r, (U64)val);
-            return (unsigned)r >> 3;
-#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                                        !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (unsigned)__builtin_ctzll((U64)val) >> 3;
-#       else
-            const U64 m = 0x0101010101010101ULL;
-            val ^= val - 1;
-            return (unsigned)(((U64)((val & (m - 1)) * m)) >> 56);
-#       endif
-        } else /* 32 bits */ {
-#       if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r;
-            _BitScanForward(&r, (U32)val);
-            return (unsigned)r >> 3;
-#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (unsigned)__builtin_ctz((U32)val) >> 3;
-#       else
-            const U32 m = 0x01010101;
-            return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;
-#       endif
-        }
-    } else   /* Big Endian CPU */ {
-        if (sizeof(val)==8) {
-#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (unsigned)__builtin_clzll((U64)val) >> 3;
-#       else
-#if 1
-            /* this method is probably faster,
-             * but adds a 128 bytes lookup table */
-            static const unsigned char ctz7_tab[128] = {
-                7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-            };
-            U64 const mask = 0x0101010101010101ULL;
-            U64 const t = (((val >> 8) - mask) | val) & mask;
-            return ctz7_tab[(t * 0x0080402010080402ULL) >> 57];
-#else
-            /* this method doesn't consume memory space like the previous one,
-             * but it contains several branches,
-             * that may end up slowing execution */
-            static const U32 by32 = sizeof(val)*4;  /* 32 on 64 bits (goal), 16 on 32 bits.
-            Just to avoid some static analyzer complaining about shift by 32 on 32-bits target.
-            Note that this code path is never triggered in 32-bits mode. */
-            unsigned r;
-            if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; }
-            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
-            r += (!val);
-            return r;
-#endif
-#       endif
-        } else /* 32 bits */ {
-#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                                        !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (unsigned)__builtin_clz((U32)val) >> 3;
-#       else
-            val >>= 8;
-            val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) |
-              (val + 0x00FF0000)) >> 24;
-            return (unsigned)val ^ 3;
-#       endif
-        }
-    }
-}
-
-
-#define STEPSIZE sizeof(reg_t)
-LZ4_FORCE_INLINE
-unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
-{
-    const BYTE* const pStart = pIn;
-
-    if (likely(pIn < pInLimit-(STEPSIZE-1))) {
-        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
-        if (!diff) {
-            pIn+=STEPSIZE; pMatch+=STEPSIZE;
-        } else {
-            return LZ4_NbCommonBytes(diff);
-    }   }
-
-    while (likely(pIn < pInLimit-(STEPSIZE-1))) {
-        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
-        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
-        pIn += LZ4_NbCommonBytes(diff);
-        return (unsigned)(pIn - pStart);
-    }
-
-    if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
-    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
-    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
-    return (unsigned)(pIn - pStart);
-}
-
-
-#ifndef LZ4_COMMONDEFS_ONLY
-/*-************************************
-*  Local Constants
-**************************************/
-static const int LZ4_64Klimit = ((64 KB) + (MFLIMIT-1));
-static const U32 LZ4_skipTrigger = 6;  /* Increase this value ==> compression run slower on incompressible data */
-
-
-/*-************************************
-*  Local Structures and types
-**************************************/
-typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t;
-
-/**
- * This enum distinguishes several different modes of accessing previous
- * content in the stream.
- *
- * - noDict        : There is no preceding content.
- * - withPrefix64k : Table entries up to ctx->dictSize before the current blob
- *                   blob being compressed are valid and refer to the preceding
- *                   content (of length ctx->dictSize), which is available
- *                   contiguously preceding in memory the content currently
- *                   being compressed.
- * - usingExtDict  : Like withPrefix64k, but the preceding content is somewhere
- *                   else in memory, starting at ctx->dictionary with length
- *                   ctx->dictSize.
- * - usingDictCtx  : Like usingExtDict, but everything concerning the preceding
- *                   content is in a separate context, pointed to by
- *                   ctx->dictCtx. ctx->dictionary, ctx->dictSize, and table
- *                   entries in the current context that refer to positions
- *                   preceding the beginning of the current compression are
- *                   ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx
- *                   ->dictSize describe the location and size of the preceding
- *                   content, and matches are found by looking in the ctx
- *                   ->dictCtx->hashTable.
- */
-typedef enum { noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive;
-typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;
-
-
-/*-************************************
-*  Local Utils
-**************************************/
-int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; }
-const char* LZ4_versionString(void) { return LZ4_VERSION_STRING; }
-int LZ4_compressBound(int isize)  { return LZ4_COMPRESSBOUND(isize); }
-int LZ4_sizeofState(void) { return LZ4_STREAMSIZE; }
-
-
-/*-************************************
-*  Internal Definitions used in Tests
-**************************************/
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize);
-
-int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int maxOutputSize,
-                                     const void* dictStart, size_t dictSize);
-
-#if defined (__cplusplus)
-}
-#endif
-
-/*-******************************
-*  Compression functions
-********************************/
-LZ4_FORCE_INLINE U32 LZ4_hash4(U32 sequence, tableType_t const tableType)
-{
-    if (tableType == byU16)
-        return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));
-    else
-        return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
-}
-
-LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
-{
-    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
-    if (LZ4_isLittleEndian()) {
-        const U64 prime5bytes = 889523592379ULL;
-        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
-    } else {
-        const U64 prime8bytes = 11400714785074694791ULL;
-        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
-    }
-}
-
-LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)
-{
-    if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
-    return LZ4_hash4(LZ4_read32(p), tableType);
-}
-
-LZ4_FORCE_INLINE void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType)
-{
-    switch (tableType)
-    {
-    default: /* fallthrough */
-    case clearedTable: { /* illegal! */ assert(0); return; }
-    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; }
-    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; }
-    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; }
-    }
-}
-
-LZ4_FORCE_INLINE void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType)
-{
-    switch (tableType)
-    {
-    default: /* fallthrough */
-    case clearedTable: /* fallthrough */
-    case byPtr: { /* illegal! */ assert(0); return; }
-    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }
-    case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
-    }
-}
-
-LZ4_FORCE_INLINE void LZ4_putPositionOnHash(const BYTE* p, U32 h,
-                                  void* tableBase, tableType_t const tableType,
-                            const BYTE* srcBase)
-{
-    switch (tableType)
-    {
-    case clearedTable: { /* illegal! */ assert(0); return; }
-    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
-    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
-    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
-    }
-}
-
-LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
-{
-    U32 const h = LZ4_hashPosition(p, tableType);
-    LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
-}
-
-/* LZ4_getIndexOnHash() :
- * Index of match position registered in hash table.
- * hash position must be calculated by using base+index, or dictBase+index.
- * Assumption 1 : only valid if tableType == byU32 or byU16.
- * Assumption 2 : h is presumed valid (within limits of hash table)
- */
-LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType)
-{
-    LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);
-    if (tableType == byU32) {
-        const U32* const hashTable = (const U32*) tableBase;
-        assert(h < (1U << (LZ4_MEMORY_USAGE-2)));
-        return hashTable[h];
-    }
-    if (tableType == byU16) {
-        const U16* const hashTable = (const U16*) tableBase;
-        assert(h < (1U << (LZ4_MEMORY_USAGE-1)));
-        return hashTable[h];
-    }
-    assert(0); return 0;  /* forbidden case */
-}
-
-static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType, const BYTE* srcBase)
-{
-    if (tableType == byPtr) { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; }
-    if (tableType == byU32) { const U32* const hashTable = (const U32*) tableBase; return hashTable[h] + srcBase; }
-    { const U16* const hashTable = (const U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */
-}
-
-LZ4_FORCE_INLINE const BYTE*
-LZ4_getPosition(const BYTE* p,
-                const void* tableBase, tableType_t tableType,
-                const BYTE* srcBase)
-{
-    U32 const h = LZ4_hashPosition(p, tableType);
-    return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
-}
-
-LZ4_FORCE_INLINE void
-LZ4_prepareTable(LZ4_stream_t_internal* const cctx,
-           const int inputSize,
-           const tableType_t tableType) {
-    /* If the table hasn't been used, it's guaranteed to be zeroed out, and is
-     * therefore safe to use no matter what mode we're in. Otherwise, we figure
-     * out if it's safe to leave as is or whether it needs to be reset.
-     */
-    if ((tableType_t)cctx->tableType != clearedTable) {
-        assert(inputSize >= 0);
-        if ((tableType_t)cctx->tableType != tableType
-          || ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU)
-          || ((tableType == byU32) && cctx->currentOffset > 1 GB)
-          || tableType == byPtr
-          || inputSize >= 4 KB)
-        {
-            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx);
-            MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);
-            cctx->currentOffset = 0;
-            cctx->tableType = (U32)clearedTable;
-        } else {
-            DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)");
-        }
-    }
-
-    /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back, is faster
-     * than compressing without a gap. However, compressing with
-     * currentOffset == 0 is faster still, so we preserve that case.
-     */
-    if (cctx->currentOffset != 0 && tableType == byU32) {
-        DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset");
-        cctx->currentOffset += 64 KB;
-    }
-
-    /* Finally, clear history */
-    cctx->dictCtx = NULL;
-    cctx->dictionary = NULL;
-    cctx->dictSize = 0;
-}
-
-/** LZ4_compress_generic() :
- *  inlined, to ensure branches are decided at compilation time.
- *  Presumed already validated at this stage:
- *  - source != NULL
- *  - inputSize > 0
- */
-LZ4_FORCE_INLINE int LZ4_compress_generic_validated(
-                 LZ4_stream_t_internal* const cctx,
-                 const char* const source,
-                 char* const dest,
-                 const int inputSize,
-                 int *inputConsumed, /* only written when outputDirective == fillOutput */
-                 const int maxOutputSize,
-                 const limitedOutput_directive outputDirective,
-                 const tableType_t tableType,
-                 const dict_directive dictDirective,
-                 const dictIssue_directive dictIssue,
-                 const int acceleration)
-{
-    int result;
-    const BYTE* ip = (const BYTE*) source;
-
-    U32 const startIndex = cctx->currentOffset;
-    const BYTE* base = (const BYTE*) source - startIndex;
-    const BYTE* lowLimit;
-
-    const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx;
-    const BYTE* const dictionary =
-        dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary;
-    const U32 dictSize =
-        dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize;
-    const U32 dictDelta = (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0;   /* make indexes in dictCtx comparable with index in current context */
-
-    int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx);
-    U32 const prefixIdxLimit = startIndex - dictSize;   /* used when dictDirective == dictSmall */
-    const BYTE* const dictEnd = dictionary ? dictionary + dictSize : dictionary;
-    const BYTE* anchor = (const BYTE*) source;
-    const BYTE* const iend = ip + inputSize;
-    const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1;
-    const BYTE* const matchlimit = iend - LASTLITERALS;
-
-    /* the dictCtx currentOffset is indexed on the start of the dictionary,
-     * while a dictionary in the current context precedes the currentOffset */
-    const BYTE* dictBase = !dictionary ? NULL : (dictDirective == usingDictCtx) ?
-                            dictionary + dictSize - dictCtx->currentOffset :
-                            dictionary + dictSize - startIndex;
-
-    BYTE* op = (BYTE*) dest;
-    BYTE* const olimit = op + maxOutputSize;
-
-    U32 offset = 0;
-    U32 forwardH;
-
-    DEBUGLOG(5, "LZ4_compress_generic_validated: srcSize=%i, tableType=%u", inputSize, tableType);
-    assert(ip != NULL);
-    /* If init conditions are not met, we don't have to mark stream
-     * as having dirty context, since no action was taken yet */
-    if (outputDirective == fillOutput && maxOutputSize < 1) { return 0; } /* Impossible to store anything */
-    if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) { return 0; }  /* Size too large (not within 64K limit) */
-    if (tableType==byPtr) assert(dictDirective==noDict);      /* only supported use case with byPtr */
-    assert(acceleration >= 1);
-
-    lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0);
-
-    /* Update context state */
-    if (dictDirective == usingDictCtx) {
-        /* Subsequent linked blocks can't use the dictionary. */
-        /* Instead, they use the block we just compressed. */
-        cctx->dictCtx = NULL;
-        cctx->dictSize = (U32)inputSize;
-    } else {
-        cctx->dictSize += (U32)inputSize;
-    }
-    cctx->currentOffset += (U32)inputSize;
-    cctx->tableType = (U32)tableType;
-
-    if (inputSize<LZ4_minLength) goto _last_literals;        /* Input too small, no compression (all literals) */
-
-    /* First Byte */
-    LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-    ip++; forwardH = LZ4_hashPosition(ip, tableType);
-
-    /* Main Loop */
-    for ( ; ; ) {
-        const BYTE* match;
-        BYTE* token;
-        const BYTE* filledIp;
-
-        /* Find a match */
-        if (tableType == byPtr) {
-            const BYTE* forwardIp = ip;
-            int step = 1;
-            int searchMatchNb = acceleration << LZ4_skipTrigger;
-            do {
-                U32 const h = forwardH;
-                ip = forwardIp;
-                forwardIp += step;
-                step = (searchMatchNb++ >> LZ4_skipTrigger);
-
-                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
-                assert(ip < mflimitPlusOne);
-
-                match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base);
-                forwardH = LZ4_hashPosition(forwardIp, tableType);
-                LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base);
-
-            } while ( (match+LZ4_DISTANCE_MAX < ip)
-                   || (LZ4_read32(match) != LZ4_read32(ip)) );
-
-        } else {   /* byU32, byU16 */
-
-            const BYTE* forwardIp = ip;
-            int step = 1;
-            int searchMatchNb = acceleration << LZ4_skipTrigger;
-            do {
-                U32 const h = forwardH;
-                U32 const current = (U32)(forwardIp - base);
-                U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
-                assert(matchIndex <= current);
-                assert(forwardIp - base < (ptrdiff_t)(2 GB - 1));
-                ip = forwardIp;
-                forwardIp += step;
-                step = (searchMatchNb++ >> LZ4_skipTrigger);
-
-                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
-                assert(ip < mflimitPlusOne);
-
-                if (dictDirective == usingDictCtx) {
-                    if (matchIndex < startIndex) {
-                        /* there was no match, try the dictionary */
-                        assert(tableType == byU32);
-                        matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
-                        match = dictBase + matchIndex;
-                        matchIndex += dictDelta;   /* make dictCtx index comparable with current context */
-                        lowLimit = dictionary;
-                    } else {
-                        match = base + matchIndex;
-                        lowLimit = (const BYTE*)source;
-                    }
-                } else if (dictDirective==usingExtDict) {
-                    if (matchIndex < startIndex) {
-                        DEBUGLOG(7, "extDict candidate: matchIndex=%5u  <  startIndex=%5u", matchIndex, startIndex);
-                        assert(startIndex - matchIndex >= MINMATCH);
-                        match = dictBase + matchIndex;
-                        lowLimit = dictionary;
-                    } else {
-                        match = base + matchIndex;
-                        lowLimit = (const BYTE*)source;
-                    }
-                } else {   /* single continuous memory segment */
-                    match = base + matchIndex;
-                }
-                forwardH = LZ4_hashPosition(forwardIp, tableType);
-                LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
-
-                DEBUGLOG(7, "candidate at pos=%u  (offset=%u \n", matchIndex, current - matchIndex);
-                if ((dictIssue == dictSmall) && (matchIndex < prefixIdxLimit)) { continue; }    /* match outside of valid area */
-                assert(matchIndex < current);
-                if ( ((tableType != byU16) || (LZ4_DISTANCE_MAX < LZ4_DISTANCE_ABSOLUTE_MAX))
-                  && (matchIndex+LZ4_DISTANCE_MAX < current)) {
-                    continue;
-                } /* too far */
-                assert((current - matchIndex) <= LZ4_DISTANCE_MAX);  /* match now expected within distance */
-
-                if (LZ4_read32(match) == LZ4_read32(ip)) {
-                    if (maybe_extMem) offset = current - matchIndex;
-                    break;   /* match found */
-                }
-
-            } while(1);
-        }
-
-        /* Catch up */
-        filledIp = ip;
-        while (((ip>anchor) & (match > lowLimit)) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; }
-
-        /* Encode Literals */
-        {   unsigned const litLength = (unsigned)(ip - anchor);
-            token = op++;
-            if ((outputDirective == limitedOutput) &&  /* Check output buffer overflow */
-                (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)) ) {
-                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
-            }
-            if ((outputDirective == fillOutput) &&
-                (unlikely(op + (litLength+240)/255 /* litlen */ + litLength /* literals */ + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit))) {
-                op--;
-                goto _last_literals;
-            }
-            if (litLength >= RUN_MASK) {
-                int len = (int)(litLength - RUN_MASK);
-                *token = (RUN_MASK<<ML_BITS);
-                for(; len >= 255 ; len-=255) *op++ = 255;
-                *op++ = (BYTE)len;
-            }
-            else *token = (BYTE)(litLength<<ML_BITS);
-
-            /* Copy Literals */
-            LZ4_wildCopy8(op, anchor, op+litLength);
-            op+=litLength;
-            DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
-                        (int)(anchor-(const BYTE*)source), litLength, (int)(ip-(const BYTE*)source));
-        }
-
-_next_match:
-        /* at this stage, the following variables must be correctly set :
-         * - ip : at start of LZ operation
-         * - match : at start of previous pattern occurence; can be within current prefix, or within extDict
-         * - offset : if maybe_ext_memSegment==1 (constant)
-         * - lowLimit : must be == dictionary to mean "match is within extDict"; must be == source otherwise
-         * - token and *token : position to write 4-bits for match length; higher 4-bits for literal length supposed already written
-         */
-
-        if ((outputDirective == fillOutput) &&
-            (op + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit)) {
-            /* the match was too close to the end, rewind and go to last literals */
-            op = token;
-            goto _last_literals;
-        }
-
-        /* Encode Offset */
-        if (maybe_extMem) {   /* static test */
-            DEBUGLOG(6, "             with offset=%u  (ext if > %i)", offset, (int)(ip - (const BYTE*)source));
-            assert(offset <= LZ4_DISTANCE_MAX && offset > 0);
-            LZ4_writeLE16(op, (U16)offset); op+=2;
-        } else  {
-            DEBUGLOG(6, "             with offset=%u  (same segment)", (U32)(ip - match));
-            assert(ip-match <= LZ4_DISTANCE_MAX);
-            LZ4_writeLE16(op, (U16)(ip - match)); op+=2;
-        }
-
-        /* Encode MatchLength */
-        {   unsigned matchCode;
-
-            if ( (dictDirective==usingExtDict || dictDirective==usingDictCtx)
-              && (lowLimit==dictionary) /* match within extDict */ ) {
-                const BYTE* limit = ip + (dictEnd-match);
-                assert(dictEnd > match);
-                if (limit > matchlimit) limit = matchlimit;
-                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
-                ip += (size_t)matchCode + MINMATCH;
-                if (ip==limit) {
-                    unsigned const more = LZ4_count(limit, (const BYTE*)source, matchlimit);
-                    matchCode += more;
-                    ip += more;
-                }
-                DEBUGLOG(6, "             with matchLength=%u starting in extDict", matchCode+MINMATCH);
-            } else {
-                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
-                ip += (size_t)matchCode + MINMATCH;
-                DEBUGLOG(6, "             with matchLength=%u", matchCode+MINMATCH);
-            }
-
-            if ((outputDirective) &&    /* Check output buffer overflow */
-                (unlikely(op + (1 + LASTLITERALS) + (matchCode+240)/255 > olimit)) ) {
-                if (outputDirective == fillOutput) {
-                    /* Match description too long : reduce it */
-                    U32 newMatchCode = 15 /* in token */ - 1 /* to avoid needing a zero byte */ + ((U32)(olimit - op) - 1 - LASTLITERALS) * 255;
-                    ip -= matchCode - newMatchCode;
-                    assert(newMatchCode < matchCode);
-                    matchCode = newMatchCode;
-                    if (unlikely(ip <= filledIp)) {
-                        /* We have already filled up to filledIp so if ip ends up less than filledIp
-                         * we have positions in the hash table beyond the current position. This is
-                         * a problem if we reuse the hash table. So we have to remove these positions
-                         * from the hash table.
-                         */
-                        const BYTE* ptr;
-                        DEBUGLOG(5, "Clearing %u positions", (U32)(filledIp - ip));
-                        for (ptr = ip; ptr <= filledIp; ++ptr) {
-                            U32 const h = LZ4_hashPosition(ptr, tableType);
-                            LZ4_clearHash(h, cctx->hashTable, tableType);
-                        }
-                    }
-                } else {
-                    assert(outputDirective == limitedOutput);
-                    return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
-                }
-            }
-            if (matchCode >= ML_MASK) {
-                *token += ML_MASK;
-                matchCode -= ML_MASK;
-                LZ4_write32(op, 0xFFFFFFFF);
-                while (matchCode >= 4*255) {
-                    op+=4;
-                    LZ4_write32(op, 0xFFFFFFFF);
-                    matchCode -= 4*255;
-                }
-                op += matchCode / 255;
-                *op++ = (BYTE)(matchCode % 255);
-            } else
-                *token += (BYTE)(matchCode);
-        }
-        /* Ensure we have enough space for the last literals. */
-        assert(!(outputDirective == fillOutput && op + 1 + LASTLITERALS > olimit));
-
-        anchor = ip;
-
-        /* Test end of chunk */
-        if (ip >= mflimitPlusOne) break;
-
-        /* Fill table */
-        LZ4_putPosition(ip-2, cctx->hashTable, tableType, base);
-
-        /* Test next position */
-        if (tableType == byPtr) {
-
-            match = LZ4_getPosition(ip, cctx->hashTable, tableType, base);
-            LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-            if ( (match+LZ4_DISTANCE_MAX >= ip)
-              && (LZ4_read32(match) == LZ4_read32(ip)) )
-            { token=op++; *token=0; goto _next_match; }
-
-        } else {   /* byU32, byU16 */
-
-            U32 const h = LZ4_hashPosition(ip, tableType);
-            U32 const current = (U32)(ip-base);
-            U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
-            assert(matchIndex < current);
-            if (dictDirective == usingDictCtx) {
-                if (matchIndex < startIndex) {
-                    /* there was no match, try the dictionary */
-                    matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
-                    match = dictBase + matchIndex;
-                    lowLimit = dictionary;   /* required for match length counter */
-                    matchIndex += dictDelta;
-                } else {
-                    match = base + matchIndex;
-                    lowLimit = (const BYTE*)source;  /* required for match length counter */
-                }
-            } else if (dictDirective==usingExtDict) {
-                if (matchIndex < startIndex) {
-                    match = dictBase + matchIndex;
-                    lowLimit = dictionary;   /* required for match length counter */
-                } else {
-                    match = base + matchIndex;
-                    lowLimit = (const BYTE*)source;   /* required for match length counter */
-                }
-            } else {   /* single memory segment */
-                match = base + matchIndex;
-            }
-            LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
-            assert(matchIndex < current);
-            if ( ((dictIssue==dictSmall) ? (matchIndex >= prefixIdxLimit) : 1)
-              && (((tableType==byU16) && (LZ4_DISTANCE_MAX == LZ4_DISTANCE_ABSOLUTE_MAX)) ? 1 : (matchIndex+LZ4_DISTANCE_MAX >= current))
-              && (LZ4_read32(match) == LZ4_read32(ip)) ) {
-                token=op++;
-                *token=0;
-                if (maybe_extMem) offset = current - matchIndex;
-                DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
-                            (int)(anchor-(const BYTE*)source), 0, (int)(ip-(const BYTE*)source));
-                goto _next_match;
-            }
-        }
-
-        /* Prepare next loop */
-        forwardH = LZ4_hashPosition(++ip, tableType);
-
-    }
-
-_last_literals:
-    /* Encode Last Literals */
-    {   size_t lastRun = (size_t)(iend - anchor);
-        if ( (outputDirective) &&  /* Check output buffer overflow */
-            (op + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > olimit)) {
-            if (outputDirective == fillOutput) {
-                /* adapt lastRun to fill 'dst' */
-                assert(olimit >= op);
-                lastRun  = (size_t)(olimit-op) - 1/*token*/;
-                lastRun -= (lastRun + 256 - RUN_MASK) / 256;  /*additional length tokens*/
-            } else {
-                assert(outputDirective == limitedOutput);
-                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
-            }
-        }
-        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRun);
-        if (lastRun >= RUN_MASK) {
-            size_t accumulator = lastRun - RUN_MASK;
-            *op++ = RUN_MASK << ML_BITS;
-            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
-            *op++ = (BYTE) accumulator;
-        } else {
-            *op++ = (BYTE)(lastRun<<ML_BITS);
-        }
-        LZ4_memcpy(op, anchor, lastRun);
-        ip = anchor + lastRun;
-        op += lastRun;
-    }
-
-    if (outputDirective == fillOutput) {
-        *inputConsumed = (int) (((const char*)ip)-source);
-    }
-    result = (int)(((char*)op) - dest);
-    assert(result > 0);
-    DEBUGLOG(5, "LZ4_compress_generic: compressed %i bytes into %i bytes", inputSize, result);
-    return result;
-}
-
-/** LZ4_compress_generic() :
- *  inlined, to ensure branches are decided at compilation time;
- *  takes care of src == (NULL, 0)
- *  and forward the rest to LZ4_compress_generic_validated */
-LZ4_FORCE_INLINE int LZ4_compress_generic(
-                 LZ4_stream_t_internal* const cctx,
-                 const char* const src,
-                 char* const dst,
-                 const int srcSize,
-                 int *inputConsumed, /* only written when outputDirective == fillOutput */
-                 const int dstCapacity,
-                 const limitedOutput_directive outputDirective,
-                 const tableType_t tableType,
-                 const dict_directive dictDirective,
-                 const dictIssue_directive dictIssue,
-                 const int acceleration)
-{
-    DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, dstCapacity=%i",
-                srcSize, dstCapacity);
-
-    if ((U32)srcSize > (U32)LZ4_MAX_INPUT_SIZE) { return 0; }  /* Unsupported srcSize, too large (or negative) */
-    if (srcSize == 0) {   /* src == NULL supported if srcSize == 0 */
-        if (outputDirective != notLimited && dstCapacity <= 0) return 0;  /* no output, can't write anything */
-        DEBUGLOG(5, "Generating an empty block");
-        assert(outputDirective == notLimited || dstCapacity >= 1);
-        assert(dst != NULL);
-        dst[0] = 0;
-        if (outputDirective == fillOutput) {
-            assert (inputConsumed != NULL);
-            *inputConsumed = 0;
-        }
-        return 1;
-    }
-    assert(src != NULL);
-
-    return LZ4_compress_generic_validated(cctx, src, dst, srcSize,
-                inputConsumed, /* only written into if outputDirective == fillOutput */
-                dstCapacity, outputDirective,
-                tableType, dictDirective, dictIssue, acceleration);
-}
-
-
-int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
-{
-    LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
-    assert(ctx != NULL);
-    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
-    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
-    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
-        if (inputSize < LZ4_64Klimit) {
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, byU16, noDict, noDictIssue, acceleration);
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-        }
-    } else {
-        if (inputSize < LZ4_64Klimit) {
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-        }
-    }
-}
-
-/**
- * LZ4_compress_fast_extState_fastReset() :
- * A variant of LZ4_compress_fast_extState().
- *
- * Using this variant avoids an expensive initialization step. It is only safe
- * to call if the state buffer is known to be correctly initialized already
- * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
- * "correctly initialized").
- */
-int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration)
-{
-    LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
-    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
-    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
-
-    if (dstCapacity >= LZ4_compressBound(srcSize)) {
-        if (srcSize < LZ4_64Klimit) {
-            const tableType_t tableType = byU16;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            if (ctx->currentOffset) {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, dictSmall, acceleration);
-            } else {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-            }
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-        }
-    } else {
-        if (srcSize < LZ4_64Klimit) {
-            const tableType_t tableType = byU16;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            if (ctx->currentOffset) {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, dictSmall, acceleration);
-            } else {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-            }
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-        }
-    }
-}
-
-
-int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
-{
-    int result;
-#if (LZ4_HEAPMODE)
-    LZ4_stream_t* ctxPtr = ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-    if (ctxPtr == NULL) return 0;
-#else
-    LZ4_stream_t ctx;
-    LZ4_stream_t* const ctxPtr = &ctx;
-#endif
-    result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration);
-
-#if (LZ4_HEAPMODE)
-    FREEMEM(ctxPtr);
-#endif
-    return result;
-}
-
-
-int LZ4_compress_default(const char* src, char* dst, int srcSize, int maxOutputSize)
-{
-    return LZ4_compress_fast(src, dst, srcSize, maxOutputSize, 1);
-}
-
-
-/* Note!: This function leaves the stream in an unclean/broken state!
- * It is not safe to subsequently use the same state with a _fastReset() or
- * _continue() call without resetting it. */
-static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize)
-{
-    void* const s = LZ4_initStream(state, sizeof (*state));
-    assert(s != NULL); (void)s;
-
-    if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
-        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
-    } else {
-        if (*srcSizePtr < LZ4_64Klimit) {
-            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, byU16, noDict, noDictIssue, 1);
-        } else {
-            tableType_t const addrMode = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, addrMode, noDict, noDictIssue, 1);
-    }   }
-}
-
-
-int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
-{
-#if (LZ4_HEAPMODE)
-    LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-    if (ctx == NULL) return 0;
-#else
-    LZ4_stream_t ctxBody;
-    LZ4_stream_t* ctx = &ctxBody;
-#endif
-
-    int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
-
-#if (LZ4_HEAPMODE)
-    FREEMEM(ctx);
-#endif
-    return result;
-}
-
-
-
-/*-******************************
-*  Streaming functions
-********************************/
-
-LZ4_stream_t* LZ4_createStream(void)
-{
-    LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));
-    LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal));    /* A compilation error here means LZ4_STREAMSIZE is not large enough */
-    DEBUGLOG(4, "LZ4_createStream %p", lz4s);
-    if (lz4s == NULL) return NULL;
-    LZ4_initStream(lz4s, sizeof(*lz4s));
-    return lz4s;
-}
-
-static size_t LZ4_stream_t_alignment(void)
-{
-#if LZ4_ALIGN_TEST
-    typedef struct { char c; LZ4_stream_t t; } t_a;
-    return sizeof(t_a) - sizeof(LZ4_stream_t);
-#else
-    return 1;  /* effectively disabled */
-#endif
-}
-
-LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
-{
-    DEBUGLOG(5, "LZ4_initStream");
-    if (buffer == NULL) { return NULL; }
-    if (size < sizeof(LZ4_stream_t)) { return NULL; }
-    if (!LZ4_isAligned(buffer, LZ4_stream_t_alignment())) return NULL;
-    MEM_INIT(buffer, 0, sizeof(LZ4_stream_t_internal));
-    return (LZ4_stream_t*)buffer;
-}
-
-/* resetStream is now deprecated,
- * prefer initStream() which is more general */
-void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
-{
-    DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
-    MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t_internal));
-}
-
-void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
-    LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32);
-}
-
-int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
-{
-    if (!LZ4_stream) return 0;   /* support free on NULL */
-    DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
-    FREEMEM(LZ4_stream);
-    return (0);
-}
-
-
-#define HASH_UNIT sizeof(reg_t)
-int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
-{
-    LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse;
-    const tableType_t tableType = byU32;
-    const BYTE* p = (const BYTE*)dictionary;
-    const BYTE* const dictEnd = p + dictSize;
-    const BYTE* base;
-
-    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict);
-
-    /* It's necessary to reset the context,
-     * and not just continue it with prepareTable()
-     * to avoid any risk of generating overflowing matchIndex
-     * when compressing using this dictionary */
-    LZ4_resetStream(LZ4_dict);
-
-    /* We always increment the offset by 64 KB, since, if the dict is longer,
-     * we truncate it to the last 64k, and if it's shorter, we still want to
-     * advance by a whole window length so we can provide the guarantee that
-     * there are only valid offsets in the window, which allows an optimization
-     * in LZ4_compress_fast_continue() where it uses noDictIssue even when the
-     * dictionary isn't a full 64k. */
-    dict->currentOffset += 64 KB;
-
-    if (dictSize < (int)HASH_UNIT) {
-        return 0;
-    }
-
-    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
-    base = dictEnd - dict->currentOffset;
-    dict->dictionary = p;
-    dict->dictSize = (U32)(dictEnd - p);
-    dict->tableType = (U32)tableType;
-
-    while (p <= dictEnd-HASH_UNIT) {
-        LZ4_putPosition(p, dict->hashTable, tableType, base);
-        p+=3;
-    }
-
-    return (int)dict->dictSize;
-}
-
-void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) {
-    const LZ4_stream_t_internal* dictCtx = dictionaryStream == NULL ? NULL :
-        &(dictionaryStream->internal_donotuse);
-
-    DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)",
-             workingStream, dictionaryStream,
-             dictCtx != NULL ? dictCtx->dictSize : 0);
-
-    if (dictCtx != NULL) {
-        /* If the current offset is zero, we will never look in the
-         * external dictionary context, since there is no value a table
-         * entry can take that indicate a miss. In that case, we need
-         * to bump the offset to something non-zero.
-         */
-        if (workingStream->internal_donotuse.currentOffset == 0) {
-            workingStream->internal_donotuse.currentOffset = 64 KB;
-        }
-
-        /* Don't actually attach an empty dictionary.
-         */
-        if (dictCtx->dictSize == 0) {
-            dictCtx = NULL;
-        }
-    }
-    workingStream->internal_donotuse.dictCtx = dictCtx;
-}
-
-
-static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
-{
-    assert(nextSize >= 0);
-    if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) {   /* potential ptrdiff_t overflow (32-bits mode) */
-        /* rescale hash table */
-        U32 const delta = LZ4_dict->currentOffset - 64 KB;
-        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
-        int i;
-        DEBUGLOG(4, "LZ4_renormDictT");
-        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
-            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
-            else LZ4_dict->hashTable[i] -= delta;
-        }
-        LZ4_dict->currentOffset = 64 KB;
-        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
-        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
-    }
-}
-
-
-int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream,
-                                const char* source, char* dest,
-                                int inputSize, int maxOutputSize,
-                                int acceleration)
-{
-    const tableType_t tableType = byU32;
-    LZ4_stream_t_internal* streamPtr = &LZ4_stream->internal_donotuse;
-    const BYTE* dictEnd = streamPtr->dictionary + streamPtr->dictSize;
-
-    DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i)", inputSize);
-
-    LZ4_renormDictT(streamPtr, inputSize);   /* avoid index overflow */
-    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
-    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
-
-    /* invalidate tiny dictionaries */
-    if ( (streamPtr->dictSize-1 < 4-1)   /* intentional underflow */
-      && (dictEnd != (const BYTE*)source) ) {
-        DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary);
-        streamPtr->dictSize = 0;
-        streamPtr->dictionary = (const BYTE*)source;
-        dictEnd = (const BYTE*)source;
-    }
-
-    /* Check overlapping input/dictionary space */
-    {   const BYTE* sourceEnd = (const BYTE*) source + inputSize;
-        if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd)) {
-            streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
-            if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
-            if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
-            streamPtr->dictionary = dictEnd - streamPtr->dictSize;
-        }
-    }
-
-    /* prefix mode : source data follows dictionary */
-    if (dictEnd == (const BYTE*)source) {
-        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
-            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration);
-        else
-            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, noDictIssue, acceleration);
-    }
-
-    /* external dictionary mode */
-    {   int result;
-        if (streamPtr->dictCtx) {
-            /* We depend here on the fact that dictCtx'es (produced by
-             * LZ4_loadDict) guarantee that their tables contain no references
-             * to offsets between dictCtx->currentOffset - 64 KB and
-             * dictCtx->currentOffset - dictCtx->dictSize. This makes it safe
-             * to use noDictIssue even when the dict isn't a full 64 KB.
-             */
-            if (inputSize > 4 KB) {
-                /* For compressing large blobs, it is faster to pay the setup
-                 * cost to copy the dictionary's tables into the active context,
-                 * so that the compression loop is only looking into one table.
-                 */
-                LZ4_memcpy(streamPtr, streamPtr->dictCtx, sizeof(*streamPtr));
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
-            } else {
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration);
-            }
-        } else {
-            if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration);
-            } else {
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
-            }
-        }
-        streamPtr->dictionary = (const BYTE*)source;
-        streamPtr->dictSize = (U32)inputSize;
-        return result;
-    }
-}
-
-
-/* Hidden debug function, to force-test external dictionary mode */
-int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize)
-{
-    LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
-    int result;
-
-    LZ4_renormDictT(streamPtr, srcSize);
-
-    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
-        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1);
-    } else {
-        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
-    }
-
-    streamPtr->dictionary = (const BYTE*)source;
-    streamPtr->dictSize = (U32)srcSize;
-
-    return result;
-}
-
-
-/*! LZ4_saveDict() :
- *  If previously compressed data block is not guaranteed to remain available at its memory location,
- *  save it into a safer place (char* safeBuffer).
- *  Note : you don't need to call LZ4_loadDict() afterwards,
- *         dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue().
- *  Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
- */
-int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
-{
-    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
-    const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
-
-    if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
-    if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }
-
-    if (safeBuffer == NULL) assert(dictSize == 0);
-    if (dictSize > 0)
-        memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
-
-    dict->dictionary = (const BYTE*)safeBuffer;
-    dict->dictSize = (U32)dictSize;
-
-    return dictSize;
-}
-
-
-
-/*-*******************************
- *  Decompression functions
- ********************************/
-
-typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;
-typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive;
-
-#undef MIN
-#define MIN(a,b)    ( (a) < (b) ? (a) : (b) )
-
-/* Read the variable-length literal or match length.
- *
- * ip - pointer to use as input.
- * lencheck - end ip.  Return an error if ip advances >= lencheck.
- * loop_check - check ip >= lencheck in body of loop.  Returns loop_error if so.
- * initial_check - check ip >= lencheck before start of loop.  Returns initial_error if so.
- * error (output) - error code.  Should be set to 0 before call.
- */
-typedef enum { loop_error = -2, initial_error = -1, ok = 0 } variable_length_error;
-LZ4_FORCE_INLINE unsigned
-read_variable_length(const BYTE**ip, const BYTE* lencheck,
-                     int loop_check, int initial_check,
-                     variable_length_error* error)
-{
-    U32 length = 0;
-    U32 s;
-    if (initial_check && unlikely((*ip) >= lencheck)) {    /* overflow detection */
-        *error = initial_error;
-        return length;
-    }
-    do {
-        s = **ip;
-        (*ip)++;
-        length += s;
-        if (loop_check && unlikely((*ip) >= lencheck)) {    /* overflow detection */
-            *error = loop_error;
-            return length;
-        }
-    } while (s==255);
-
-    return length;
-}
-
-/*! LZ4_decompress_generic() :
- *  This generic decompression function covers all use cases.
- *  It shall be instantiated several times, using different sets of directives.
- *  Note that it is important for performance that this function really get inlined,
- *  in order to remove useless branches during compilation optimization.
- */
-LZ4_FORCE_INLINE int
-LZ4_decompress_generic(
-                 const char* const src,
-                 char* const dst,
-                 int srcSize,
-                 int outputSize,         /* If endOnInput==endOnInputSize, this value is `dstCapacity` */
-
-                 endCondition_directive endOnInput,   /* endOnOutputSize, endOnInputSize */
-                 earlyEnd_directive partialDecoding,  /* full, partial */
-                 dict_directive dict,                 /* noDict, withPrefix64k, usingExtDict */
-                 const BYTE* const lowPrefix,  /* always <= dst, == dst when no prefix */
-                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
-                 const size_t dictSize         /* note : = 0 if noDict */
-                 )
-{
-    if (src == NULL) { return -1; }
-
-    {   const BYTE* ip = (const BYTE*) src;
-        const BYTE* const iend = ip + srcSize;
-
-        BYTE* op = (BYTE*) dst;
-        BYTE* const oend = op + outputSize;
-        BYTE* cpy;
-
-        const BYTE* const dictEnd = (dictStart == NULL) ? NULL : dictStart + dictSize;
-
-        const int safeDecode = (endOnInput==endOnInputSize);
-        const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
-
-
-        /* Set up the "end" pointers for the shortcut. */
-        const BYTE* const shortiend = iend - (endOnInput ? 14 : 8) /*maxLL*/ - 2 /*offset*/;
-        const BYTE* const shortoend = oend - (endOnInput ? 14 : 8) /*maxLL*/ - 18 /*maxML*/;
-
-        const BYTE* match;
-        size_t offset;
-        unsigned token;
-        size_t length;
-
-
-        DEBUGLOG(5, "LZ4_decompress_generic (srcSize:%i, dstSize:%i)", srcSize, outputSize);
-
-        /* Special cases */
-        assert(lowPrefix <= op);
-        if ((endOnInput) && (unlikely(outputSize==0))) {
-            /* Empty output buffer */
-            if (partialDecoding) return 0;
-            return ((srcSize==1) && (*ip==0)) ? 0 : -1;
-        }
-        if ((!endOnInput) && (unlikely(outputSize==0))) { return (*ip==0 ? 1 : -1); }
-        if ((endOnInput) && unlikely(srcSize==0)) { return -1; }
-
-	/* Currently the fast loop shows a regression on qualcomm arm chips. */
-#if LZ4_FAST_DEC_LOOP
-        if ((oend - op) < FASTLOOP_SAFE_DISTANCE) {
-            DEBUGLOG(6, "skip fast decode loop");
-            goto safe_decode;
-        }
-
-        /* Fast loop : decode sequences as long as output < iend-FASTLOOP_SAFE_DISTANCE */
-        while (1) {
-            /* Main fastloop assertion: We can always wildcopy FASTLOOP_SAFE_DISTANCE */
-            assert(oend - op >= FASTLOOP_SAFE_DISTANCE);
-            if (endOnInput) { assert(ip < iend); }
-            token = *ip++;
-            length = token >> ML_BITS;  /* literal length */
-
-            assert(!endOnInput || ip <= iend); /* ip < iend before the increment */
-
-            /* decode literal length */
-            if (length == RUN_MASK) {
-                variable_length_error error = ok;
-                length += read_variable_length(&ip, iend-RUN_MASK, (int)endOnInput, (int)endOnInput, &error);
-                if (error == initial_error) { goto _output_error; }
-                if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
-                if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
-
-                /* copy literals */
-                cpy = op+length;
-                LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
-                if (endOnInput) {  /* LZ4_decompress_safe() */
-                    if ((cpy>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; }
-                    LZ4_wildCopy32(op, ip, cpy);
-                } else {   /* LZ4_decompress_fast() */
-                    if (cpy>oend-8) { goto safe_literal_copy; }
-                    LZ4_wildCopy8(op, ip, cpy); /* LZ4_decompress_fast() cannot copy more than 8 bytes at a time :
-                                                 * it doesn't know input length, and only relies on end-of-block properties */
-                }
-                ip += length; op = cpy;
-            } else {
-                cpy = op+length;
-                if (endOnInput) {  /* LZ4_decompress_safe() */
-                    DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length);
-                    /* We don't need to check oend, since we check it once for each loop below */
-                    if (ip > iend-(16 + 1/*max lit + offset + nextToken*/)) { goto safe_literal_copy; }
-                    /* Literals can only be 14, but hope compilers optimize if we copy by a register size */
-                    LZ4_memcpy(op, ip, 16);
-                } else {  /* LZ4_decompress_fast() */
-                    /* LZ4_decompress_fast() cannot copy more than 8 bytes at a time :
-                     * it doesn't know input length, and relies on end-of-block properties */
-                    LZ4_memcpy(op, ip, 8);
-                    if (length > 8) { LZ4_memcpy(op+8, ip+8, 8); }
-                }
-                ip += length; op = cpy;
-            }
-
-            /* get offset */
-            offset = LZ4_readLE16(ip); ip+=2;
-            match = op - offset;
-            assert(match <= op);
-
-            /* get matchlength */
-            length = token & ML_MASK;
-
-            if (length == ML_MASK) {
-                variable_length_error error = ok;
-                if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */
-                length += read_variable_length(&ip, iend - LASTLITERALS + 1, (int)endOnInput, 0, &error);
-                if (error != ok) { goto _output_error; }
-                if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */
-                length += MINMATCH;
-                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
-                    goto safe_match_copy;
-                }
-            } else {
-                length += MINMATCH;
-                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
-                    goto safe_match_copy;
-                }
-
-                /* Fastpath check: Avoids a branch in LZ4_wildCopy32 if true */
-                if ((dict == withPrefix64k) || (match >= lowPrefix)) {
-                    if (offset >= 8) {
-                        assert(match >= lowPrefix);
-                        assert(match <= op);
-                        assert(op + 18 <= oend);
-
-                        LZ4_memcpy(op, match, 8);
-                        LZ4_memcpy(op+8, match+8, 8);
-                        LZ4_memcpy(op+16, match+16, 2);
-                        op += length;
-                        continue;
-            }   }   }
-
-            if (checkOffset && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */
-            /* match starting within external dictionary */
-            if ((dict==usingExtDict) && (match < lowPrefix)) {
-                if (unlikely(op+length > oend-LASTLITERALS)) {
-                    if (partialDecoding) {
-                        DEBUGLOG(7, "partialDecoding: dictionary match, close to dstEnd");
-                        length = MIN(length, (size_t)(oend-op));
-                    } else {
-                        goto _output_error;  /* end-of-block condition violated */
-                }   }
-
-                if (length <= (size_t)(lowPrefix-match)) {
-                    /* match fits entirely within external dictionary : just copy */
-                    memmove(op, dictEnd - (lowPrefix-match), length);
-                    op += length;
-                } else {
-                    /* match stretches into both external dictionary and current block */
-                    size_t const copySize = (size_t)(lowPrefix - match);
-                    size_t const restSize = length - copySize;
-                    LZ4_memcpy(op, dictEnd - copySize, copySize);
-                    op += copySize;
-                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
-                        BYTE* const endOfMatch = op + restSize;
-                        const BYTE* copyFrom = lowPrefix;
-                        while (op < endOfMatch) { *op++ = *copyFrom++; }
-                    } else {
-                        LZ4_memcpy(op, lowPrefix, restSize);
-                        op += restSize;
-                }   }
-                continue;
-            }
-
-            /* copy match within block */
-            cpy = op + length;
-
-            assert((op <= oend) && (oend-op >= 32));
-            if (unlikely(offset<16)) {
-                LZ4_memcpy_using_offset(op, match, cpy, offset);
-            } else {
-                LZ4_wildCopy32(op, match, cpy);
-            }
-
-            op = cpy;   /* wildcopy correction */
-        }
-    safe_decode:
-#endif
-
-        /* Main Loop : decode remaining sequences where output < FASTLOOP_SAFE_DISTANCE */
-        while (1) {
-            token = *ip++;
-            length = token >> ML_BITS;  /* literal length */
-
-            assert(!endOnInput || ip <= iend); /* ip < iend before the increment */
-
-            /* A two-stage shortcut for the most common case:
-             * 1) If the literal length is 0..14, and there is enough space,
-             * enter the shortcut and copy 16 bytes on behalf of the literals
-             * (in the fast mode, only 8 bytes can be safely copied this way).
-             * 2) Further if the match length is 4..18, copy 18 bytes in a similar
-             * manner; but we ensure that there's enough space in the output for
-             * those 18 bytes earlier, upon entering the shortcut (in other words,
-             * there is a combined check for both stages).
-             */
-            if ( (endOnInput ? length != RUN_MASK : length <= 8)
-                /* strictly "less than" on input, to re-enter the loop with at least one byte */
-              && likely((endOnInput ? ip < shortiend : 1) & (op <= shortoend)) ) {
-                /* Copy the literals */
-                LZ4_memcpy(op, ip, endOnInput ? 16 : 8);
-                op += length; ip += length;
-
-                /* The second stage: prepare for match copying, decode full info.
-                 * If it doesn't work out, the info won't be wasted. */
-                length = token & ML_MASK; /* match length */
-                offset = LZ4_readLE16(ip); ip += 2;
-                match = op - offset;
-                assert(match <= op); /* check overflow */
-
-                /* Do not deal with overlapping matches. */
-                if ( (length != ML_MASK)
-                  && (offset >= 8)
-                  && (dict==withPrefix64k || match >= lowPrefix) ) {
-                    /* Copy the match. */
-                    LZ4_memcpy(op + 0, match + 0, 8);
-                    LZ4_memcpy(op + 8, match + 8, 8);
-                    LZ4_memcpy(op +16, match +16, 2);
-                    op += length + MINMATCH;
-                    /* Both stages worked, load the next token. */
-                    continue;
-                }
-
-                /* The second stage didn't work out, but the info is ready.
-                 * Propel it right to the point of match copying. */
-                goto _copy_match;
-            }
-
-            /* decode literal length */
-            if (length == RUN_MASK) {
-                variable_length_error error = ok;
-                length += read_variable_length(&ip, iend-RUN_MASK, (int)endOnInput, (int)endOnInput, &error);
-                if (error == initial_error) { goto _output_error; }
-                if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
-                if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
-            }
-
-            /* copy literals */
-            cpy = op+length;
-#if LZ4_FAST_DEC_LOOP
-        safe_literal_copy:
-#endif
-            LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
-            if ( ((endOnInput) && ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) )
-              || ((!endOnInput) && (cpy>oend-WILDCOPYLENGTH)) )
-            {
-                /* We've either hit the input parsing restriction or the output parsing restriction.
-                 * In the normal scenario, decoding a full block, it must be the last sequence,
-                 * otherwise it's an error (invalid input or dimensions).
-                 * In partialDecoding scenario, it's necessary to ensure there is no buffer overflow.
-                 */
-                if (partialDecoding) {
-                    /* Since we are partial decoding we may be in this block because of the output parsing
-                     * restriction, which is not valid since the output buffer is allowed to be undersized.
-                     */
-                    assert(endOnInput);
-                    DEBUGLOG(7, "partialDecoding: copying literals, close to input or output end")
-                    DEBUGLOG(7, "partialDecoding: literal length = %u", (unsigned)length);
-                    DEBUGLOG(7, "partialDecoding: remaining space in dstBuffer : %i", (int)(oend - op));
-                    DEBUGLOG(7, "partialDecoding: remaining space in srcBuffer : %i", (int)(iend - ip));
-                    /* Finishing in the middle of a literals segment,
-                     * due to lack of input.
-                     */
-                    if (ip+length > iend) {
-                        length = (size_t)(iend-ip);
-                        cpy = op + length;
-                    }
-                    /* Finishing in the middle of a literals segment,
-                     * due to lack of output space.
-                     */
-                    if (cpy > oend) {
-                        cpy = oend;
-                        assert(op<=oend);
-                        length = (size_t)(oend-op);
-                    }
-                } else {
-                    /* We must be on the last sequence because of the parsing limitations so check
-                     * that we exactly regenerate the original size (must be exact when !endOnInput).
-                     */
-                    if ((!endOnInput) && (cpy != oend)) { goto _output_error; }
-                     /* We must be on the last sequence (or invalid) because of the parsing limitations
-                      * so check that we exactly consume the input and don't overrun the output buffer.
-                      */
-                    if ((endOnInput) && ((ip+length != iend) || (cpy > oend))) {
-                        DEBUGLOG(6, "should have been last run of literals")
-                        DEBUGLOG(6, "ip(%p) + length(%i) = %p != iend (%p)", ip, (int)length, ip+length, iend);
-                        DEBUGLOG(6, "or cpy(%p) > oend(%p)", cpy, oend);
-                        goto _output_error;
-                    }
-                }
-                memmove(op, ip, length);  /* supports overlapping memory regions; only matters for in-place decompression scenarios */
-                ip += length;
-                op += length;
-                /* Necessarily EOF when !partialDecoding.
-                 * When partialDecoding, it is EOF if we've either
-                 * filled the output buffer or
-                 * can't proceed with reading an offset for following match.
-                 */
-                if (!partialDecoding || (cpy == oend) || (ip >= (iend-2))) {
-                    break;
-                }
-            } else {
-                LZ4_wildCopy8(op, ip, cpy);   /* may overwrite up to WILDCOPYLENGTH beyond cpy */
-                ip += length; op = cpy;
-            }
-
-            /* get offset */
-            offset = LZ4_readLE16(ip); ip+=2;
-            match = op - offset;
-
-            /* get matchlength */
-            length = token & ML_MASK;
-
-    _copy_match:
-            if (length == ML_MASK) {
-              variable_length_error error = ok;
-              length += read_variable_length(&ip, iend - LASTLITERALS + 1, (int)endOnInput, 0, &error);
-              if (error != ok) goto _output_error;
-                if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
-            }
-            length += MINMATCH;
-
-#if LZ4_FAST_DEC_LOOP
-        safe_match_copy:
-#endif
-            if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error;   /* Error : offset outside buffers */
-            /* match starting within external dictionary */
-            if ((dict==usingExtDict) && (match < lowPrefix)) {
-                if (unlikely(op+length > oend-LASTLITERALS)) {
-                    if (partialDecoding) length = MIN(length, (size_t)(oend-op));
-                    else goto _output_error;   /* doesn't respect parsing restriction */
-                }
-
-                if (length <= (size_t)(lowPrefix-match)) {
-                    /* match fits entirely within external dictionary : just copy */
-                    memmove(op, dictEnd - (lowPrefix-match), length);
-                    op += length;
-                } else {
-                    /* match stretches into both external dictionary and current block */
-                    size_t const copySize = (size_t)(lowPrefix - match);
-                    size_t const restSize = length - copySize;
-                    LZ4_memcpy(op, dictEnd - copySize, copySize);
-                    op += copySize;
-                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
-                        BYTE* const endOfMatch = op + restSize;
-                        const BYTE* copyFrom = lowPrefix;
-                        while (op < endOfMatch) *op++ = *copyFrom++;
-                    } else {
-                        LZ4_memcpy(op, lowPrefix, restSize);
-                        op += restSize;
-                }   }
-                continue;
-            }
-            assert(match >= lowPrefix);
-
-            /* copy match within block */
-            cpy = op + length;
-
-            /* partialDecoding : may end anywhere within the block */
-            assert(op<=oend);
-            if (partialDecoding && (cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
-                size_t const mlen = MIN(length, (size_t)(oend-op));
-                const BYTE* const matchEnd = match + mlen;
-                BYTE* const copyEnd = op + mlen;
-                if (matchEnd > op) {   /* overlap copy */
-                    while (op < copyEnd) { *op++ = *match++; }
-                } else {
-                    LZ4_memcpy(op, match, mlen);
-                }
-                op = copyEnd;
-                if (op == oend) { break; }
-                continue;
-            }
-
-            if (unlikely(offset<8)) {
-                LZ4_write32(op, 0);   /* silence msan warning when offset==0 */
-                op[0] = match[0];
-                op[1] = match[1];
-                op[2] = match[2];
-                op[3] = match[3];
-                match += inc32table[offset];
-                LZ4_memcpy(op+4, match, 4);
-                match -= dec64table[offset];
-            } else {
-                LZ4_memcpy(op, match, 8);
-                match += 8;
-            }
-            op += 8;
-
-            if (unlikely(cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
-                BYTE* const oCopyLimit = oend - (WILDCOPYLENGTH-1);
-                if (cpy > oend-LASTLITERALS) { goto _output_error; } /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
-                if (op < oCopyLimit) {
-                    LZ4_wildCopy8(op, match, oCopyLimit);
-                    match += oCopyLimit - op;
-                    op = oCopyLimit;
-                }
-                while (op < cpy) { *op++ = *match++; }
-            } else {
-                LZ4_memcpy(op, match, 8);
-                if (length > 16)  { LZ4_wildCopy8(op+8, match+8, cpy); }
-            }
-            op = cpy;   /* wildcopy correction */
-        }
-
-        /* end of decoding */
-        if (endOnInput) {
-            DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst));
-           return (int) (((char*)op)-dst);     /* Nb of output bytes decoded */
-       } else {
-           return (int) (((const char*)ip)-src);   /* Nb of input bytes read */
-       }
-
-        /* Overflow error detected */
-    _output_error:
-        return (int) (-(((const char*)ip)-src))-1;
-    }
-}
-
-
-/*===== Instantiate the API decoding functions. =====*/
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize,
-                                  endOnInputSize, decode_full_block, noDict,
-                                  (BYTE*)dest, NULL, 0);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize, int targetOutputSize, int dstCapacity)
-{
-    dstCapacity = MIN(targetOutputSize, dstCapacity);
-    return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity,
-                                  endOnInputSize, partial_decode,
-                                  noDict, (BYTE*)dst, NULL, 0);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
-{
-    return LZ4_decompress_generic(source, dest, 0, originalSize,
-                                  endOnOutputSize, decode_full_block, withPrefix64k,
-                                  (BYTE*)dest - 64 KB, NULL, 0);
-}
-
-/*===== Instantiate a few more decoding cases, used more than once. =====*/
-
-LZ4_FORCE_O2 /* Exported, an obsolete API function. */
-int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  endOnInputSize, decode_full_block, withPrefix64k,
-                                  (BYTE*)dest - 64 KB, NULL, 0);
-}
-
-/* Another obsolete API function, paired with the previous one. */
-int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
-{
-    /* LZ4_decompress_fast doesn't validate match offsets,
-     * and thus serves well with any prefixed dictionary. */
-    return LZ4_decompress_fast(source, dest, originalSize);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, int compressedSize, int maxOutputSize,
-                                               size_t prefixSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  endOnInputSize, decode_full_block, noDict,
-                                  (BYTE*)dest-prefixSize, NULL, 0);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int maxOutputSize,
-                                     const void* dictStart, size_t dictSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  endOnInputSize, decode_full_block, usingExtDict,
-                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_fast_extDict(const char* source, char* dest, int originalSize,
-                                       const void* dictStart, size_t dictSize)
-{
-    return LZ4_decompress_generic(source, dest, 0, originalSize,
-                                  endOnOutputSize, decode_full_block, usingExtDict,
-                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-}
-
-/* The "double dictionary" mode, for use with e.g. ring buffers: the first part
- * of the dictionary is passed as prefix, and the second via dictStart + dictSize.
- * These routines are used only once, in LZ4_decompress_*_continue().
- */
-LZ4_FORCE_INLINE
-int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compressedSize, int maxOutputSize,
-                                   size_t prefixSize, const void* dictStart, size_t dictSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  endOnInputSize, decode_full_block, usingExtDict,
-                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
-}
-
-LZ4_FORCE_INLINE
-int LZ4_decompress_fast_doubleDict(const char* source, char* dest, int originalSize,
-                                   size_t prefixSize, const void* dictStart, size_t dictSize)
-{
-    return LZ4_decompress_generic(source, dest, 0, originalSize,
-                                  endOnOutputSize, decode_full_block, usingExtDict,
-                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
-}
-
-/*===== streaming decompression functions =====*/
-
-LZ4_streamDecode_t* LZ4_createStreamDecode(void)
-{
-    LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t));
-    LZ4_STATIC_ASSERT(LZ4_STREAMDECODESIZE >= sizeof(LZ4_streamDecode_t_internal));    /* A compilation error here means LZ4_STREAMDECODESIZE is not large enough */
-    return lz4s;
-}
-
-int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
-{
-    if (LZ4_stream == NULL) { return 0; }  /* support free on NULL */
-    FREEMEM(LZ4_stream);
-    return 0;
-}
-
-/*! LZ4_setStreamDecode() :
- *  Use this function to instruct where to find the dictionary.
- *  This function is not necessary if previous data is still available where it was decoded.
- *  Loading a size of 0 is allowed (same effect as no dictionary).
- * @return : 1 if OK, 0 if error
- */
-int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
-{
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    lz4sd->prefixSize = (size_t) dictSize;
-    lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
-    lz4sd->externalDict = NULL;
-    lz4sd->extDictSize  = 0;
-    return 1;
-}
-
-/*! LZ4_decoderRingBufferSize() :
- *  when setting a ring buffer for streaming decompression (optional scenario),
- *  provides the minimum size of this ring buffer
- *  to be compatible with any source respecting maxBlockSize condition.
- *  Note : in a ring buffer scenario,
- *  blocks are presumed decompressed next to each other.
- *  When not enough space remains for next block (remainingSize < maxBlockSize),
- *  decoding resumes from beginning of ring buffer.
- * @return : minimum ring buffer size,
- *           or 0 if there is an error (invalid maxBlockSize).
- */
-int LZ4_decoderRingBufferSize(int maxBlockSize)
-{
-    if (maxBlockSize < 0) return 0;
-    if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0;
-    if (maxBlockSize < 16) maxBlockSize = 16;
-    return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize);
-}
-
-/*
-*_continue() :
-    These decoding functions allow decompression of multiple blocks in "streaming" mode.
-    Previously decoded blocks must still be available at the memory position where they were decoded.
-    If it's not possible, save the relevant part of decoded data into a safe buffer,
-    and indicate where it stands using LZ4_setStreamDecode()
-*/
-LZ4_FORCE_O2
-int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
-{
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    int result;
-
-    if (lz4sd->prefixSize == 0) {
-        /* The first call, no dictionary yet. */
-        assert(lz4sd->extDictSize == 0);
-        result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)result;
-        lz4sd->prefixEnd = (BYTE*)dest + result;
-    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
-        /* They're rolling the current segment. */
-        if (lz4sd->prefixSize >= 64 KB - 1)
-            result = LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
-        else if (lz4sd->extDictSize == 0)
-            result = LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize,
-                                                         lz4sd->prefixSize);
-        else
-            result = LZ4_decompress_safe_doubleDict(source, dest, compressedSize, maxOutputSize,
-                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize += (size_t)result;
-        lz4sd->prefixEnd  += result;
-    } else {
-        /* The buffer wraps around, or they're switching to another buffer. */
-        lz4sd->extDictSize = lz4sd->prefixSize;
-        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-        result = LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize,
-                                                  lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)result;
-        lz4sd->prefixEnd  = (BYTE*)dest + result;
-    }
-
-    return result;
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize)
-{
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    int result;
-    assert(originalSize >= 0);
-
-    if (lz4sd->prefixSize == 0) {
-        assert(lz4sd->extDictSize == 0);
-        result = LZ4_decompress_fast(source, dest, originalSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)originalSize;
-        lz4sd->prefixEnd = (BYTE*)dest + originalSize;
-    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
-        if (lz4sd->prefixSize >= 64 KB - 1 || lz4sd->extDictSize == 0)
-            result = LZ4_decompress_fast(source, dest, originalSize);
-        else
-            result = LZ4_decompress_fast_doubleDict(source, dest, originalSize,
-                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize += (size_t)originalSize;
-        lz4sd->prefixEnd  += originalSize;
-    } else {
-        lz4sd->extDictSize = lz4sd->prefixSize;
-        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-        result = LZ4_decompress_fast_extDict(source, dest, originalSize,
-                                             lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)originalSize;
-        lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
-    }
-
-    return result;
-}
-
-
-/*
-Advanced decoding functions :
-*_usingDict() :
-    These decoding functions work the same as "_continue" ones,
-    the dictionary must be explicitly provided within parameters
-*/
-
-int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
-{
-    if (dictSize==0)
-        return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
-    if (dictStart+dictSize == dest) {
-        if (dictSize >= 64 KB - 1) {
-            return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
-        }
-        assert(dictSize >= 0);
-        return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize);
-    }
-    assert(dictSize >= 0);
-    return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize);
-}
-
-int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
-{
-    if (dictSize==0 || dictStart+dictSize == dest)
-        return LZ4_decompress_fast(source, dest, originalSize);
-    assert(dictSize >= 0);
-    return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, (size_t)dictSize);
-}
-
-
-/*=*************************************************
-*  Obsolete Functions
-***************************************************/
-/* obsolete compression functions */
-int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize)
-{
-    return LZ4_compress_default(source, dest, inputSize, maxOutputSize);
-}
-int LZ4_compress(const char* src, char* dest, int srcSize)
-{
-    return LZ4_compress_default(src, dest, srcSize, LZ4_compressBound(srcSize));
-}
-int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize)
-{
-    return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1);
-}
-int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize)
-{
-    return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1);
-}
-int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int dstCapacity)
-{
-    return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1);
-}
-int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize)
-{
-    return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1);
-}
-
-/*
-These decompression functions are deprecated and should no longer be used.
-They are only provided here for compatibility with older user programs.
-- LZ4_uncompress is totally equivalent to LZ4_decompress_fast
-- LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
-*/
-int LZ4_uncompress (const char* source, char* dest, int outputSize)
-{
-    return LZ4_decompress_fast(source, dest, outputSize);
-}
-int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize)
-{
-    return LZ4_decompress_safe(source, dest, isize, maxOutputSize);
-}
-
-/* Obsolete Streaming functions */
-
-int LZ4_sizeofStreamState(void) { return LZ4_STREAMSIZE; }
-
-int LZ4_resetStreamState(void* state, char* inputBuffer)
-{
-    (void)inputBuffer;
-    LZ4_resetStream((LZ4_stream_t*)state);
-    return 0;
-}
-
-void* LZ4_create (char* inputBuffer)
-{
-    (void)inputBuffer;
-    return LZ4_createStream();
-}
-
-char* LZ4_slideInputBuffer (void* state)
-{
-    /* avoid const char * -> char * conversion warning */
-    return (char *)(uptrval)((LZ4_stream_t*)state)->internal_donotuse.dictionary;
-}
-
-#endif   /* LZ4_COMMONDEFS_ONLY */
diff --git a/thirdparty/lz4/lz4.h b/thirdparty/lz4/lz4.h
deleted file mode 100644
index ded957d..0000000
--- a/thirdparty/lz4/lz4.h
+++ /dev/null
@@ -1,774 +0,0 @@
-/*
- *  LZ4 - Fast LZ compression algorithm
- *  Header File
- *  Copyright (C) 2011-2020, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-    - LZ4 homepage : http://www.lz4.org
-    - LZ4 source repository : https://github.com/lz4/lz4
-*/
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-#ifndef LZ4_H_2983827168210
-#define LZ4_H_2983827168210
-
-/* --- Dependency --- */
-#include <stddef.h>   /* size_t */
-
-
-/**
-  Introduction
-
-  LZ4 is lossless compression algorithm, providing compression speed >500 MB/s per core,
-  scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
-  multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
-
-  The LZ4 compression library provides in-memory compression and decompression functions.
-  It gives full buffer control to user.
-  Compression can be done in:
-    - a single step (described as Simple Functions)
-    - a single step, reusing a context (described in Advanced Functions)
-    - unbounded multiple steps (described as Streaming compression)
-
-  lz4.h generates and decodes LZ4-compressed blocks (doc/lz4_Block_format.md).
-  Decompressing such a compressed block requires additional metadata.
-  Exact metadata depends on exact decompression function.
-  For the typical case of LZ4_decompress_safe(),
-  metadata includes block's compressed size, and maximum bound of decompressed size.
-  Each application is free to encode and pass such metadata in whichever way it wants.
-
-  lz4.h only handle blocks, it can not generate Frames.
-
-  Blocks are different from Frames (doc/lz4_Frame_format.md).
-  Frames bundle both blocks and metadata in a specified manner.
-  Embedding metadata is required for compressed data to be self-contained and portable.
-  Frame format is delivered through a companion API, declared in lz4frame.h.
-  The `lz4` CLI can only manage frames.
-*/
-
-/*^***************************************************************
-*  Export parameters
-*****************************************************************/
-/*
-*  LZ4_DLL_EXPORT :
-*  Enable exporting of functions when building a Windows DLL
-*  LZ4LIB_VISIBILITY :
-*  Control library symbols visibility.
-*/
-#ifndef LZ4LIB_VISIBILITY
-#  if defined(__GNUC__) && (__GNUC__ >= 4)
-#    define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default")))
-#  else
-#    define LZ4LIB_VISIBILITY
-#  endif
-#endif
-#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
-#  define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY
-#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
-#  define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
-#else
-#  define LZ4LIB_API LZ4LIB_VISIBILITY
-#endif
-
-/*------   Version   ------*/
-#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
-#define LZ4_VERSION_MINOR    9    /* for new (non-breaking) interface capabilities */
-#define LZ4_VERSION_RELEASE  3    /* for tweaks, bug-fixes, or development */
-
-#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
-
-#define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
-#define LZ4_QUOTE(str) #str
-#define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
-#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)
-
-LZ4LIB_API int LZ4_versionNumber (void);  /**< library version number; useful to check dll version */
-LZ4LIB_API const char* LZ4_versionString (void);   /**< library version string; useful to check dll version */
-
-
-/*-************************************
-*  Tuning parameter
-**************************************/
-/*!
- * LZ4_MEMORY_USAGE :
- * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
- * Increasing memory usage improves compression ratio.
- * Reduced memory usage may improve speed, thanks to better cache locality.
- * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
- */
-#ifndef LZ4_MEMORY_USAGE
-# define LZ4_MEMORY_USAGE 14
-#endif
-
-
-/*-************************************
-*  Simple Functions
-**************************************/
-/*! LZ4_compress_default() :
- *  Compresses 'srcSize' bytes from buffer 'src'
- *  into already allocated 'dst' buffer of size 'dstCapacity'.
- *  Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize).
- *  It also runs faster, so it's a recommended setting.
- *  If the function cannot compress 'src' into a more limited 'dst' budget,
- *  compression stops *immediately*, and the function result is zero.
- *  In which case, 'dst' content is undefined (invalid).
- *      srcSize : max supported value is LZ4_MAX_INPUT_SIZE.
- *      dstCapacity : size of buffer 'dst' (which must be already allocated)
- *     @return  : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity)
- *                or 0 if compression fails
- * Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer).
- */
-LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity);
-
-/*! LZ4_decompress_safe() :
- *  compressedSize : is the exact complete size of the compressed block.
- *  dstCapacity : is the size of destination buffer (which must be already allocated), presumed an upper bound of decompressed size.
- * @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
- *           If destination buffer is not large enough, decoding will stop and output an error code (negative value).
- *           If the source stream is detected malformed, the function will stop decoding and return a negative result.
- * Note 1 : This function is protected against malicious data packets :
- *          it will never writes outside 'dst' buffer, nor read outside 'source' buffer,
- *          even if the compressed block is maliciously modified to order the decoder to do these actions.
- *          In such case, the decoder stops immediately, and considers the compressed block malformed.
- * Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them.
- *          The implementation is free to send / store / derive this information in whichever way is most beneficial.
- *          If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead.
- */
-LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity);
-
-
-/*-************************************
-*  Advanced Functions
-**************************************/
-#define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
-#define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
-
-/*! LZ4_compressBound() :
-    Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
-    This function is primarily useful for memory allocation purposes (destination buffer size).
-    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
-    Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize)
-        inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
-        return : maximum output size in a "worst case" scenario
-              or 0, if input size is incorrect (too large or negative)
-*/
-LZ4LIB_API int LZ4_compressBound(int inputSize);
-
-/*! LZ4_compress_fast() :
-    Same as LZ4_compress_default(), but allows selection of "acceleration" factor.
-    The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
-    It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
-    An acceleration value of "1" is the same as regular LZ4_compress_default()
-    Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c).
-    Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c).
-*/
-LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-
-/*! LZ4_compress_fast_extState() :
- *  Same as LZ4_compress_fast(), using an externally allocated memory space for its state.
- *  Use LZ4_sizeofState() to know how much memory must be allocated,
- *  and allocate it on 8-bytes boundaries (using `malloc()` typically).
- *  Then, provide this buffer as `void* state` to compression function.
- */
-LZ4LIB_API int LZ4_sizeofState(void);
-LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-
-/*! LZ4_compress_destSize() :
- *  Reverse the logic : compresses as much data as possible from 'src' buffer
- *  into already allocated buffer 'dst', of size >= 'targetDestSize'.
- *  This function either compresses the entire 'src' content into 'dst' if it's large enough,
- *  or fill 'dst' buffer completely with as much data as possible from 'src'.
- *  note: acceleration parameter is fixed to "default".
- *
- * *srcSizePtr : will be modified to indicate how many bytes where read from 'src' to fill 'dst'.
- *               New value is necessarily <= input value.
- * @return : Nb bytes written into 'dst' (necessarily <= targetDestSize)
- *           or 0 if compression fails.
- *
- * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed un v1.9.2+):
- *        the produced compressed content could, in specific circumstances,
- *        require to be decompressed into a destination buffer larger
- *        by at least 1 byte than the content to decompress.
- *        If an application uses `LZ4_compress_destSize()`,
- *        it's highly recommended to update liblz4 to v1.9.2 or better.
- *        If this can't be done or ensured,
- *        the receiving decompression function should provide
- *        a dstCapacity which is > decompressedSize, by at least 1 byte.
- *        See https://github.com/lz4/lz4/issues/859 for details
- */
-LZ4LIB_API int LZ4_compress_destSize (const char* src, char* dst, int* srcSizePtr, int targetDstSize);
-
-
-/*! LZ4_decompress_safe_partial() :
- *  Decompress an LZ4 compressed block, of size 'srcSize' at position 'src',
- *  into destination buffer 'dst' of size 'dstCapacity'.
- *  Up to 'targetOutputSize' bytes will be decoded.
- *  The function stops decoding on reaching this objective.
- *  This can be useful to boost performance
- *  whenever only the beginning of a block is required.
- *
- * @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize)
- *           If source stream is detected malformed, function returns a negative result.
- *
- *  Note 1 : @return can be < targetOutputSize, if compressed block contains less data.
- *
- *  Note 2 : targetOutputSize must be <= dstCapacity
- *
- *  Note 3 : this function effectively stops decoding on reaching targetOutputSize,
- *           so dstCapacity is kind of redundant.
- *           This is because in older versions of this function,
- *           decoding operation would still write complete sequences.
- *           Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize,
- *           it could write more bytes, though only up to dstCapacity.
- *           Some "margin" used to be required for this operation to work properly.
- *           Thankfully, this is no longer necessary.
- *           The function nonetheless keeps the same signature, in an effort to preserve API compatibility.
- *
- *  Note 4 : If srcSize is the exact size of the block,
- *           then targetOutputSize can be any value,
- *           including larger than the block's decompressed size.
- *           The function will, at most, generate block's decompressed size.
- *
- *  Note 5 : If srcSize is _larger_ than block's compressed size,
- *           then targetOutputSize **MUST** be <= block's decompressed size.
- *           Otherwise, *silent corruption will occur*.
- */
-LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity);
-
-
-/*-*********************************************
-*  Streaming Compression Functions
-***********************************************/
-typedef union LZ4_stream_u LZ4_stream_t;  /* incomplete type (defined later) */
-
-LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
-LZ4LIB_API int           LZ4_freeStream (LZ4_stream_t* streamPtr);
-
-/*! LZ4_resetStream_fast() : v1.9.0+
- *  Use this to prepare an LZ4_stream_t for a new chain of dependent blocks
- *  (e.g., LZ4_compress_fast_continue()).
- *
- *  An LZ4_stream_t must be initialized once before usage.
- *  This is automatically done when created by LZ4_createStream().
- *  However, should the LZ4_stream_t be simply declared on stack (for example),
- *  it's necessary to initialize it first, using LZ4_initStream().
- *
- *  After init, start any new stream with LZ4_resetStream_fast().
- *  A same LZ4_stream_t can be re-used multiple times consecutively
- *  and compress multiple streams,
- *  provided that it starts each new stream with LZ4_resetStream_fast().
- *
- *  LZ4_resetStream_fast() is much faster than LZ4_initStream(),
- *  but is not compatible with memory regions containing garbage data.
- *
- *  Note: it's only useful to call LZ4_resetStream_fast()
- *        in the context of streaming compression.
- *        The *extState* functions perform their own resets.
- *        Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive.
- */
-LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr);
-
-/*! LZ4_loadDict() :
- *  Use this function to reference a static dictionary into LZ4_stream_t.
- *  The dictionary must remain available during compression.
- *  LZ4_loadDict() triggers a reset, so any previous data will be forgotten.
- *  The same dictionary will have to be loaded on decompression side for successful decoding.
- *  Dictionary are useful for better compression of small data (KB range).
- *  While LZ4 accept any input as dictionary,
- *  results are generally better when using Zstandard's Dictionary Builder.
- *  Loading a size of 0 is allowed, and is the same as reset.
- * @return : loaded dictionary size, in bytes (necessarily <= 64 KB)
- */
-LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
-
-/*! LZ4_compress_fast_continue() :
- *  Compress 'src' content using data from previously compressed blocks, for better compression ratio.
- * 'dst' buffer must be already allocated.
- *  If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
- *
- * @return : size of compressed block
- *           or 0 if there is an error (typically, cannot fit into 'dst').
- *
- *  Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block.
- *           Each block has precise boundaries.
- *           Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata.
- *           It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together.
- *
- *  Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory !
- *
- *  Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB.
- *           Make sure that buffers are separated, by at least one byte.
- *           This construction ensures that each block only depends on previous block.
- *
- *  Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.
- *
- *  Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed.
- */
-LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-/*! LZ4_saveDict() :
- *  If last 64KB data cannot be guaranteed to remain available at its current memory location,
- *  save it into a safer place (char* safeBuffer).
- *  This is schematically equivalent to a memcpy() followed by LZ4_loadDict(),
- *  but is much faster, because LZ4_saveDict() doesn't need to rebuild tables.
- * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error.
- */
-LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize);
-
-
-/*-**********************************************
-*  Streaming Decompression Functions
-*  Bufferless synchronous API
-************************************************/
-typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* tracking context */
-
-/*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() :
- *  creation / destruction of streaming decompression tracking context.
- *  A tracking context can be re-used multiple times.
- */
-LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
-LZ4LIB_API int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
-
-/*! LZ4_setStreamDecode() :
- *  An LZ4_streamDecode_t context can be allocated once and re-used multiple times.
- *  Use this function to start decompression of a new stream of blocks.
- *  A dictionary can optionally be set. Use NULL or size 0 for a reset order.
- *  Dictionary is presumed stable : it must remain accessible and unmodified during next decompression.
- * @return : 1 if OK, 0 if error
- */
-LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
-
-/*! LZ4_decoderRingBufferSize() : v1.8.2+
- *  Note : in a ring buffer scenario (optional),
- *  blocks are presumed decompressed next to each other
- *  up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize),
- *  at which stage it resumes from beginning of ring buffer.
- *  When setting such a ring buffer for streaming decompression,
- *  provides the minimum size of this ring buffer
- *  to be compatible with any source respecting maxBlockSize condition.
- * @return : minimum ring buffer size,
- *           or 0 if there is an error (invalid maxBlockSize).
- */
-LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize);
-#define LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize) (65536 + 14 + (maxBlockSize))  /* for static allocation; maxBlockSize presumed valid */
-
-/*! LZ4_decompress_*_continue() :
- *  These decoding functions allow decompression of consecutive blocks in "streaming" mode.
- *  A block is an unsplittable entity, it must be presented entirely to a decompression function.
- *  Decompression functions only accepts one block at a time.
- *  The last 64KB of previously decoded data *must* remain available and unmodified at the memory position where they were decoded.
- *  If less than 64KB of data has been decoded, all the data must be present.
- *
- *  Special : if decompression side sets a ring buffer, it must respect one of the following conditions :
- *  - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize).
- *    maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes.
- *    In which case, encoding and decoding buffers do not need to be synchronized.
- *    Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize.
- *  - Synchronized mode :
- *    Decompression buffer size is _exactly_ the same as compression buffer size,
- *    and follows exactly same update rule (block boundaries at same positions),
- *    and decoding function is provided with exact decompressed size of each block (exception for last block of the stream),
- *    _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).
- *  - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes.
- *    In which case, encoding and decoding buffers do not need to be synchronized,
- *    and encoding ring buffer can have any size, including small ones ( < 64 KB).
- *
- *  Whenever these conditions are not possible,
- *  save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression,
- *  then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block.
-*/
-LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int srcSize, int dstCapacity);
-
-
-/*! LZ4_decompress_*_usingDict() :
- *  These decoding functions work the same as
- *  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue()
- *  They are stand-alone, and don't need an LZ4_streamDecode_t structure.
- *  Dictionary is presumed stable : it must remain accessible and unmodified during decompression.
- *  Performance tip : Decompression speed can be substantially increased
- *                    when dst == dictStart + dictSize.
- */
-LZ4LIB_API int LZ4_decompress_safe_usingDict (const char* src, char* dst, int srcSize, int dstCapcity, const char* dictStart, int dictSize);
-
-#endif /* LZ4_H_2983827168210 */
-
-
-/*^*************************************
- * !!!!!!   STATIC LINKING ONLY   !!!!!!
- ***************************************/
-
-/*-****************************************************************************
- * Experimental section
- *
- * Symbols declared in this section must be considered unstable. Their
- * signatures or semantics may change, or they may be removed altogether in the
- * future. They are therefore only safe to depend on when the caller is
- * statically linked against the library.
- *
- * To protect against unsafe usage, not only are the declarations guarded,
- * the definitions are hidden by default
- * when building LZ4 as a shared/dynamic library.
- *
- * In order to access these declarations,
- * define LZ4_STATIC_LINKING_ONLY in your application
- * before including LZ4's headers.
- *
- * In order to make their implementations accessible dynamically, you must
- * define LZ4_PUBLISH_STATIC_FUNCTIONS when building the LZ4 library.
- ******************************************************************************/
-
-#ifdef LZ4_STATIC_LINKING_ONLY
-
-#ifndef LZ4_STATIC_3504398509
-#define LZ4_STATIC_3504398509
-
-#ifdef LZ4_PUBLISH_STATIC_FUNCTIONS
-#define LZ4LIB_STATIC_API LZ4LIB_API
-#else
-#define LZ4LIB_STATIC_API
-#endif
-
-
-/*! LZ4_compress_fast_extState_fastReset() :
- *  A variant of LZ4_compress_fast_extState().
- *
- *  Using this variant avoids an expensive initialization step.
- *  It is only safe to call if the state buffer is known to be correctly initialized already
- *  (see above comment on LZ4_resetStream_fast() for a definition of "correctly initialized").
- *  From a high level, the difference is that
- *  this function initializes the provided state with a call to something like LZ4_resetStream_fast()
- *  while LZ4_compress_fast_extState() starts with a call to LZ4_resetStream().
- */
-LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-/*! LZ4_attach_dictionary() :
- *  This is an experimental API that allows
- *  efficient use of a static dictionary many times.
- *
- *  Rather than re-loading the dictionary buffer into a working context before
- *  each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a
- *  working LZ4_stream_t, this function introduces a no-copy setup mechanism,
- *  in which the working stream references the dictionary stream in-place.
- *
- *  Several assumptions are made about the state of the dictionary stream.
- *  Currently, only streams which have been prepared by LZ4_loadDict() should
- *  be expected to work.
- *
- *  Alternatively, the provided dictionaryStream may be NULL,
- *  in which case any existing dictionary stream is unset.
- *
- *  If a dictionary is provided, it replaces any pre-existing stream history.
- *  The dictionary contents are the only history that can be referenced and
- *  logically immediately precede the data compressed in the first subsequent
- *  compression call.
- *
- *  The dictionary will only remain attached to the working stream through the
- *  first compression call, at the end of which it is cleared. The dictionary
- *  stream (and source buffer) must remain in-place / accessible / unchanged
- *  through the completion of the first compression call on the stream.
- */
-LZ4LIB_STATIC_API void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream);
-
-
-/*! In-place compression and decompression
- *
- * It's possible to have input and output sharing the same buffer,
- * for highly contrained memory environments.
- * In both cases, it requires input to lay at the end of the buffer,
- * and decompression to start at beginning of the buffer.
- * Buffer size must feature some margin, hence be larger than final size.
- *
- * |<------------------------buffer--------------------------------->|
- *                             |<-----------compressed data--------->|
- * |<-----------decompressed size------------------>|
- *                                                  |<----margin---->|
- *
- * This technique is more useful for decompression,
- * since decompressed size is typically larger,
- * and margin is short.
- *
- * In-place decompression will work inside any buffer
- * which size is >= LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize).
- * This presumes that decompressedSize > compressedSize.
- * Otherwise, it means compression actually expanded data,
- * and it would be more efficient to store such data with a flag indicating it's not compressed.
- * This can happen when data is not compressible (already compressed, or encrypted).
- *
- * For in-place compression, margin is larger, as it must be able to cope with both
- * history preservation, requiring input data to remain unmodified up to LZ4_DISTANCE_MAX,
- * and data expansion, which can happen when input is not compressible.
- * As a consequence, buffer size requirements are much higher,
- * and memory savings offered by in-place compression are more limited.
- *
- * There are ways to limit this cost for compression :
- * - Reduce history size, by modifying LZ4_DISTANCE_MAX.
- *   Note that it is a compile-time constant, so all compressions will apply this limit.
- *   Lower values will reduce compression ratio, except when input_size < LZ4_DISTANCE_MAX,
- *   so it's a reasonable trick when inputs are known to be small.
- * - Require the compressor to deliver a "maximum compressed size".
- *   This is the `dstCapacity` parameter in `LZ4_compress*()`.
- *   When this size is < LZ4_COMPRESSBOUND(inputSize), then compression can fail,
- *   in which case, the return code will be 0 (zero).
- *   The caller must be ready for these cases to happen,
- *   and typically design a backup scheme to send data uncompressed.
- * The combination of both techniques can significantly reduce
- * the amount of margin required for in-place compression.
- *
- * In-place compression can work in any buffer
- * which size is >= (maxCompressedSize)
- * with maxCompressedSize == LZ4_COMPRESSBOUND(srcSize) for guaranteed compression success.
- * LZ4_COMPRESS_INPLACE_BUFFER_SIZE() depends on both maxCompressedSize and LZ4_DISTANCE_MAX,
- * so it's possible to reduce memory requirements by playing with them.
- */
-
-#define LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize)          (((compressedSize) >> 8) + 32)
-#define LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize)   ((decompressedSize) + LZ4_DECOMPRESS_INPLACE_MARGIN(decompressedSize))  /**< note: presumes that compressedSize < decompressedSize. note2: margin is overestimated a bit, since it could use compressedSize instead */
-
-#ifndef LZ4_DISTANCE_MAX   /* history window size; can be user-defined at compile time */
-#  define LZ4_DISTANCE_MAX 65535   /* set to maximum value by default */
-#endif
-
-#define LZ4_COMPRESS_INPLACE_MARGIN                           (LZ4_DISTANCE_MAX + 32)   /* LZ4_DISTANCE_MAX can be safely replaced by srcSize when it's smaller */
-#define LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCompressedSize)   ((maxCompressedSize) + LZ4_COMPRESS_INPLACE_MARGIN)  /**< maxCompressedSize is generally LZ4_COMPRESSBOUND(inputSize), but can be set to any lower value, with the risk that compression can fail (return code 0(zero)) */
-
-#endif   /* LZ4_STATIC_3504398509 */
-#endif   /* LZ4_STATIC_LINKING_ONLY */
-
-
-
-#ifndef LZ4_H_98237428734687
-#define LZ4_H_98237428734687
-
-/*-************************************************************
- *  Private Definitions
- **************************************************************
- * Do not use these definitions directly.
- * They are only exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
- * Accessing members will expose user code to API and/or ABI break in future versions of the library.
- **************************************************************/
-#define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
-#define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
-#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
-
-#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  int8_t  LZ4_i8;
-  typedef uint8_t  LZ4_byte;
-  typedef uint16_t LZ4_u16;
-  typedef uint32_t LZ4_u32;
-#else
-  typedef   signed char  LZ4_i8;
-  typedef unsigned char  LZ4_byte;
-  typedef unsigned short LZ4_u16;
-  typedef unsigned int   LZ4_u32;
-#endif
-
-typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
-struct LZ4_stream_t_internal {
-    LZ4_u32 hashTable[LZ4_HASH_SIZE_U32];
-    LZ4_u32 currentOffset;
-    LZ4_u32 tableType;
-    const LZ4_byte* dictionary;
-    const LZ4_stream_t_internal* dictCtx;
-    LZ4_u32 dictSize;
-};
-
-typedef struct {
-    const LZ4_byte* externalDict;
-    size_t extDictSize;
-    const LZ4_byte* prefixEnd;
-    size_t prefixSize;
-} LZ4_streamDecode_t_internal;
-
-
-/*! LZ4_stream_t :
- *  Do not use below internal definitions directly !
- *  Declare or allocate an LZ4_stream_t instead.
- *  LZ4_stream_t can also be created using LZ4_createStream(), which is recommended.
- *  The structure definition can be convenient for static allocation
- *  (on stack, or as part of larger structure).
- *  Init this structure with LZ4_initStream() before first use.
- *  note : only use this definition in association with static linking !
- *  this definition is not API/ABI safe, and may change in future versions.
- */
-#define LZ4_STREAMSIZE       16416  /* static size, for inter-version compatibility */
-#define LZ4_STREAMSIZE_VOIDP (LZ4_STREAMSIZE / sizeof(void*))
-union LZ4_stream_u {
-    void* table[LZ4_STREAMSIZE_VOIDP];
-    LZ4_stream_t_internal internal_donotuse;
-}; /* previously typedef'd to LZ4_stream_t */
-
-
-/*! LZ4_initStream() : v1.9.0+
- *  An LZ4_stream_t structure must be initialized at least once.
- *  This is automatically done when invoking LZ4_createStream(),
- *  but it's not when the structure is simply declared on stack (for example).
- *
- *  Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t.
- *  It can also initialize any arbitrary buffer of sufficient size,
- *  and will @return a pointer of proper type upon initialization.
- *
- *  Note : initialization fails if size and alignment conditions are not respected.
- *         In which case, the function will @return NULL.
- *  Note2: An LZ4_stream_t structure guarantees correct alignment and size.
- *  Note3: Before v1.9.0, use LZ4_resetStream() instead
- */
-LZ4LIB_API LZ4_stream_t* LZ4_initStream (void* buffer, size_t size);
-
-
-/*! LZ4_streamDecode_t :
- *  information structure to track an LZ4 stream during decompression.
- *  init this structure  using LZ4_setStreamDecode() before first use.
- *  note : only use in association with static linking !
- *         this definition is not API/ABI safe,
- *         and may change in a future version !
- */
-#define LZ4_STREAMDECODESIZE_U64 (4 + ((sizeof(void*)==16) ? 2 : 0) /*AS-400*/ )
-#define LZ4_STREAMDECODESIZE     (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
-union LZ4_streamDecode_u {
-    unsigned long long table[LZ4_STREAMDECODESIZE_U64];
-    LZ4_streamDecode_t_internal internal_donotuse;
-} ;   /* previously typedef'd to LZ4_streamDecode_t */
-
-
-
-/*-************************************
-*  Obsolete Functions
-**************************************/
-
-/*! Deprecation warnings
- *
- *  Deprecated functions make the compiler generate a warning when invoked.
- *  This is meant to invite users to update their source code.
- *  Should deprecation warnings be a problem, it is generally possible to disable them,
- *  typically with -Wno-deprecated-declarations for gcc
- *  or _CRT_SECURE_NO_WARNINGS in Visual.
- *
- *  Another method is to define LZ4_DISABLE_DEPRECATE_WARNINGS
- *  before including the header file.
- */
-#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
-#  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
-#else
-#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
-#    define LZ4_DEPRECATED(message) [[deprecated(message)]]
-#  elif defined(_MSC_VER)
-#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
-#  elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 45))
-#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
-#  elif defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 31)
-#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
-#  else
-#    pragma message("WARNING: LZ4_DEPRECATED needs custom implementation for this compiler")
-#    define LZ4_DEPRECATED(message)   /* disabled */
-#  endif
-#endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
-
-/*! Obsolete compression functions (since v1.7.3) */
-LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress               (const char* src, char* dest, int srcSize);
-LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress_limitedOutput (const char* src, char* dest, int srcSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
-
-/*! Obsolete decompression functions (since v1.8.0) */
-LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize);
-LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
-
-/* Obsolete streaming functions (since v1.7.0)
- * degraded functionality; do not use!
- *
- * In order to perform streaming compression, these functions depended on data
- * that is no longer tracked in the state. They have been preserved as well as
- * possible: using them will still produce a correct output. However, they don't
- * actually retain any history between compression calls. The compression ratio
- * achieved will therefore be no better than compressing each chunk
- * independently.
- */
-LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer);
-LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int   LZ4_sizeofStreamState(void);
-LZ4_DEPRECATED("Use LZ4_resetStream() instead")  LZ4LIB_API int   LZ4_resetStreamState(void* state, char* inputBuffer);
-LZ4_DEPRECATED("Use LZ4_saveDict() instead")     LZ4LIB_API char* LZ4_slideInputBuffer (void* state);
-
-/*! Obsolete streaming decoding functions (since v1.7.0) */
-LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
-LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
-
-/*! Obsolete LZ4_decompress_fast variants (since v1.9.0) :
- *  These functions used to be faster than LZ4_decompress_safe(),
- *  but this is no longer the case. They are now slower.
- *  This is because LZ4_decompress_fast() doesn't know the input size,
- *  and therefore must progress more cautiously into the input buffer to not read beyond the end of block.
- *  On top of that `LZ4_decompress_fast()` is not protected vs malformed or malicious inputs, making it a security liability.
- *  As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated.
- *
- *  The last remaining LZ4_decompress_fast() specificity is that
- *  it can decompress a block without knowing its compressed size.
- *  Such functionality can be achieved in a more secure manner
- *  by employing LZ4_decompress_safe_partial().
- *
- *  Parameters:
- *  originalSize : is the uncompressed size to regenerate.
- *                 `dst` must be already allocated, its size must be >= 'originalSize' bytes.
- * @return : number of bytes read from source buffer (== compressed size).
- *           The function expects to finish at block's end exactly.
- *           If the source stream is detected malformed, the function stops decoding and returns a negative result.
- *  note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer.
- *         However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds.
- *         Also, since match offsets are not validated, match reads from 'src' may underflow too.
- *         These issues never happen if input (compressed) data is correct.
- *         But they may happen if input data is invalid (error or intentional tampering).
- *         As a consequence, use these functions in trusted environments with trusted data **only**.
- */
-LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe() instead")
-LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize);
-LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_continue() instead")
-LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize);
-LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_usingDict() instead")
-LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize);
-
-/*! LZ4_resetStream() :
- *  An LZ4_stream_t structure must be initialized at least once.
- *  This is done with LZ4_initStream(), or LZ4_resetStream().
- *  Consider switching to LZ4_initStream(),
- *  invoking LZ4_resetStream() will trigger deprecation warnings in the future.
- */
-LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
-
-
-#endif /* LZ4_H_98237428734687 */
-
-
-#if defined (__cplusplus)
-}
-#endif
diff --git a/thirdparty/lz4/lz4frame.c b/thirdparty/lz4/lz4frame.c
deleted file mode 100644
index ec02c92..0000000
--- a/thirdparty/lz4/lz4frame.c
+++ /dev/null
@@ -1,1899 +0,0 @@
-/*
- * LZ4 auto-framing library
- * Copyright (C) 2011-2016, Yann Collet.
- *
- * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- * - Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * - Redistributions in binary form must reproduce the above
- *   copyright notice, this list of conditions and the following disclaimer
- *   in the documentation and/or other materials provided with the
- *   distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * You can contact the author at :
- * - LZ4 homepage : http://www.lz4.org
- * - LZ4 source repository : https://github.com/lz4/lz4
- */
-
-/* LZ4F is a stand-alone API to create LZ4-compressed Frames
- * in full conformance with specification v1.6.1 .
- * This library rely upon memory management capabilities (malloc, free)
- * provided either by <stdlib.h>,
- * or redirected towards another library of user's choice
- * (see Memory Routines below).
- */
-
-
-/*-************************************
-*  Compiler Options
-**************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#endif
-
-
-/*-************************************
-*  Tuning parameters
-**************************************/
-/*
- * LZ4F_HEAPMODE :
- * Select how default compression functions will allocate memory for their hash table,
- * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).
- */
-#ifndef LZ4F_HEAPMODE
-#  define LZ4F_HEAPMODE 0
-#endif
-
-
-/*-************************************
-*  Memory routines
-**************************************/
-/*
- * User may redirect invocations of
- * malloc(), calloc() and free()
- * towards another library or solution of their choice
- * by modifying below section.
- */
-#ifndef LZ4_SRC_INCLUDED   /* avoid redefinition when sources are coalesced */
-#  include <stdlib.h>   /* malloc, calloc, free */
-#  define ALLOC(s)          malloc(s)
-#  define ALLOC_AND_ZERO(s) calloc(1,(s))
-#  define FREEMEM(p)        free(p)
-#endif
-
-#include <string.h>   /* memset, memcpy, memmove */
-#ifndef LZ4_SRC_INCLUDED  /* avoid redefinition when sources are coalesced */
-#  define MEM_INIT(p,v,s)   memset((p),(v),(s))
-#endif
-
-
-/*-************************************
-*  Library declarations
-**************************************/
-#define LZ4F_STATIC_LINKING_ONLY
-#include "lz4frame.h"
-#define LZ4_STATIC_LINKING_ONLY
-#include "lz4.h"
-#define LZ4_HC_STATIC_LINKING_ONLY
-#include "lz4hc.h"
-#define XXH_STATIC_LINKING_ONLY
-#include "xxhash.h"
-
-
-/*-************************************
-*  Debug
-**************************************/
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=1)
-#  include <assert.h>
-#else
-#  ifndef assert
-#    define assert(condition) ((void)0)
-#  endif
-#endif
-
-#define LZ4F_STATIC_ASSERT(c)    { enum { LZ4F_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2) && !defined(DEBUGLOG)
-#  include <stdio.h>
-static int g_debuglog_enable = 1;
-#  define DEBUGLOG(l, ...) {                                  \
-                if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \
-                    fprintf(stderr, __FILE__ ": ");           \
-                    fprintf(stderr, __VA_ARGS__);             \
-                    fprintf(stderr, " \n");                   \
-            }   }
-#else
-#  define DEBUGLOG(l, ...)      {}    /* disabled */
-#endif
-
-
-/*-************************************
-*  Basic Types
-**************************************/
-#if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-# include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-#else
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-#endif
-
-
-/* unoptimized version; solves endianess & alignment issues */
-static U32 LZ4F_readLE32 (const void* src)
-{
-    const BYTE* const srcPtr = (const BYTE*)src;
-    U32 value32 = srcPtr[0];
-    value32 += ((U32)srcPtr[1])<< 8;
-    value32 += ((U32)srcPtr[2])<<16;
-    value32 += ((U32)srcPtr[3])<<24;
-    return value32;
-}
-
-static void LZ4F_writeLE32 (void* dst, U32 value32)
-{
-    BYTE* const dstPtr = (BYTE*)dst;
-    dstPtr[0] = (BYTE)value32;
-    dstPtr[1] = (BYTE)(value32 >> 8);
-    dstPtr[2] = (BYTE)(value32 >> 16);
-    dstPtr[3] = (BYTE)(value32 >> 24);
-}
-
-static U64 LZ4F_readLE64 (const void* src)
-{
-    const BYTE* const srcPtr = (const BYTE*)src;
-    U64 value64 = srcPtr[0];
-    value64 += ((U64)srcPtr[1]<<8);
-    value64 += ((U64)srcPtr[2]<<16);
-    value64 += ((U64)srcPtr[3]<<24);
-    value64 += ((U64)srcPtr[4]<<32);
-    value64 += ((U64)srcPtr[5]<<40);
-    value64 += ((U64)srcPtr[6]<<48);
-    value64 += ((U64)srcPtr[7]<<56);
-    return value64;
-}
-
-static void LZ4F_writeLE64 (void* dst, U64 value64)
-{
-    BYTE* const dstPtr = (BYTE*)dst;
-    dstPtr[0] = (BYTE)value64;
-    dstPtr[1] = (BYTE)(value64 >> 8);
-    dstPtr[2] = (BYTE)(value64 >> 16);
-    dstPtr[3] = (BYTE)(value64 >> 24);
-    dstPtr[4] = (BYTE)(value64 >> 32);
-    dstPtr[5] = (BYTE)(value64 >> 40);
-    dstPtr[6] = (BYTE)(value64 >> 48);
-    dstPtr[7] = (BYTE)(value64 >> 56);
-}
-
-
-/*-************************************
-*  Constants
-**************************************/
-#ifndef LZ4_SRC_INCLUDED   /* avoid double definition */
-#  define KB *(1<<10)
-#  define MB *(1<<20)
-#  define GB *(1<<30)
-#endif
-
-#define _1BIT  0x01
-#define _2BITS 0x03
-#define _3BITS 0x07
-#define _4BITS 0x0F
-#define _8BITS 0xFF
-
-#define LZ4F_MAGIC_SKIPPABLE_START 0x184D2A50U
-#define LZ4F_MAGICNUMBER 0x184D2204U
-#define LZ4F_BLOCKUNCOMPRESSED_FLAG 0x80000000U
-#define LZ4F_BLOCKSIZEID_DEFAULT LZ4F_max64KB
-
-static const size_t minFHSize = LZ4F_HEADER_SIZE_MIN;   /*  7 */
-static const size_t maxFHSize = LZ4F_HEADER_SIZE_MAX;   /* 19 */
-static const size_t BHSize = LZ4F_BLOCK_HEADER_SIZE;  /* block header : size, and compress flag */
-static const size_t BFSize = LZ4F_BLOCK_CHECKSUM_SIZE;  /* block footer : checksum (optional) */
-
-
-/*-************************************
-*  Structures and local types
-**************************************/
-typedef struct LZ4F_cctx_s
-{
-    LZ4F_preferences_t prefs;
-    U32    version;
-    U32    cStage;
-    const LZ4F_CDict* cdict;
-    size_t maxBlockSize;
-    size_t maxBufferSize;
-    BYTE*  tmpBuff;
-    BYTE*  tmpIn;
-    size_t tmpInSize;
-    U64    totalInSize;
-    XXH32_state_t xxh;
-    void*  lz4CtxPtr;
-    U16    lz4CtxAlloc; /* sized for: 0 = none, 1 = lz4 ctx, 2 = lz4hc ctx */
-    U16    lz4CtxState; /* in use as: 0 = none, 1 = lz4 ctx, 2 = lz4hc ctx */
-} LZ4F_cctx_t;
-
-
-/*-************************************
-*  Error management
-**************************************/
-#define LZ4F_GENERATE_STRING(STRING) #STRING,
-static const char* LZ4F_errorStrings[] = { LZ4F_LIST_ERRORS(LZ4F_GENERATE_STRING) };
-
-
-unsigned LZ4F_isError(LZ4F_errorCode_t code)
-{
-    return (code > (LZ4F_errorCode_t)(-LZ4F_ERROR_maxCode));
-}
-
-const char* LZ4F_getErrorName(LZ4F_errorCode_t code)
-{
-    static const char* codeError = "Unspecified error code";
-    if (LZ4F_isError(code)) return LZ4F_errorStrings[-(int)(code)];
-    return codeError;
-}
-
-LZ4F_errorCodes LZ4F_getErrorCode(size_t functionResult)
-{
-    if (!LZ4F_isError(functionResult)) return LZ4F_OK_NoError;
-    return (LZ4F_errorCodes)(-(ptrdiff_t)functionResult);
-}
-
-static LZ4F_errorCode_t err0r(LZ4F_errorCodes code)
-{
-    /* A compilation error here means sizeof(ptrdiff_t) is not large enough */
-    LZ4F_STATIC_ASSERT(sizeof(ptrdiff_t) >= sizeof(size_t));
-    return (LZ4F_errorCode_t)-(ptrdiff_t)code;
-}
-
-unsigned LZ4F_getVersion(void) { return LZ4F_VERSION; }
-
-int LZ4F_compressionLevel_max(void) { return LZ4HC_CLEVEL_MAX; }
-
-size_t LZ4F_getBlockSize(unsigned blockSizeID)
-{
-    static const size_t blockSizes[4] = { 64 KB, 256 KB, 1 MB, 4 MB };
-
-    if (blockSizeID == 0) blockSizeID = LZ4F_BLOCKSIZEID_DEFAULT;
-    if (blockSizeID < LZ4F_max64KB || blockSizeID > LZ4F_max4MB)
-        return err0r(LZ4F_ERROR_maxBlockSize_invalid);
-    blockSizeID -= LZ4F_max64KB;
-    return blockSizes[blockSizeID];
-}
-
-/*-************************************
-*  Private functions
-**************************************/
-#define MIN(a,b)   ( (a) < (b) ? (a) : (b) )
-
-static BYTE LZ4F_headerChecksum (const void* header, size_t length)
-{
-    U32 const xxh = XXH32(header, length, 0);
-    return (BYTE)(xxh >> 8);
-}
-
-
-/*-************************************
-*  Simple-pass compression functions
-**************************************/
-static LZ4F_blockSizeID_t LZ4F_optimalBSID(const LZ4F_blockSizeID_t requestedBSID,
-                                           const size_t srcSize)
-{
-    LZ4F_blockSizeID_t proposedBSID = LZ4F_max64KB;
-    size_t maxBlockSize = 64 KB;
-    while (requestedBSID > proposedBSID) {
-        if (srcSize <= maxBlockSize)
-            return proposedBSID;
-        proposedBSID = (LZ4F_blockSizeID_t)((int)proposedBSID + 1);
-        maxBlockSize <<= 2;
-    }
-    return requestedBSID;
-}
-
-/*! LZ4F_compressBound_internal() :
- *  Provides dstCapacity given a srcSize to guarantee operation success in worst case situations.
- *  prefsPtr is optional : if NULL is provided, preferences will be set to cover worst case scenario.
- * @return is always the same for a srcSize and prefsPtr, so it can be relied upon to size reusable buffers.
- *  When srcSize==0, LZ4F_compressBound() provides an upper bound for LZ4F_flush() and LZ4F_compressEnd() operations.
- */
-static size_t LZ4F_compressBound_internal(size_t srcSize,
-                                    const LZ4F_preferences_t* preferencesPtr,
-                                          size_t alreadyBuffered)
-{
-    LZ4F_preferences_t prefsNull = LZ4F_INIT_PREFERENCES;
-    prefsNull.frameInfo.contentChecksumFlag = LZ4F_contentChecksumEnabled;   /* worst case */
-    prefsNull.frameInfo.blockChecksumFlag = LZ4F_blockChecksumEnabled;   /* worst case */
-    {   const LZ4F_preferences_t* const prefsPtr = (preferencesPtr==NULL) ? &prefsNull : preferencesPtr;
-        U32 const flush = prefsPtr->autoFlush | (srcSize==0);
-        LZ4F_blockSizeID_t const blockID = prefsPtr->frameInfo.blockSizeID;
-        size_t const blockSize = LZ4F_getBlockSize(blockID);
-        size_t const maxBuffered = blockSize - 1;
-        size_t const bufferedSize = MIN(alreadyBuffered, maxBuffered);
-        size_t const maxSrcSize = srcSize + bufferedSize;
-        unsigned const nbFullBlocks = (unsigned)(maxSrcSize / blockSize);
-        size_t const partialBlockSize = maxSrcSize & (blockSize-1);
-        size_t const lastBlockSize = flush ? partialBlockSize : 0;
-        unsigned const nbBlocks = nbFullBlocks + (lastBlockSize>0);
-
-        size_t const blockCRCSize = BFSize * prefsPtr->frameInfo.blockChecksumFlag;
-        size_t const frameEnd = BHSize + (prefsPtr->frameInfo.contentChecksumFlag*BFSize);
-
-        return ((BHSize + blockCRCSize) * nbBlocks) +
-               (blockSize * nbFullBlocks) + lastBlockSize + frameEnd;
-    }
-}
-
-size_t LZ4F_compressFrameBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr)
-{
-    LZ4F_preferences_t prefs;
-    size_t const headerSize = maxFHSize;      /* max header size, including optional fields */
-
-    if (preferencesPtr!=NULL) prefs = *preferencesPtr;
-    else MEM_INIT(&prefs, 0, sizeof(prefs));
-    prefs.autoFlush = 1;
-
-    return headerSize + LZ4F_compressBound_internal(srcSize, &prefs, 0);;
-}
-
-
-/*! LZ4F_compressFrame_usingCDict() :
- *  Compress srcBuffer using a dictionary, in a single step.
- *  cdict can be NULL, in which case, no dictionary is used.
- *  dstBuffer MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr).
- *  The LZ4F_preferences_t structure is optional : you may provide NULL as argument,
- *  however, it's the only way to provide a dictID, so it's not recommended.
- * @return : number of bytes written into dstBuffer,
- *           or an error code if it fails (can be tested using LZ4F_isError())
- */
-size_t LZ4F_compressFrame_usingCDict(LZ4F_cctx* cctx,
-                                     void* dstBuffer, size_t dstCapacity,
-                               const void* srcBuffer, size_t srcSize,
-                               const LZ4F_CDict* cdict,
-                               const LZ4F_preferences_t* preferencesPtr)
-{
-    LZ4F_preferences_t prefs;
-    LZ4F_compressOptions_t options;
-    BYTE* const dstStart = (BYTE*) dstBuffer;
-    BYTE* dstPtr = dstStart;
-    BYTE* const dstEnd = dstStart + dstCapacity;
-
-    if (preferencesPtr!=NULL)
-        prefs = *preferencesPtr;
-    else
-        MEM_INIT(&prefs, 0, sizeof(prefs));
-    if (prefs.frameInfo.contentSize != 0)
-        prefs.frameInfo.contentSize = (U64)srcSize;   /* auto-correct content size if selected (!=0) */
-
-    prefs.frameInfo.blockSizeID = LZ4F_optimalBSID(prefs.frameInfo.blockSizeID, srcSize);
-    prefs.autoFlush = 1;
-    if (srcSize <= LZ4F_getBlockSize(prefs.frameInfo.blockSizeID))
-        prefs.frameInfo.blockMode = LZ4F_blockIndependent;   /* only one block => no need for inter-block link */
-
-    MEM_INIT(&options, 0, sizeof(options));
-    options.stableSrc = 1;
-
-    if (dstCapacity < LZ4F_compressFrameBound(srcSize, &prefs))  /* condition to guarantee success */
-        return err0r(LZ4F_ERROR_dstMaxSize_tooSmall);
-
-    { size_t const headerSize = LZ4F_compressBegin_usingCDict(cctx, dstBuffer, dstCapacity, cdict, &prefs);  /* write header */
-      if (LZ4F_isError(headerSize)) return headerSize;
-      dstPtr += headerSize;   /* header size */ }
-
-    assert(dstEnd >= dstPtr);
-    { size_t const cSize = LZ4F_compressUpdate(cctx, dstPtr, (size_t)(dstEnd-dstPtr), srcBuffer, srcSize, &options);
-      if (LZ4F_isError(cSize)) return cSize;
-      dstPtr += cSize; }
-
-    assert(dstEnd >= dstPtr);
-    { size_t const tailSize = LZ4F_compressEnd(cctx, dstPtr, (size_t)(dstEnd-dstPtr), &options);   /* flush last block, and generate suffix */
-      if (LZ4F_isError(tailSize)) return tailSize;
-      dstPtr += tailSize; }
-
-    assert(dstEnd >= dstStart);
-    return (size_t)(dstPtr - dstStart);
-}
-
-
-/*! LZ4F_compressFrame() :
- *  Compress an entire srcBuffer into a valid LZ4 frame, in a single step.
- *  dstBuffer MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr).
- *  The LZ4F_preferences_t structure is optional : you can provide NULL as argument. All preferences will be set to default.
- * @return : number of bytes written into dstBuffer.
- *           or an error code if it fails (can be tested using LZ4F_isError())
- */
-size_t LZ4F_compressFrame(void* dstBuffer, size_t dstCapacity,
-                    const void* srcBuffer, size_t srcSize,
-                    const LZ4F_preferences_t* preferencesPtr)
-{
-    size_t result;
-#if (LZ4F_HEAPMODE)
-    LZ4F_cctx_t *cctxPtr;
-    result = LZ4F_createCompressionContext(&cctxPtr, LZ4F_VERSION);
-    if (LZ4F_isError(result)) return result;
-#else
-    LZ4F_cctx_t cctx;
-    LZ4_stream_t lz4ctx;
-    LZ4F_cctx_t *cctxPtr = &cctx;
-
-    DEBUGLOG(4, "LZ4F_compressFrame");
-    MEM_INIT(&cctx, 0, sizeof(cctx));
-    cctx.version = LZ4F_VERSION;
-    cctx.maxBufferSize = 5 MB;   /* mess with real buffer size to prevent dynamic allocation; works only because autoflush==1 & stableSrc==1 */
-    if (preferencesPtr == NULL ||
-        preferencesPtr->compressionLevel < LZ4HC_CLEVEL_MIN)
-    {
-        LZ4_initStream(&lz4ctx, sizeof(lz4ctx));
-        cctxPtr->lz4CtxPtr = &lz4ctx;
-        cctxPtr->lz4CtxAlloc = 1;
-        cctxPtr->lz4CtxState = 1;
-    }
-#endif
-
-    result = LZ4F_compressFrame_usingCDict(cctxPtr, dstBuffer, dstCapacity,
-                                           srcBuffer, srcSize,
-                                           NULL, preferencesPtr);
-
-#if (LZ4F_HEAPMODE)
-    LZ4F_freeCompressionContext(cctxPtr);
-#else
-    if (preferencesPtr != NULL &&
-        preferencesPtr->compressionLevel >= LZ4HC_CLEVEL_MIN)
-    {
-        FREEMEM(cctxPtr->lz4CtxPtr);
-    }
-#endif
-    return result;
-}
-
-
-/*-***************************************************
-*   Dictionary compression
-*****************************************************/
-
-struct LZ4F_CDict_s {
-    void* dictContent;
-    LZ4_stream_t* fastCtx;
-    LZ4_streamHC_t* HCCtx;
-}; /* typedef'd to LZ4F_CDict within lz4frame_static.h */
-
-/*! LZ4F_createCDict() :
- *  When compressing multiple messages / blocks with the same dictionary, it's recommended to load it just once.
- *  LZ4F_createCDict() will create a digested dictionary, ready to start future compression operations without startup delay.
- *  LZ4F_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only.
- * `dictBuffer` can be released after LZ4F_CDict creation, since its content is copied within CDict
- * @return : digested dictionary for compression, or NULL if failed */
-LZ4F_CDict* LZ4F_createCDict(const void* dictBuffer, size_t dictSize)
-{
-    const char* dictStart = (const char*)dictBuffer;
-    LZ4F_CDict* cdict = (LZ4F_CDict*) ALLOC(sizeof(*cdict));
-    DEBUGLOG(4, "LZ4F_createCDict");
-    if (!cdict) return NULL;
-    if (dictSize > 64 KB) {
-        dictStart += dictSize - 64 KB;
-        dictSize = 64 KB;
-    }
-    cdict->dictContent = ALLOC(dictSize);
-    cdict->fastCtx = LZ4_createStream();
-    cdict->HCCtx = LZ4_createStreamHC();
-    if (!cdict->dictContent || !cdict->fastCtx || !cdict->HCCtx) {
-        LZ4F_freeCDict(cdict);
-        return NULL;
-    }
-    memcpy(cdict->dictContent, dictStart, dictSize);
-    LZ4_loadDict (cdict->fastCtx, (const char*)cdict->dictContent, (int)dictSize);
-    LZ4_setCompressionLevel(cdict->HCCtx, LZ4HC_CLEVEL_DEFAULT);
-    LZ4_loadDictHC(cdict->HCCtx, (const char*)cdict->dictContent, (int)dictSize);
-    return cdict;
-}
-
-void LZ4F_freeCDict(LZ4F_CDict* cdict)
-{
-    if (cdict==NULL) return;  /* support free on NULL */
-    FREEMEM(cdict->dictContent);
-    LZ4_freeStream(cdict->fastCtx);
-    LZ4_freeStreamHC(cdict->HCCtx);
-    FREEMEM(cdict);
-}
-
-
-/*-*********************************
-*  Advanced compression functions
-***********************************/
-
-/*! LZ4F_createCompressionContext() :
- *  The first thing to do is to create a compressionContext object, which will be used in all compression operations.
- *  This is achieved using LZ4F_createCompressionContext(), which takes as argument a version and an LZ4F_preferences_t structure.
- *  The version provided MUST be LZ4F_VERSION. It is intended to track potential incompatible differences between different binaries.
- *  The function will provide a pointer to an allocated LZ4F_compressionContext_t object.
- *  If the result LZ4F_errorCode_t is not OK_NoError, there was an error during context creation.
- *  Object can release its memory using LZ4F_freeCompressionContext();
- */
-LZ4F_errorCode_t LZ4F_createCompressionContext(LZ4F_cctx** LZ4F_compressionContextPtr, unsigned version)
-{
-    LZ4F_cctx_t* const cctxPtr = (LZ4F_cctx_t*)ALLOC_AND_ZERO(sizeof(LZ4F_cctx_t));
-    if (cctxPtr==NULL) return err0r(LZ4F_ERROR_allocation_failed);
-
-    cctxPtr->version = version;
-    cctxPtr->cStage = 0;   /* Next stage : init stream */
-
-    *LZ4F_compressionContextPtr = cctxPtr;
-
-    return LZ4F_OK_NoError;
-}
-
-
-LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_cctx* cctxPtr)
-{
-    if (cctxPtr != NULL) {  /* support free on NULL */
-       FREEMEM(cctxPtr->lz4CtxPtr);  /* note: LZ4_streamHC_t and LZ4_stream_t are simple POD types */
-       FREEMEM(cctxPtr->tmpBuff);
-       FREEMEM(cctxPtr);
-    }
-
-    return LZ4F_OK_NoError;
-}
-
-
-/**
- * This function prepares the internal LZ4(HC) stream for a new compression,
- * resetting the context and attaching the dictionary, if there is one.
- *
- * It needs to be called at the beginning of each independent compression
- * stream (i.e., at the beginning of a frame in blockLinked mode, or at the
- * beginning of each block in blockIndependent mode).
- */
-static void LZ4F_initStream(void* ctx,
-                            const LZ4F_CDict* cdict,
-                            int level,
-                            LZ4F_blockMode_t blockMode) {
-    if (level < LZ4HC_CLEVEL_MIN) {
-        if (cdict != NULL || blockMode == LZ4F_blockLinked) {
-            /* In these cases, we will call LZ4_compress_fast_continue(),
-             * which needs an already reset context. Otherwise, we'll call a
-             * one-shot API. The non-continued APIs internally perform their own
-             * resets at the beginning of their calls, where they know what
-             * tableType they need the context to be in. So in that case this
-             * would be misguided / wasted work. */
-            LZ4_resetStream_fast((LZ4_stream_t*)ctx);
-        }
-        LZ4_attach_dictionary((LZ4_stream_t *)ctx, cdict ? cdict->fastCtx : NULL);
-    } else {
-        LZ4_resetStreamHC_fast((LZ4_streamHC_t*)ctx, level);
-        LZ4_attach_HC_dictionary((LZ4_streamHC_t *)ctx, cdict ? cdict->HCCtx : NULL);
-    }
-}
-
-
-/*! LZ4F_compressBegin_usingCDict() :
- *  init streaming compression and writes frame header into dstBuffer.
- *  dstBuffer must be >= LZ4F_HEADER_SIZE_MAX bytes.
- * @return : number of bytes written into dstBuffer for the header
- *           or an error code (can be tested using LZ4F_isError())
- */
-size_t LZ4F_compressBegin_usingCDict(LZ4F_cctx* cctxPtr,
-                          void* dstBuffer, size_t dstCapacity,
-                          const LZ4F_CDict* cdict,
-                          const LZ4F_preferences_t* preferencesPtr)
-{
-    LZ4F_preferences_t prefNull;
-    BYTE* const dstStart = (BYTE*)dstBuffer;
-    BYTE* dstPtr = dstStart;
-    BYTE* headerStart;
-
-    if (dstCapacity < maxFHSize) return err0r(LZ4F_ERROR_dstMaxSize_tooSmall);
-    MEM_INIT(&prefNull, 0, sizeof(prefNull));
-    if (preferencesPtr == NULL) preferencesPtr = &prefNull;
-    cctxPtr->prefs = *preferencesPtr;
-
-    /* Ctx Management */
-    {   U16 const ctxTypeID = (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN) ? 1 : 2;
-        if (cctxPtr->lz4CtxAlloc < ctxTypeID) {
-            FREEMEM(cctxPtr->lz4CtxPtr);
-            if (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN) {
-                cctxPtr->lz4CtxPtr = LZ4_createStream();
-            } else {
-                cctxPtr->lz4CtxPtr = LZ4_createStreamHC();
-            }
-            if (cctxPtr->lz4CtxPtr == NULL)
-                return err0r(LZ4F_ERROR_allocation_failed);
-            cctxPtr->lz4CtxAlloc = ctxTypeID;
-            cctxPtr->lz4CtxState = ctxTypeID;
-        } else if (cctxPtr->lz4CtxState != ctxTypeID) {
-            /* otherwise, a sufficient buffer is allocated, but we need to
-             * reset it to the correct context type */
-            if (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN) {
-                LZ4_initStream((LZ4_stream_t *) cctxPtr->lz4CtxPtr, sizeof (LZ4_stream_t));
-            } else {
-                LZ4_initStreamHC((LZ4_streamHC_t *) cctxPtr->lz4CtxPtr, sizeof(LZ4_streamHC_t));
-                LZ4_setCompressionLevel((LZ4_streamHC_t *) cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel);
-            }
-            cctxPtr->lz4CtxState = ctxTypeID;
-        }
-    }
-
-    /* Buffer Management */
-    if (cctxPtr->prefs.frameInfo.blockSizeID == 0)
-        cctxPtr->prefs.frameInfo.blockSizeID = LZ4F_BLOCKSIZEID_DEFAULT;
-    cctxPtr->maxBlockSize = LZ4F_getBlockSize(cctxPtr->prefs.frameInfo.blockSizeID);
-
-    {   size_t const requiredBuffSize = preferencesPtr->autoFlush ?
-                ((cctxPtr->prefs.frameInfo.blockMode == LZ4F_blockLinked) ? 64 KB : 0) :  /* only needs past data up to window size */
-                cctxPtr->maxBlockSize + ((cctxPtr->prefs.frameInfo.blockMode == LZ4F_blockLinked) ? 128 KB : 0);
-
-        if (cctxPtr->maxBufferSize < requiredBuffSize) {
-            cctxPtr->maxBufferSize = 0;
-            FREEMEM(cctxPtr->tmpBuff);
-            cctxPtr->tmpBuff = (BYTE*)ALLOC_AND_ZERO(requiredBuffSize);
-            if (cctxPtr->tmpBuff == NULL) return err0r(LZ4F_ERROR_allocation_failed);
-            cctxPtr->maxBufferSize = requiredBuffSize;
-    }   }
-    cctxPtr->tmpIn = cctxPtr->tmpBuff;
-    cctxPtr->tmpInSize = 0;
-    (void)XXH32_reset(&(cctxPtr->xxh), 0);
-
-    /* context init */
-    cctxPtr->cdict = cdict;
-    if (cctxPtr->prefs.frameInfo.blockMode == LZ4F_blockLinked) {
-        /* frame init only for blockLinked : blockIndependent will be init at each block */
-        LZ4F_initStream(cctxPtr->lz4CtxPtr, cdict, cctxPtr->prefs.compressionLevel, LZ4F_blockLinked);
-    }
-    if (preferencesPtr->compressionLevel >= LZ4HC_CLEVEL_MIN) {
-        LZ4_favorDecompressionSpeed((LZ4_streamHC_t*)cctxPtr->lz4CtxPtr, (int)preferencesPtr->favorDecSpeed);
-    }
-
-    /* Magic Number */
-    LZ4F_writeLE32(dstPtr, LZ4F_MAGICNUMBER);
-    dstPtr += 4;
-    headerStart = dstPtr;
-
-    /* FLG Byte */
-    *dstPtr++ = (BYTE)(((1 & _2BITS) << 6)    /* Version('01') */
-        + ((cctxPtr->prefs.frameInfo.blockMode & _1BIT ) << 5)
-        + ((cctxPtr->prefs.frameInfo.blockChecksumFlag & _1BIT ) << 4)
-        + ((unsigned)(cctxPtr->prefs.frameInfo.contentSize > 0) << 3)
-        + ((cctxPtr->prefs.frameInfo.contentChecksumFlag & _1BIT ) << 2)
-        +  (cctxPtr->prefs.frameInfo.dictID > 0) );
-    /* BD Byte */
-    *dstPtr++ = (BYTE)((cctxPtr->prefs.frameInfo.blockSizeID & _3BITS) << 4);
-    /* Optional Frame content size field */
-    if (cctxPtr->prefs.frameInfo.contentSize) {
-        LZ4F_writeLE64(dstPtr, cctxPtr->prefs.frameInfo.contentSize);
-        dstPtr += 8;
-        cctxPtr->totalInSize = 0;
-    }
-    /* Optional dictionary ID field */
-    if (cctxPtr->prefs.frameInfo.dictID) {
-        LZ4F_writeLE32(dstPtr, cctxPtr->prefs.frameInfo.dictID);
-        dstPtr += 4;
-    }
-    /* Header CRC Byte */
-    *dstPtr = LZ4F_headerChecksum(headerStart, (size_t)(dstPtr - headerStart));
-    dstPtr++;
-
-    cctxPtr->cStage = 1;   /* header written, now request input data block */
-    return (size_t)(dstPtr - dstStart);
-}
-
-
-/*! LZ4F_compressBegin() :
- *  init streaming compression and writes frame header into dstBuffer.
- *  dstBuffer must be >= LZ4F_HEADER_SIZE_MAX bytes.
- *  preferencesPtr can be NULL, in which case default parameters are selected.
- * @return : number of bytes written into dstBuffer for the header
- *        or an error code (can be tested using LZ4F_isError())
- */
-size_t LZ4F_compressBegin(LZ4F_cctx* cctxPtr,
-                          void* dstBuffer, size_t dstCapacity,
-                          const LZ4F_preferences_t* preferencesPtr)
-{
-    return LZ4F_compressBegin_usingCDict(cctxPtr, dstBuffer, dstCapacity,
-                                         NULL, preferencesPtr);
-}
-
-
-/*  LZ4F_compressBound() :
- * @return minimum capacity of dstBuffer for a given srcSize to handle worst case scenario.
- *  LZ4F_preferences_t structure is optional : if NULL, preferences will be set to cover worst case scenario.
- *  This function cannot fail.
- */
-size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr)
-{
-    if (preferencesPtr && preferencesPtr->autoFlush) {
-        return LZ4F_compressBound_internal(srcSize, preferencesPtr, 0);
-    }
-    return LZ4F_compressBound_internal(srcSize, preferencesPtr, (size_t)-1);
-}
-
-
-typedef int (*compressFunc_t)(void* ctx, const char* src, char* dst, int srcSize, int dstSize, int level, const LZ4F_CDict* cdict);
-
-
-/*! LZ4F_makeBlock():
- *  compress a single block, add header and optional checksum.
- *  assumption : dst buffer capacity is >= BHSize + srcSize + crcSize
- */
-static size_t LZ4F_makeBlock(void* dst,
-                       const void* src, size_t srcSize,
-                             compressFunc_t compress, void* lz4ctx, int level,
-                       const LZ4F_CDict* cdict,
-                             LZ4F_blockChecksum_t crcFlag)
-{
-    BYTE* const cSizePtr = (BYTE*)dst;
-    U32 cSize = (U32)compress(lz4ctx, (const char*)src, (char*)(cSizePtr+BHSize),
-                                      (int)(srcSize), (int)(srcSize-1),
-                                      level, cdict);
-    if (cSize == 0) {  /* compression failed */
-        DEBUGLOG(5, "LZ4F_makeBlock: compression failed, creating a raw block (size %u)", (U32)srcSize);
-        cSize = (U32)srcSize;
-        LZ4F_writeLE32(cSizePtr, cSize | LZ4F_BLOCKUNCOMPRESSED_FLAG);
-        memcpy(cSizePtr+BHSize, src, srcSize);
-    } else {
-        LZ4F_writeLE32(cSizePtr, cSize);
-    }
-    if (crcFlag) {
-        U32 const crc32 = XXH32(cSizePtr+BHSize, cSize, 0);  /* checksum of compressed data */
-        LZ4F_writeLE32(cSizePtr+BHSize+cSize, crc32);
-    }
-    return BHSize + cSize + ((U32)crcFlag)*BFSize;
-}
-
-
-static int LZ4F_compressBlock(void* ctx, const char* src, char* dst, int srcSize, int dstCapacity, int level, const LZ4F_CDict* cdict)
-{
-    int const acceleration = (level < 0) ? -level + 1 : 1;
-    LZ4F_initStream(ctx, cdict, level, LZ4F_blockIndependent);
-    if (cdict) {
-        return LZ4_compress_fast_continue((LZ4_stream_t*)ctx, src, dst, srcSize, dstCapacity, acceleration);
-    } else {
-        return LZ4_compress_fast_extState_fastReset(ctx, src, dst, srcSize, dstCapacity, acceleration);
-    }
-}
-
-static int LZ4F_compressBlock_continue(void* ctx, const char* src, char* dst, int srcSize, int dstCapacity, int level, const LZ4F_CDict* cdict)
-{
-    int const acceleration = (level < 0) ? -level + 1 : 1;
-    (void)cdict; /* init once at beginning of frame */
-    return LZ4_compress_fast_continue((LZ4_stream_t*)ctx, src, dst, srcSize, dstCapacity, acceleration);
-}
-
-static int LZ4F_compressBlockHC(void* ctx, const char* src, char* dst, int srcSize, int dstCapacity, int level, const LZ4F_CDict* cdict)
-{
-    LZ4F_initStream(ctx, cdict, level, LZ4F_blockIndependent);
-    if (cdict) {
-        return LZ4_compress_HC_continue((LZ4_streamHC_t*)ctx, src, dst, srcSize, dstCapacity);
-    }
-    return LZ4_compress_HC_extStateHC_fastReset(ctx, src, dst, srcSize, dstCapacity, level);
-}
-
-static int LZ4F_compressBlockHC_continue(void* ctx, const char* src, char* dst, int srcSize, int dstCapacity, int level, const LZ4F_CDict* cdict)
-{
-    (void)level; (void)cdict; /* init once at beginning of frame */
-    return LZ4_compress_HC_continue((LZ4_streamHC_t*)ctx, src, dst, srcSize, dstCapacity);
-}
-
-static compressFunc_t LZ4F_selectCompression(LZ4F_blockMode_t blockMode, int level)
-{
-    if (level < LZ4HC_CLEVEL_MIN) {
-        if (blockMode == LZ4F_blockIndependent) return LZ4F_compressBlock;
-        return LZ4F_compressBlock_continue;
-    }
-    if (blockMode == LZ4F_blockIndependent) return LZ4F_compressBlockHC;
-    return LZ4F_compressBlockHC_continue;
-}
-
-static int LZ4F_localSaveDict(LZ4F_cctx_t* cctxPtr)
-{
-    if (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN)
-        return LZ4_saveDict ((LZ4_stream_t*)(cctxPtr->lz4CtxPtr), (char*)(cctxPtr->tmpBuff), 64 KB);
-    return LZ4_saveDictHC ((LZ4_streamHC_t*)(cctxPtr->lz4CtxPtr), (char*)(cctxPtr->tmpBuff), 64 KB);
-}
-
-typedef enum { notDone, fromTmpBuffer, fromSrcBuffer } LZ4F_lastBlockStatus;
-
-/*! LZ4F_compressUpdate() :
- *  LZ4F_compressUpdate() can be called repetitively to compress as much data as necessary.
- *  dstBuffer MUST be >= LZ4F_compressBound(srcSize, preferencesPtr).
- *  LZ4F_compressOptions_t structure is optional : you can provide NULL as argument.
- * @return : the number of bytes written into dstBuffer. It can be zero, meaning input data was just buffered.
- *           or an error code if it fails (which can be tested using LZ4F_isError())
- */
-size_t LZ4F_compressUpdate(LZ4F_cctx* cctxPtr,
-                           void* dstBuffer, size_t dstCapacity,
-                     const void* srcBuffer, size_t srcSize,
-                     const LZ4F_compressOptions_t* compressOptionsPtr)
-{
-    LZ4F_compressOptions_t cOptionsNull;
-    size_t const blockSize = cctxPtr->maxBlockSize;
-    const BYTE* srcPtr = (const BYTE*)srcBuffer;
-    const BYTE* const srcEnd = srcPtr + srcSize;
-    BYTE* const dstStart = (BYTE*)dstBuffer;
-    BYTE* dstPtr = dstStart;
-    LZ4F_lastBlockStatus lastBlockCompressed = notDone;
-    compressFunc_t const compress = LZ4F_selectCompression(cctxPtr->prefs.frameInfo.blockMode, cctxPtr->prefs.compressionLevel);
-
-    DEBUGLOG(4, "LZ4F_compressUpdate (srcSize=%zu)", srcSize);
-
-    if (cctxPtr->cStage != 1) return err0r(LZ4F_ERROR_GENERIC);
-    if (dstCapacity < LZ4F_compressBound_internal(srcSize, &(cctxPtr->prefs), cctxPtr->tmpInSize))
-        return err0r(LZ4F_ERROR_dstMaxSize_tooSmall);
-    MEM_INIT(&cOptionsNull, 0, sizeof(cOptionsNull));
-    if (compressOptionsPtr == NULL) compressOptionsPtr = &cOptionsNull;
-
-    /* complete tmp buffer */
-    if (cctxPtr->tmpInSize > 0) {   /* some data already within tmp buffer */
-        size_t const sizeToCopy = blockSize - cctxPtr->tmpInSize;
-        if (sizeToCopy > srcSize) {
-            /* add src to tmpIn buffer */
-            memcpy(cctxPtr->tmpIn + cctxPtr->tmpInSize, srcBuffer, srcSize);
-            srcPtr = srcEnd;
-            cctxPtr->tmpInSize += srcSize;
-            /* still needs some CRC */
-        } else {
-            /* complete tmpIn block and then compress it */
-            lastBlockCompressed = fromTmpBuffer;
-            memcpy(cctxPtr->tmpIn + cctxPtr->tmpInSize, srcBuffer, sizeToCopy);
-            srcPtr += sizeToCopy;
-
-            dstPtr += LZ4F_makeBlock(dstPtr,
-                                     cctxPtr->tmpIn, blockSize,
-                                     compress, cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel,
-                                     cctxPtr->cdict,
-                                     cctxPtr->prefs.frameInfo.blockChecksumFlag);
-
-            if (cctxPtr->prefs.frameInfo.blockMode==LZ4F_blockLinked) cctxPtr->tmpIn += blockSize;
-            cctxPtr->tmpInSize = 0;
-        }
-    }
-
-    while ((size_t)(srcEnd - srcPtr) >= blockSize) {
-        /* compress full blocks */
-        lastBlockCompressed = fromSrcBuffer;
-        dstPtr += LZ4F_makeBlock(dstPtr,
-                                 srcPtr, blockSize,
-                                 compress, cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel,
-                                 cctxPtr->cdict,
-                                 cctxPtr->prefs.frameInfo.blockChecksumFlag);
-        srcPtr += blockSize;
-    }
-
-    if ((cctxPtr->prefs.autoFlush) && (srcPtr < srcEnd)) {
-        /* compress remaining input < blockSize */
-        lastBlockCompressed = fromSrcBuffer;
-        dstPtr += LZ4F_makeBlock(dstPtr,
-                                 srcPtr, (size_t)(srcEnd - srcPtr),
-                                 compress, cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel,
-                                 cctxPtr->cdict,
-                                 cctxPtr->prefs.frameInfo.blockChecksumFlag);
-        srcPtr  = srcEnd;
-    }
-
-    /* preserve dictionary if necessary */
-    if ((cctxPtr->prefs.frameInfo.blockMode==LZ4F_blockLinked) && (lastBlockCompressed==fromSrcBuffer)) {
-        if (compressOptionsPtr->stableSrc) {
-            cctxPtr->tmpIn = cctxPtr->tmpBuff;
-        } else {
-            int const realDictSize = LZ4F_localSaveDict(cctxPtr);
-            if (realDictSize==0) return err0r(LZ4F_ERROR_GENERIC);
-            cctxPtr->tmpIn = cctxPtr->tmpBuff + realDictSize;
-        }
-    }
-
-    /* keep tmpIn within limits */
-    if ((cctxPtr->tmpIn + blockSize) > (cctxPtr->tmpBuff + cctxPtr->maxBufferSize)   /* necessarily LZ4F_blockLinked && lastBlockCompressed==fromTmpBuffer */
-        && !(cctxPtr->prefs.autoFlush))
-    {
-        int const realDictSize = LZ4F_localSaveDict(cctxPtr);
-        cctxPtr->tmpIn = cctxPtr->tmpBuff + realDictSize;
-    }
-
-    /* some input data left, necessarily < blockSize */
-    if (srcPtr < srcEnd) {
-        /* fill tmp buffer */
-        size_t const sizeToCopy = (size_t)(srcEnd - srcPtr);
-        memcpy(cctxPtr->tmpIn, srcPtr, sizeToCopy);
-        cctxPtr->tmpInSize = sizeToCopy;
-    }
-
-    if (cctxPtr->prefs.frameInfo.contentChecksumFlag == LZ4F_contentChecksumEnabled)
-        (void)XXH32_update(&(cctxPtr->xxh), srcBuffer, srcSize);
-
-    cctxPtr->totalInSize += srcSize;
-    return (size_t)(dstPtr - dstStart);
-}
-
-
-/*! LZ4F_flush() :
- *  When compressed data must be sent immediately, without waiting for a block to be filled,
- *  invoke LZ4_flush(), which will immediately compress any remaining data stored within LZ4F_cctx.
- *  The result of the function is the number of bytes written into dstBuffer.
- *  It can be zero, this means there was no data left within LZ4F_cctx.
- *  The function outputs an error code if it fails (can be tested using LZ4F_isError())
- *  LZ4F_compressOptions_t* is optional. NULL is a valid argument.
- */
-size_t LZ4F_flush(LZ4F_cctx* cctxPtr,
-                  void* dstBuffer, size_t dstCapacity,
-            const LZ4F_compressOptions_t* compressOptionsPtr)
-{
-    BYTE* const dstStart = (BYTE*)dstBuffer;
-    BYTE* dstPtr = dstStart;
-    compressFunc_t compress;
-
-    if (cctxPtr->tmpInSize == 0) return 0;   /* nothing to flush */
-    if (cctxPtr->cStage != 1) return err0r(LZ4F_ERROR_GENERIC);
-    if (dstCapacity < (cctxPtr->tmpInSize + BHSize + BFSize))
-        return err0r(LZ4F_ERROR_dstMaxSize_tooSmall);
-    (void)compressOptionsPtr;   /* not yet useful */
-
-    /* select compression function */
-    compress = LZ4F_selectCompression(cctxPtr->prefs.frameInfo.blockMode, cctxPtr->prefs.compressionLevel);
-
-    /* compress tmp buffer */
-    dstPtr += LZ4F_makeBlock(dstPtr,
-                             cctxPtr->tmpIn, cctxPtr->tmpInSize,
-                             compress, cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel,
-                             cctxPtr->cdict,
-                             cctxPtr->prefs.frameInfo.blockChecksumFlag);
-    assert(((void)"flush overflows dstBuffer!", (size_t)(dstPtr - dstStart) <= dstCapacity));
-
-    if (cctxPtr->prefs.frameInfo.blockMode == LZ4F_blockLinked)
-        cctxPtr->tmpIn += cctxPtr->tmpInSize;
-    cctxPtr->tmpInSize = 0;
-
-    /* keep tmpIn within limits */
-    if ((cctxPtr->tmpIn + cctxPtr->maxBlockSize) > (cctxPtr->tmpBuff + cctxPtr->maxBufferSize)) {  /* necessarily LZ4F_blockLinked */
-        int const realDictSize = LZ4F_localSaveDict(cctxPtr);
-        cctxPtr->tmpIn = cctxPtr->tmpBuff + realDictSize;
-    }
-
-    return (size_t)(dstPtr - dstStart);
-}
-
-
-/*! LZ4F_compressEnd() :
- *  When you want to properly finish the compressed frame, just call LZ4F_compressEnd().
- *  It will flush whatever data remained within compressionContext (like LZ4_flush())
- *  but also properly finalize the frame, with an endMark and an (optional) checksum.
- *  LZ4F_compressOptions_t structure is optional : you can provide NULL as argument.
- * @return: the number of bytes written into dstBuffer (necessarily >= 4 (endMark size))
- *       or an error code if it fails (can be tested using LZ4F_isError())
- *  The context can then be used again to compress a new frame, starting with LZ4F_compressBegin().
- */
-size_t LZ4F_compressEnd(LZ4F_cctx* cctxPtr,
-                        void* dstBuffer, size_t dstCapacity,
-                  const LZ4F_compressOptions_t* compressOptionsPtr)
-{
-    BYTE* const dstStart = (BYTE*)dstBuffer;
-    BYTE* dstPtr = dstStart;
-
-    size_t const flushSize = LZ4F_flush(cctxPtr, dstBuffer, dstCapacity, compressOptionsPtr);
-    DEBUGLOG(5,"LZ4F_compressEnd: dstCapacity=%u", (unsigned)dstCapacity);
-    if (LZ4F_isError(flushSize)) return flushSize;
-    dstPtr += flushSize;
-
-    assert(flushSize <= dstCapacity);
-    dstCapacity -= flushSize;
-
-    if (dstCapacity < 4) return err0r(LZ4F_ERROR_dstMaxSize_tooSmall);
-    LZ4F_writeLE32(dstPtr, 0);
-    dstPtr += 4;   /* endMark */
-
-    if (cctxPtr->prefs.frameInfo.contentChecksumFlag == LZ4F_contentChecksumEnabled) {
-        U32 const xxh = XXH32_digest(&(cctxPtr->xxh));
-        if (dstCapacity < 8) return err0r(LZ4F_ERROR_dstMaxSize_tooSmall);
-        DEBUGLOG(5,"Writing 32-bit content checksum");
-        LZ4F_writeLE32(dstPtr, xxh);
-        dstPtr+=4;   /* content Checksum */
-    }
-
-    cctxPtr->cStage = 0;   /* state is now re-usable (with identical preferences) */
-    cctxPtr->maxBufferSize = 0;  /* reuse HC context */
-
-    if (cctxPtr->prefs.frameInfo.contentSize) {
-        if (cctxPtr->prefs.frameInfo.contentSize != cctxPtr->totalInSize)
-            return err0r(LZ4F_ERROR_frameSize_wrong);
-    }
-
-    return (size_t)(dstPtr - dstStart);
-}
-
-
-/*-***************************************************
-*   Frame Decompression
-*****************************************************/
-
-typedef enum {
-    dstage_getFrameHeader=0, dstage_storeFrameHeader,
-    dstage_init,
-    dstage_getBlockHeader, dstage_storeBlockHeader,
-    dstage_copyDirect, dstage_getBlockChecksum,
-    dstage_getCBlock, dstage_storeCBlock,
-    dstage_flushOut,
-    dstage_getSuffix, dstage_storeSuffix,
-    dstage_getSFrameSize, dstage_storeSFrameSize,
-    dstage_skipSkippable
-} dStage_t;
-
-struct LZ4F_dctx_s {
-    LZ4F_frameInfo_t frameInfo;
-    U32    version;
-    dStage_t dStage;
-    U64    frameRemainingSize;
-    size_t maxBlockSize;
-    size_t maxBufferSize;
-    BYTE*  tmpIn;
-    size_t tmpInSize;
-    size_t tmpInTarget;
-    BYTE*  tmpOutBuffer;
-    const BYTE* dict;
-    size_t dictSize;
-    BYTE*  tmpOut;
-    size_t tmpOutSize;
-    size_t tmpOutStart;
-    XXH32_state_t xxh;
-    XXH32_state_t blockChecksum;
-    BYTE   header[LZ4F_HEADER_SIZE_MAX];
-};  /* typedef'd to LZ4F_dctx in lz4frame.h */
-
-
-/*! LZ4F_createDecompressionContext() :
- *  Create a decompressionContext object, which will track all decompression operations.
- *  Provides a pointer to a fully allocated and initialized LZ4F_decompressionContext object.
- *  Object can later be released using LZ4F_freeDecompressionContext().
- * @return : if != 0, there was an error during context creation.
- */
-LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_dctx** LZ4F_decompressionContextPtr, unsigned versionNumber)
-{
-    LZ4F_dctx* const dctx = (LZ4F_dctx*)ALLOC_AND_ZERO(sizeof(LZ4F_dctx));
-    if (dctx == NULL) {  /* failed allocation */
-        *LZ4F_decompressionContextPtr = NULL;
-        return err0r(LZ4F_ERROR_allocation_failed);
-    }
-
-    dctx->version = versionNumber;
-    *LZ4F_decompressionContextPtr = dctx;
-    return LZ4F_OK_NoError;
-}
-
-LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_dctx* dctx)
-{
-    LZ4F_errorCode_t result = LZ4F_OK_NoError;
-    if (dctx != NULL) {   /* can accept NULL input, like free() */
-      result = (LZ4F_errorCode_t)dctx->dStage;
-      FREEMEM(dctx->tmpIn);
-      FREEMEM(dctx->tmpOutBuffer);
-      FREEMEM(dctx);
-    }
-    return result;
-}
-
-
-/*==---   Streaming Decompression operations   ---==*/
-
-void LZ4F_resetDecompressionContext(LZ4F_dctx* dctx)
-{
-    dctx->dStage = dstage_getFrameHeader;
-    dctx->dict = NULL;
-    dctx->dictSize = 0;
-}
-
-
-/*! LZ4F_decodeHeader() :
- *  input   : `src` points at the **beginning of the frame**
- *  output  : set internal values of dctx, such as
- *            dctx->frameInfo and dctx->dStage.
- *            Also allocates internal buffers.
- *  @return : nb Bytes read from src (necessarily <= srcSize)
- *            or an error code (testable with LZ4F_isError())
- */
-static size_t LZ4F_decodeHeader(LZ4F_dctx* dctx, const void* src, size_t srcSize)
-{
-    unsigned blockMode, blockChecksumFlag, contentSizeFlag, contentChecksumFlag, dictIDFlag, blockSizeID;
-    size_t frameHeaderSize;
-    const BYTE* srcPtr = (const BYTE*)src;
-
-    DEBUGLOG(5, "LZ4F_decodeHeader");
-    /* need to decode header to get frameInfo */
-    if (srcSize < minFHSize) return err0r(LZ4F_ERROR_frameHeader_incomplete);   /* minimal frame header size */
-    MEM_INIT(&(dctx->frameInfo), 0, sizeof(dctx->frameInfo));
-
-    /* special case : skippable frames */
-    if ((LZ4F_readLE32(srcPtr) & 0xFFFFFFF0U) == LZ4F_MAGIC_SKIPPABLE_START) {
-        dctx->frameInfo.frameType = LZ4F_skippableFrame;
-        if (src == (void*)(dctx->header)) {
-            dctx->tmpInSize = srcSize;
-            dctx->tmpInTarget = 8;
-            dctx->dStage = dstage_storeSFrameSize;
-            return srcSize;
-        } else {
-            dctx->dStage = dstage_getSFrameSize;
-            return 4;
-        }
-    }
-
-    /* control magic number */
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    if (LZ4F_readLE32(srcPtr) != LZ4F_MAGICNUMBER) {
-        DEBUGLOG(4, "frame header error : unknown magic number");
-        return err0r(LZ4F_ERROR_frameType_unknown);
-    }
-#endif
-    dctx->frameInfo.frameType = LZ4F_frame;
-
-    /* Flags */
-    {   U32 const FLG = srcPtr[4];
-        U32 const version = (FLG>>6) & _2BITS;
-        blockChecksumFlag = (FLG>>4) & _1BIT;
-        blockMode = (FLG>>5) & _1BIT;
-        contentSizeFlag = (FLG>>3) & _1BIT;
-        contentChecksumFlag = (FLG>>2) & _1BIT;
-        dictIDFlag = FLG & _1BIT;
-        /* validate */
-        if (((FLG>>1)&_1BIT) != 0) return err0r(LZ4F_ERROR_reservedFlag_set); /* Reserved bit */
-        if (version != 1) return err0r(LZ4F_ERROR_headerVersion_wrong);        /* Version Number, only supported value */
-    }
-
-    /* Frame Header Size */
-    frameHeaderSize = minFHSize + (contentSizeFlag?8:0) + (dictIDFlag?4:0);
-
-    if (srcSize < frameHeaderSize) {
-        /* not enough input to fully decode frame header */
-        if (srcPtr != dctx->header)
-            memcpy(dctx->header, srcPtr, srcSize);
-        dctx->tmpInSize = srcSize;
-        dctx->tmpInTarget = frameHeaderSize;
-        dctx->dStage = dstage_storeFrameHeader;
-        return srcSize;
-    }
-
-    {   U32 const BD = srcPtr[5];
-        blockSizeID = (BD>>4) & _3BITS;
-        /* validate */
-        if (((BD>>7)&_1BIT) != 0) return err0r(LZ4F_ERROR_reservedFlag_set);   /* Reserved bit */
-        if (blockSizeID < 4) return err0r(LZ4F_ERROR_maxBlockSize_invalid);    /* 4-7 only supported values for the time being */
-        if (((BD>>0)&_4BITS) != 0) return err0r(LZ4F_ERROR_reservedFlag_set);  /* Reserved bits */
-    }
-
-    /* check header */
-    assert(frameHeaderSize > 5);
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    {   BYTE const HC = LZ4F_headerChecksum(srcPtr+4, frameHeaderSize-5);
-        if (HC != srcPtr[frameHeaderSize-1])
-            return err0r(LZ4F_ERROR_headerChecksum_invalid);
-    }
-#endif
-
-    /* save */
-    dctx->frameInfo.blockMode = (LZ4F_blockMode_t)blockMode;
-    dctx->frameInfo.blockChecksumFlag = (LZ4F_blockChecksum_t)blockChecksumFlag;
-    dctx->frameInfo.contentChecksumFlag = (LZ4F_contentChecksum_t)contentChecksumFlag;
-    dctx->frameInfo.blockSizeID = (LZ4F_blockSizeID_t)blockSizeID;
-    dctx->maxBlockSize = LZ4F_getBlockSize(blockSizeID);
-    if (contentSizeFlag)
-        dctx->frameRemainingSize =
-            dctx->frameInfo.contentSize = LZ4F_readLE64(srcPtr+6);
-    if (dictIDFlag)
-        dctx->frameInfo.dictID = LZ4F_readLE32(srcPtr + frameHeaderSize - 5);
-
-    dctx->dStage = dstage_init;
-
-    return frameHeaderSize;
-}
-
-
-/*! LZ4F_headerSize() :
- * @return : size of frame header
- *           or an error code, which can be tested using LZ4F_isError()
- */
-size_t LZ4F_headerSize(const void* src, size_t srcSize)
-{
-    if (src == NULL) return err0r(LZ4F_ERROR_srcPtr_wrong);
-
-    /* minimal srcSize to determine header size */
-    if (srcSize < LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH)
-        return err0r(LZ4F_ERROR_frameHeader_incomplete);
-
-    /* special case : skippable frames */
-    if ((LZ4F_readLE32(src) & 0xFFFFFFF0U) == LZ4F_MAGIC_SKIPPABLE_START)
-        return 8;
-
-    /* control magic number */
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    if (LZ4F_readLE32(src) != LZ4F_MAGICNUMBER)
-        return err0r(LZ4F_ERROR_frameType_unknown);
-#endif
-
-    /* Frame Header Size */
-    {   BYTE const FLG = ((const BYTE*)src)[4];
-        U32 const contentSizeFlag = (FLG>>3) & _1BIT;
-        U32 const dictIDFlag = FLG & _1BIT;
-        return minFHSize + (contentSizeFlag?8:0) + (dictIDFlag?4:0);
-    }
-}
-
-/*! LZ4F_getFrameInfo() :
- *  This function extracts frame parameters (max blockSize, frame checksum, etc.).
- *  Usage is optional. Objective is to provide relevant information for allocation purposes.
- *  This function works in 2 situations :
- *   - At the beginning of a new frame, in which case it will decode this information from `srcBuffer`, and start the decoding process.
- *     Amount of input data provided must be large enough to successfully decode the frame header.
- *     A header size is variable, but is guaranteed to be <= LZ4F_HEADER_SIZE_MAX bytes. It's possible to provide more input data than this minimum.
- *   - After decoding has been started. In which case, no input is read, frame parameters are extracted from dctx.
- *  The number of bytes consumed from srcBuffer will be updated within *srcSizePtr (necessarily <= original value).
- *  Decompression must resume from (srcBuffer + *srcSizePtr).
- * @return : an hint about how many srcSize bytes LZ4F_decompress() expects for next call,
- *           or an error code which can be tested using LZ4F_isError()
- *  note 1 : in case of error, dctx is not modified. Decoding operations can resume from where they stopped.
- *  note 2 : frame parameters are *copied into* an already allocated LZ4F_frameInfo_t structure.
- */
-LZ4F_errorCode_t LZ4F_getFrameInfo(LZ4F_dctx* dctx,
-                                   LZ4F_frameInfo_t* frameInfoPtr,
-                             const void* srcBuffer, size_t* srcSizePtr)
-{
-    LZ4F_STATIC_ASSERT(dstage_getFrameHeader < dstage_storeFrameHeader);
-    if (dctx->dStage > dstage_storeFrameHeader) {
-        /* frameInfo already decoded */
-        size_t o=0, i=0;
-        *srcSizePtr = 0;
-        *frameInfoPtr = dctx->frameInfo;
-        /* returns : recommended nb of bytes for LZ4F_decompress() */
-        return LZ4F_decompress(dctx, NULL, &o, NULL, &i, NULL);
-    } else {
-        if (dctx->dStage == dstage_storeFrameHeader) {
-            /* frame decoding already started, in the middle of header => automatic fail */
-            *srcSizePtr = 0;
-            return err0r(LZ4F_ERROR_frameDecoding_alreadyStarted);
-        } else {
-            size_t const hSize = LZ4F_headerSize(srcBuffer, *srcSizePtr);
-            if (LZ4F_isError(hSize)) { *srcSizePtr=0; return hSize; }
-            if (*srcSizePtr < hSize) {
-                *srcSizePtr=0;
-                return err0r(LZ4F_ERROR_frameHeader_incomplete);
-            }
-
-            {   size_t decodeResult = LZ4F_decodeHeader(dctx, srcBuffer, hSize);
-                if (LZ4F_isError(decodeResult)) {
-                    *srcSizePtr = 0;
-                } else {
-                    *srcSizePtr = decodeResult;
-                    decodeResult = BHSize;   /* block header size */
-                }
-                *frameInfoPtr = dctx->frameInfo;
-                return decodeResult;
-    }   }   }
-}
-
-
-/* LZ4F_updateDict() :
- * only used for LZ4F_blockLinked mode
- * Condition : dstPtr != NULL
- */
-static void LZ4F_updateDict(LZ4F_dctx* dctx,
-                      const BYTE* dstPtr, size_t dstSize, const BYTE* dstBufferStart,
-                      unsigned withinTmp)
-{
-    assert(dstPtr != NULL);
-    if (dctx->dictSize==0) {
-        dctx->dict = (const BYTE*)dstPtr;   /* priority to prefix mode */
-    }
-    assert(dctx->dict != NULL);
-
-    if (dctx->dict + dctx->dictSize == dstPtr) {  /* prefix mode, everything within dstBuffer */
-        dctx->dictSize += dstSize;
-        return;
-    }
-
-    assert(dstPtr >= dstBufferStart);
-    if ((size_t)(dstPtr - dstBufferStart) + dstSize >= 64 KB) {  /* history in dstBuffer becomes large enough to become dictionary */
-        dctx->dict = (const BYTE*)dstBufferStart;
-        dctx->dictSize = (size_t)(dstPtr - dstBufferStart) + dstSize;
-        return;
-    }
-
-    assert(dstSize < 64 KB);   /* if dstSize >= 64 KB, dictionary would be set into dstBuffer directly */
-
-    /* dstBuffer does not contain whole useful history (64 KB), so it must be saved within tmpOutBuffer */
-    assert(dctx->tmpOutBuffer != NULL);
-
-    if (withinTmp && (dctx->dict == dctx->tmpOutBuffer)) {   /* continue history within tmpOutBuffer */
-        /* withinTmp expectation : content of [dstPtr,dstSize] is same as [dict+dictSize,dstSize], so we just extend it */
-        assert(dctx->dict + dctx->dictSize == dctx->tmpOut + dctx->tmpOutStart);
-        dctx->dictSize += dstSize;
-        return;
-    }
-
-    if (withinTmp) { /* copy relevant dict portion in front of tmpOut within tmpOutBuffer */
-        size_t const preserveSize = (size_t)(dctx->tmpOut - dctx->tmpOutBuffer);
-        size_t copySize = 64 KB - dctx->tmpOutSize;
-        const BYTE* const oldDictEnd = dctx->dict + dctx->dictSize - dctx->tmpOutStart;
-        if (dctx->tmpOutSize > 64 KB) copySize = 0;
-        if (copySize > preserveSize) copySize = preserveSize;
-
-        memcpy(dctx->tmpOutBuffer + preserveSize - copySize, oldDictEnd - copySize, copySize);
-
-        dctx->dict = dctx->tmpOutBuffer;
-        dctx->dictSize = preserveSize + dctx->tmpOutStart + dstSize;
-        return;
-    }
-
-    if (dctx->dict == dctx->tmpOutBuffer) {    /* copy dst into tmp to complete dict */
-        if (dctx->dictSize + dstSize > dctx->maxBufferSize) {  /* tmp buffer not large enough */
-            size_t const preserveSize = 64 KB - dstSize;
-            memcpy(dctx->tmpOutBuffer, dctx->dict + dctx->dictSize - preserveSize, preserveSize);
-            dctx->dictSize = preserveSize;
-        }
-        memcpy(dctx->tmpOutBuffer + dctx->dictSize, dstPtr, dstSize);
-        dctx->dictSize += dstSize;
-        return;
-    }
-
-    /* join dict & dest into tmp */
-    {   size_t preserveSize = 64 KB - dstSize;
-        if (preserveSize > dctx->dictSize) preserveSize = dctx->dictSize;
-        memcpy(dctx->tmpOutBuffer, dctx->dict + dctx->dictSize - preserveSize, preserveSize);
-        memcpy(dctx->tmpOutBuffer + preserveSize, dstPtr, dstSize);
-        dctx->dict = dctx->tmpOutBuffer;
-        dctx->dictSize = preserveSize + dstSize;
-    }
-}
-
-
-
-/*! LZ4F_decompress() :
- *  Call this function repetitively to regenerate compressed data in srcBuffer.
- *  The function will attempt to decode up to *srcSizePtr bytes from srcBuffer
- *  into dstBuffer of capacity *dstSizePtr.
- *
- *  The number of bytes regenerated into dstBuffer will be provided within *dstSizePtr (necessarily <= original value).
- *
- *  The number of bytes effectively read from srcBuffer will be provided within *srcSizePtr (necessarily <= original value).
- *  If number of bytes read is < number of bytes provided, then decompression operation is not complete.
- *  Remaining data will have to be presented again in a subsequent invocation.
- *
- *  The function result is an hint of the better srcSize to use for next call to LZ4F_decompress.
- *  Schematically, it's the size of the current (or remaining) compressed block + header of next block.
- *  Respecting the hint provides a small boost to performance, since it allows less buffer shuffling.
- *  Note that this is just a hint, and it's always possible to any srcSize value.
- *  When a frame is fully decoded, @return will be 0.
- *  If decompression failed, @return is an error code which can be tested using LZ4F_isError().
- */
-size_t LZ4F_decompress(LZ4F_dctx* dctx,
-                       void* dstBuffer, size_t* dstSizePtr,
-                       const void* srcBuffer, size_t* srcSizePtr,
-                       const LZ4F_decompressOptions_t* decompressOptionsPtr)
-{
-    LZ4F_decompressOptions_t optionsNull;
-    const BYTE* const srcStart = (const BYTE*)srcBuffer;
-    const BYTE* const srcEnd = srcStart + *srcSizePtr;
-    const BYTE* srcPtr = srcStart;
-    BYTE* const dstStart = (BYTE*)dstBuffer;
-    BYTE* const dstEnd = dstStart ? dstStart + *dstSizePtr : NULL;
-    BYTE* dstPtr = dstStart;
-    const BYTE* selectedIn = NULL;
-    unsigned doAnotherStage = 1;
-    size_t nextSrcSizeHint = 1;
-
-
-    DEBUGLOG(5, "LZ4F_decompress : %p,%u => %p,%u",
-            srcBuffer, (unsigned)*srcSizePtr, dstBuffer, (unsigned)*dstSizePtr);
-    if (dstBuffer == NULL) assert(*dstSizePtr == 0);
-    MEM_INIT(&optionsNull, 0, sizeof(optionsNull));
-    if (decompressOptionsPtr==NULL) decompressOptionsPtr = &optionsNull;
-    *srcSizePtr = 0;
-    *dstSizePtr = 0;
-    assert(dctx != NULL);
-
-    /* behaves as a state machine */
-
-    while (doAnotherStage) {
-
-        switch(dctx->dStage)
-        {
-
-        case dstage_getFrameHeader:
-            DEBUGLOG(6, "dstage_getFrameHeader");
-            if ((size_t)(srcEnd-srcPtr) >= maxFHSize) {  /* enough to decode - shortcut */
-                size_t const hSize = LZ4F_decodeHeader(dctx, srcPtr, (size_t)(srcEnd-srcPtr));  /* will update dStage appropriately */
-                if (LZ4F_isError(hSize)) return hSize;
-                srcPtr += hSize;
-                break;
-            }
-            dctx->tmpInSize = 0;
-            if (srcEnd-srcPtr == 0) return minFHSize;   /* 0-size input */
-            dctx->tmpInTarget = minFHSize;   /* minimum size to decode header */
-            dctx->dStage = dstage_storeFrameHeader;
-            /* fall-through */
-
-        case dstage_storeFrameHeader:
-            DEBUGLOG(6, "dstage_storeFrameHeader");
-            {   size_t const sizeToCopy = MIN(dctx->tmpInTarget - dctx->tmpInSize, (size_t)(srcEnd - srcPtr));
-                memcpy(dctx->header + dctx->tmpInSize, srcPtr, sizeToCopy);
-                dctx->tmpInSize += sizeToCopy;
-                srcPtr += sizeToCopy;
-            }
-            if (dctx->tmpInSize < dctx->tmpInTarget) {
-                nextSrcSizeHint = (dctx->tmpInTarget - dctx->tmpInSize) + BHSize;   /* rest of header + nextBlockHeader */
-                doAnotherStage = 0;   /* not enough src data, ask for some more */
-                break;
-            }
-            {   size_t const hSize = LZ4F_decodeHeader(dctx, dctx->header, dctx->tmpInTarget);  /* will update dStage appropriately */
-                if (LZ4F_isError(hSize)) return hSize;
-            }
-            break;
-
-        case dstage_init:
-            DEBUGLOG(6, "dstage_init");
-            if (dctx->frameInfo.contentChecksumFlag) (void)XXH32_reset(&(dctx->xxh), 0);
-            /* internal buffers allocation */
-            {   size_t const bufferNeeded = dctx->maxBlockSize
-                    + ((dctx->frameInfo.blockMode==LZ4F_blockLinked) ? 128 KB : 0);
-                if (bufferNeeded > dctx->maxBufferSize) {   /* tmp buffers too small */
-                    dctx->maxBufferSize = 0;   /* ensure allocation will be re-attempted on next entry*/
-                    FREEMEM(dctx->tmpIn);
-                    dctx->tmpIn = (BYTE*)ALLOC(dctx->maxBlockSize + BFSize /* block checksum */);
-                    if (dctx->tmpIn == NULL)
-                        return err0r(LZ4F_ERROR_allocation_failed);
-                    FREEMEM(dctx->tmpOutBuffer);
-                    dctx->tmpOutBuffer= (BYTE*)ALLOC(bufferNeeded);
-                    if (dctx->tmpOutBuffer== NULL)
-                        return err0r(LZ4F_ERROR_allocation_failed);
-                    dctx->maxBufferSize = bufferNeeded;
-            }   }
-            dctx->tmpInSize = 0;
-            dctx->tmpInTarget = 0;
-            dctx->tmpOut = dctx->tmpOutBuffer;
-            dctx->tmpOutStart = 0;
-            dctx->tmpOutSize = 0;
-
-            dctx->dStage = dstage_getBlockHeader;
-            /* fall-through */
-
-        case dstage_getBlockHeader:
-            if ((size_t)(srcEnd - srcPtr) >= BHSize) {
-                selectedIn = srcPtr;
-                srcPtr += BHSize;
-            } else {
-                /* not enough input to read cBlockSize field */
-                dctx->tmpInSize = 0;
-                dctx->dStage = dstage_storeBlockHeader;
-            }
-
-            if (dctx->dStage == dstage_storeBlockHeader)   /* can be skipped */
-        case dstage_storeBlockHeader:
-            {   size_t const remainingInput = (size_t)(srcEnd - srcPtr);
-                size_t const wantedData = BHSize - dctx->tmpInSize;
-                size_t const sizeToCopy = MIN(wantedData, remainingInput);
-                memcpy(dctx->tmpIn + dctx->tmpInSize, srcPtr, sizeToCopy);
-                srcPtr += sizeToCopy;
-                dctx->tmpInSize += sizeToCopy;
-
-                if (dctx->tmpInSize < BHSize) {   /* not enough input for cBlockSize */
-                    nextSrcSizeHint = BHSize - dctx->tmpInSize;
-                    doAnotherStage  = 0;
-                    break;
-                }
-                selectedIn = dctx->tmpIn;
-            }   /* if (dctx->dStage == dstage_storeBlockHeader) */
-
-        /* decode block header */
-            {   U32 const blockHeader = LZ4F_readLE32(selectedIn);
-                size_t const nextCBlockSize = blockHeader & 0x7FFFFFFFU;
-                size_t const crcSize = dctx->frameInfo.blockChecksumFlag * BFSize;
-                if (blockHeader==0) {  /* frameEnd signal, no more block */
-                    DEBUGLOG(5, "end of frame");
-                    dctx->dStage = dstage_getSuffix;
-                    break;
-                }
-                if (nextCBlockSize > dctx->maxBlockSize) {
-                    return err0r(LZ4F_ERROR_maxBlockSize_invalid);
-                }
-                if (blockHeader & LZ4F_BLOCKUNCOMPRESSED_FLAG) {
-                    /* next block is uncompressed */
-                    dctx->tmpInTarget = nextCBlockSize;
-                    DEBUGLOG(5, "next block is uncompressed (size %u)", (U32)nextCBlockSize);
-                    if (dctx->frameInfo.blockChecksumFlag) {
-                        (void)XXH32_reset(&dctx->blockChecksum, 0);
-                    }
-                    dctx->dStage = dstage_copyDirect;
-                    break;
-                }
-                /* next block is a compressed block */
-                dctx->tmpInTarget = nextCBlockSize + crcSize;
-                dctx->dStage = dstage_getCBlock;
-                if (dstPtr==dstEnd || srcPtr==srcEnd) {
-                    nextSrcSizeHint = BHSize + nextCBlockSize + crcSize;
-                    doAnotherStage = 0;
-                }
-                break;
-            }
-
-        case dstage_copyDirect:   /* uncompressed block */
-            DEBUGLOG(6, "dstage_copyDirect");
-            {   size_t sizeToCopy;
-                if (dstPtr == NULL) {
-                    sizeToCopy = 0;
-                } else {
-                    size_t const minBuffSize = MIN((size_t)(srcEnd-srcPtr), (size_t)(dstEnd-dstPtr));
-                    sizeToCopy = MIN(dctx->tmpInTarget, minBuffSize);
-                    memcpy(dstPtr, srcPtr, sizeToCopy);
-                    if (dctx->frameInfo.blockChecksumFlag) {
-                        (void)XXH32_update(&dctx->blockChecksum, srcPtr, sizeToCopy);
-                    }
-                    if (dctx->frameInfo.contentChecksumFlag)
-                        (void)XXH32_update(&dctx->xxh, srcPtr, sizeToCopy);
-                    if (dctx->frameInfo.contentSize)
-                        dctx->frameRemainingSize -= sizeToCopy;
-
-                    /* history management (linked blocks only)*/
-                    if (dctx->frameInfo.blockMode == LZ4F_blockLinked) {
-                        LZ4F_updateDict(dctx, dstPtr, sizeToCopy, dstStart, 0);
-                }   }
-
-                srcPtr += sizeToCopy;
-                dstPtr += sizeToCopy;
-                if (sizeToCopy == dctx->tmpInTarget) {   /* all done */
-                    if (dctx->frameInfo.blockChecksumFlag) {
-                        dctx->tmpInSize = 0;
-                        dctx->dStage = dstage_getBlockChecksum;
-                    } else
-                        dctx->dStage = dstage_getBlockHeader;  /* new block */
-                    break;
-                }
-                dctx->tmpInTarget -= sizeToCopy;  /* need to copy more */
-            }
-            nextSrcSizeHint = dctx->tmpInTarget +
-                            +(dctx->frameInfo.blockChecksumFlag ? BFSize : 0)
-                            + BHSize /* next header size */;
-            doAnotherStage = 0;
-            break;
-
-        /* check block checksum for recently transferred uncompressed block */
-        case dstage_getBlockChecksum:
-            DEBUGLOG(6, "dstage_getBlockChecksum");
-            {   const void* crcSrc;
-                if ((srcEnd-srcPtr >= 4) && (dctx->tmpInSize==0)) {
-                    crcSrc = srcPtr;
-                    srcPtr += 4;
-                } else {
-                    size_t const stillToCopy = 4 - dctx->tmpInSize;
-                    size_t const sizeToCopy = MIN(stillToCopy, (size_t)(srcEnd-srcPtr));
-                    memcpy(dctx->header + dctx->tmpInSize, srcPtr, sizeToCopy);
-                    dctx->tmpInSize += sizeToCopy;
-                    srcPtr += sizeToCopy;
-                    if (dctx->tmpInSize < 4) {  /* all input consumed */
-                        doAnotherStage = 0;
-                        break;
-                    }
-                    crcSrc = dctx->header;
-                }
-                {   U32 const readCRC = LZ4F_readLE32(crcSrc);
-                    U32 const calcCRC = XXH32_digest(&dctx->blockChecksum);
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-                    DEBUGLOG(6, "compare block checksum");
-                    if (readCRC != calcCRC) {
-                        DEBUGLOG(4, "incorrect block checksum: %08X != %08X",
-                                readCRC, calcCRC);
-                        return err0r(LZ4F_ERROR_blockChecksum_invalid);
-                    }
-#else
-                    (void)readCRC;
-                    (void)calcCRC;
-#endif
-            }   }
-            dctx->dStage = dstage_getBlockHeader;  /* new block */
-            break;
-
-        case dstage_getCBlock:
-            DEBUGLOG(6, "dstage_getCBlock");
-            if ((size_t)(srcEnd-srcPtr) < dctx->tmpInTarget) {
-                dctx->tmpInSize = 0;
-                dctx->dStage = dstage_storeCBlock;
-                break;
-            }
-            /* input large enough to read full block directly */
-            selectedIn = srcPtr;
-            srcPtr += dctx->tmpInTarget;
-
-            if (0)  /* always jump over next block */
-        case dstage_storeCBlock:
-            {   size_t const wantedData = dctx->tmpInTarget - dctx->tmpInSize;
-                size_t const inputLeft = (size_t)(srcEnd-srcPtr);
-                size_t const sizeToCopy = MIN(wantedData, inputLeft);
-                memcpy(dctx->tmpIn + dctx->tmpInSize, srcPtr, sizeToCopy);
-                dctx->tmpInSize += sizeToCopy;
-                srcPtr += sizeToCopy;
-                if (dctx->tmpInSize < dctx->tmpInTarget) { /* need more input */
-                    nextSrcSizeHint = (dctx->tmpInTarget - dctx->tmpInSize)
-                                    + (dctx->frameInfo.blockChecksumFlag ? BFSize : 0)
-                                    + BHSize /* next header size */;
-                    doAnotherStage = 0;
-                    break;
-                }
-                selectedIn = dctx->tmpIn;
-            }
-
-            /* At this stage, input is large enough to decode a block */
-            if (dctx->frameInfo.blockChecksumFlag) {
-                dctx->tmpInTarget -= 4;
-                assert(selectedIn != NULL);  /* selectedIn is defined at this stage (either srcPtr, or dctx->tmpIn) */
-                {   U32 const readBlockCrc = LZ4F_readLE32(selectedIn + dctx->tmpInTarget);
-                    U32 const calcBlockCrc = XXH32(selectedIn, dctx->tmpInTarget, 0);
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-                    if (readBlockCrc != calcBlockCrc)
-                        return err0r(LZ4F_ERROR_blockChecksum_invalid);
-#else
-                    (void)readBlockCrc;
-                    (void)calcBlockCrc;
-#endif
-            }   }
-
-            if ((size_t)(dstEnd-dstPtr) >= dctx->maxBlockSize) {
-                const char* dict = (const char*)dctx->dict;
-                size_t dictSize = dctx->dictSize;
-                int decodedSize;
-                assert(dstPtr != NULL);
-                if (dict && dictSize > 1 GB) {
-                    /* the dictSize param is an int, avoid truncation / sign issues */
-                    dict += dictSize - 64 KB;
-                    dictSize = 64 KB;
-                }
-                /* enough capacity in `dst` to decompress directly there */
-                decodedSize = LZ4_decompress_safe_usingDict(
-                        (const char*)selectedIn, (char*)dstPtr,
-                        (int)dctx->tmpInTarget, (int)dctx->maxBlockSize,
-                        dict, (int)dictSize);
-                if (decodedSize < 0) return err0r(LZ4F_ERROR_GENERIC);   /* decompression failed */
-                if (dctx->frameInfo.contentChecksumFlag)
-                    XXH32_update(&(dctx->xxh), dstPtr, (size_t)decodedSize);
-                if (dctx->frameInfo.contentSize)
-                    dctx->frameRemainingSize -= (size_t)decodedSize;
-
-                /* dictionary management */
-                if (dctx->frameInfo.blockMode==LZ4F_blockLinked) {
-                    LZ4F_updateDict(dctx, dstPtr, (size_t)decodedSize, dstStart, 0);
-                }
-
-                dstPtr += decodedSize;
-                dctx->dStage = dstage_getBlockHeader;
-                break;
-            }
-
-            /* not enough place into dst : decode into tmpOut */
-            /* ensure enough place for tmpOut */
-            if (dctx->frameInfo.blockMode == LZ4F_blockLinked) {
-                if (dctx->dict == dctx->tmpOutBuffer) {
-                    if (dctx->dictSize > 128 KB) {
-                        memcpy(dctx->tmpOutBuffer, dctx->dict + dctx->dictSize - 64 KB, 64 KB);
-                        dctx->dictSize = 64 KB;
-                    }
-                    dctx->tmpOut = dctx->tmpOutBuffer + dctx->dictSize;
-                } else {  /* dict not within tmp */
-                    size_t const reservedDictSpace = MIN(dctx->dictSize, 64 KB);
-                    dctx->tmpOut = dctx->tmpOutBuffer + reservedDictSpace;
-            }   }
-
-            /* Decode block */
-            {   const char* dict = (const char*)dctx->dict;
-                size_t dictSize = dctx->dictSize;
-                int decodedSize;
-                if (dict && dictSize > 1 GB) {
-                    /* the dictSize param is an int, avoid truncation / sign issues */
-                    dict += dictSize - 64 KB;
-                    dictSize = 64 KB;
-                }
-                decodedSize = LZ4_decompress_safe_usingDict(
-                        (const char*)selectedIn, (char*)dctx->tmpOut,
-                        (int)dctx->tmpInTarget, (int)dctx->maxBlockSize,
-                        dict, (int)dictSize);
-                if (decodedSize < 0)  /* decompression failed */
-                    return err0r(LZ4F_ERROR_decompressionFailed);
-                if (dctx->frameInfo.contentChecksumFlag)
-                    XXH32_update(&(dctx->xxh), dctx->tmpOut, (size_t)decodedSize);
-                if (dctx->frameInfo.contentSize)
-                    dctx->frameRemainingSize -= (size_t)decodedSize;
-                dctx->tmpOutSize = (size_t)decodedSize;
-                dctx->tmpOutStart = 0;
-                dctx->dStage = dstage_flushOut;
-            }
-            /* fall-through */
-
-        case dstage_flushOut:  /* flush decoded data from tmpOut to dstBuffer */
-            DEBUGLOG(6, "dstage_flushOut");
-            if (dstPtr != NULL) {
-                size_t const sizeToCopy = MIN(dctx->tmpOutSize - dctx->tmpOutStart, (size_t)(dstEnd-dstPtr));
-                memcpy(dstPtr, dctx->tmpOut + dctx->tmpOutStart, sizeToCopy);
-
-                /* dictionary management */
-                if (dctx->frameInfo.blockMode == LZ4F_blockLinked)
-                    LZ4F_updateDict(dctx, dstPtr, sizeToCopy, dstStart, 1 /*withinTmp*/);
-
-                dctx->tmpOutStart += sizeToCopy;
-                dstPtr += sizeToCopy;
-            }
-            if (dctx->tmpOutStart == dctx->tmpOutSize) { /* all flushed */
-                dctx->dStage = dstage_getBlockHeader;  /* get next block */
-                break;
-            }
-            /* could not flush everything : stop there, just request a block header */
-            doAnotherStage = 0;
-            nextSrcSizeHint = BHSize;
-            break;
-
-        case dstage_getSuffix:
-            if (dctx->frameRemainingSize)
-                return err0r(LZ4F_ERROR_frameSize_wrong);   /* incorrect frame size decoded */
-            if (!dctx->frameInfo.contentChecksumFlag) {  /* no checksum, frame is completed */
-                nextSrcSizeHint = 0;
-                LZ4F_resetDecompressionContext(dctx);
-                doAnotherStage = 0;
-                break;
-            }
-            if ((srcEnd - srcPtr) < 4) {  /* not enough size for entire CRC */
-                dctx->tmpInSize = 0;
-                dctx->dStage = dstage_storeSuffix;
-            } else {
-                selectedIn = srcPtr;
-                srcPtr += 4;
-            }
-
-            if (dctx->dStage == dstage_storeSuffix)   /* can be skipped */
-        case dstage_storeSuffix:
-            {   size_t const remainingInput = (size_t)(srcEnd - srcPtr);
-                size_t const wantedData = 4 - dctx->tmpInSize;
-                size_t const sizeToCopy = MIN(wantedData, remainingInput);
-                memcpy(dctx->tmpIn + dctx->tmpInSize, srcPtr, sizeToCopy);
-                srcPtr += sizeToCopy;
-                dctx->tmpInSize += sizeToCopy;
-                if (dctx->tmpInSize < 4) { /* not enough input to read complete suffix */
-                    nextSrcSizeHint = 4 - dctx->tmpInSize;
-                    doAnotherStage=0;
-                    break;
-                }
-                selectedIn = dctx->tmpIn;
-            }   /* if (dctx->dStage == dstage_storeSuffix) */
-
-        /* case dstage_checkSuffix: */   /* no direct entry, avoid initialization risks */
-            {   U32 const readCRC = LZ4F_readLE32(selectedIn);
-                U32 const resultCRC = XXH32_digest(&(dctx->xxh));
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-                if (readCRC != resultCRC)
-                    return err0r(LZ4F_ERROR_contentChecksum_invalid);
-#else
-                (void)readCRC;
-                (void)resultCRC;
-#endif
-                nextSrcSizeHint = 0;
-                LZ4F_resetDecompressionContext(dctx);
-                doAnotherStage = 0;
-                break;
-            }
-
-        case dstage_getSFrameSize:
-            if ((srcEnd - srcPtr) >= 4) {
-                selectedIn = srcPtr;
-                srcPtr += 4;
-            } else {
-                /* not enough input to read cBlockSize field */
-                dctx->tmpInSize = 4;
-                dctx->tmpInTarget = 8;
-                dctx->dStage = dstage_storeSFrameSize;
-            }
-
-            if (dctx->dStage == dstage_storeSFrameSize)
-        case dstage_storeSFrameSize:
-            {   size_t const sizeToCopy = MIN(dctx->tmpInTarget - dctx->tmpInSize,
-                                             (size_t)(srcEnd - srcPtr) );
-                memcpy(dctx->header + dctx->tmpInSize, srcPtr, sizeToCopy);
-                srcPtr += sizeToCopy;
-                dctx->tmpInSize += sizeToCopy;
-                if (dctx->tmpInSize < dctx->tmpInTarget) {
-                    /* not enough input to get full sBlockSize; wait for more */
-                    nextSrcSizeHint = dctx->tmpInTarget - dctx->tmpInSize;
-                    doAnotherStage = 0;
-                    break;
-                }
-                selectedIn = dctx->header + 4;
-            }   /* if (dctx->dStage == dstage_storeSFrameSize) */
-
-        /* case dstage_decodeSFrameSize: */   /* no direct entry */
-            {   size_t const SFrameSize = LZ4F_readLE32(selectedIn);
-                dctx->frameInfo.contentSize = SFrameSize;
-                dctx->tmpInTarget = SFrameSize;
-                dctx->dStage = dstage_skipSkippable;
-                break;
-            }
-
-        case dstage_skipSkippable:
-            {   size_t const skipSize = MIN(dctx->tmpInTarget, (size_t)(srcEnd-srcPtr));
-                srcPtr += skipSize;
-                dctx->tmpInTarget -= skipSize;
-                doAnotherStage = 0;
-                nextSrcSizeHint = dctx->tmpInTarget;
-                if (nextSrcSizeHint) break;  /* still more to skip */
-                /* frame fully skipped : prepare context for a new frame */
-                LZ4F_resetDecompressionContext(dctx);
-                break;
-            }
-        }   /* switch (dctx->dStage) */
-    }   /* while (doAnotherStage) */
-
-    /* preserve history within tmp whenever necessary */
-    LZ4F_STATIC_ASSERT((unsigned)dstage_init == 2);
-    if ( (dctx->frameInfo.blockMode==LZ4F_blockLinked)  /* next block will use up to 64KB from previous ones */
-      && (dctx->dict != dctx->tmpOutBuffer)             /* dictionary is not already within tmp */
-      && (dctx->dict != NULL)                           /* dictionary exists */
-      && (!decompressOptionsPtr->stableDst)             /* cannot rely on dst data to remain there for next call */
-      && ((unsigned)(dctx->dStage)-2 < (unsigned)(dstage_getSuffix)-2) )  /* valid stages : [init ... getSuffix[ */
-    {
-        if (dctx->dStage == dstage_flushOut) {
-            size_t const preserveSize = (size_t)(dctx->tmpOut - dctx->tmpOutBuffer);
-            size_t copySize = 64 KB - dctx->tmpOutSize;
-            const BYTE* oldDictEnd = dctx->dict + dctx->dictSize - dctx->tmpOutStart;
-            if (dctx->tmpOutSize > 64 KB) copySize = 0;
-            if (copySize > preserveSize) copySize = preserveSize;
-            assert(dctx->tmpOutBuffer != NULL);
-
-            memcpy(dctx->tmpOutBuffer + preserveSize - copySize, oldDictEnd - copySize, copySize);
-
-            dctx->dict = dctx->tmpOutBuffer;
-            dctx->dictSize = preserveSize + dctx->tmpOutStart;
-        } else {
-            const BYTE* const oldDictEnd = dctx->dict + dctx->dictSize;
-            size_t const newDictSize = MIN(dctx->dictSize, 64 KB);
-
-            memcpy(dctx->tmpOutBuffer, oldDictEnd - newDictSize, newDictSize);
-
-            dctx->dict = dctx->tmpOutBuffer;
-            dctx->dictSize = newDictSize;
-            dctx->tmpOut = dctx->tmpOutBuffer + newDictSize;
-        }
-    }
-
-    *srcSizePtr = (size_t)(srcPtr - srcStart);
-    *dstSizePtr = (size_t)(dstPtr - dstStart);
-    return nextSrcSizeHint;
-}
-
-/*! LZ4F_decompress_usingDict() :
- *  Same as LZ4F_decompress(), using a predefined dictionary.
- *  Dictionary is used "in place", without any preprocessing.
- *  It must remain accessible throughout the entire frame decoding.
- */
-size_t LZ4F_decompress_usingDict(LZ4F_dctx* dctx,
-                       void* dstBuffer, size_t* dstSizePtr,
-                       const void* srcBuffer, size_t* srcSizePtr,
-                       const void* dict, size_t dictSize,
-                       const LZ4F_decompressOptions_t* decompressOptionsPtr)
-{
-    if (dctx->dStage <= dstage_init) {
-        dctx->dict = (const BYTE*)dict;
-        dctx->dictSize = dictSize;
-    }
-    return LZ4F_decompress(dctx, dstBuffer, dstSizePtr,
-                           srcBuffer, srcSizePtr,
-                           decompressOptionsPtr);
-}
diff --git a/thirdparty/lz4/lz4frame.h b/thirdparty/lz4/lz4frame.h
deleted file mode 100644
index 267f289..0000000
--- a/thirdparty/lz4/lz4frame.h
+++ /dev/null
@@ -1,623 +0,0 @@
-/*
-   LZ4 auto-framing library
-   Header File
-   Copyright (C) 2011-2020, Yann Collet.
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - LZ4 source repository : https://github.com/lz4/lz4
-   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/* LZ4F is a stand-alone API able to create and decode LZ4 frames
- * conformant with specification v1.6.1 in doc/lz4_Frame_format.md .
- * Generated frames are compatible with `lz4` CLI.
- *
- * LZ4F also offers streaming capabilities.
- *
- * lz4.h is not required when using lz4frame.h,
- * except to extract common constant such as LZ4_VERSION_NUMBER.
- * */
-
-#ifndef LZ4F_H_09782039843
-#define LZ4F_H_09782039843
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* ---   Dependency   --- */
-#include <stddef.h>   /* size_t */
-
-
-/**
-  Introduction
-
-  lz4frame.h implements LZ4 frame specification (doc/lz4_Frame_format.md).
-  lz4frame.h provides frame compression functions that take care
-  of encoding standard metadata alongside LZ4-compressed blocks.
-*/
-
-/*-***************************************************************
- *  Compiler specifics
- *****************************************************************/
-/*  LZ4_DLL_EXPORT :
- *  Enable exporting of functions when building a Windows DLL
- *  LZ4FLIB_VISIBILITY :
- *  Control library symbols visibility.
- */
-#ifndef LZ4FLIB_VISIBILITY
-#  if defined(__GNUC__) && (__GNUC__ >= 4)
-#    define LZ4FLIB_VISIBILITY __attribute__ ((visibility ("default")))
-#  else
-#    define LZ4FLIB_VISIBILITY
-#  endif
-#endif
-#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
-#  define LZ4FLIB_API __declspec(dllexport) LZ4FLIB_VISIBILITY
-#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
-#  define LZ4FLIB_API __declspec(dllimport) LZ4FLIB_VISIBILITY
-#else
-#  define LZ4FLIB_API LZ4FLIB_VISIBILITY
-#endif
-
-#ifdef LZ4F_DISABLE_DEPRECATE_WARNINGS
-#  define LZ4F_DEPRECATE(x) x
-#else
-#  if defined(_MSC_VER)
-#    define LZ4F_DEPRECATE(x) x   /* __declspec(deprecated) x - only works with C++ */
-#  elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
-#    define LZ4F_DEPRECATE(x) x __attribute__((deprecated))
-#  else
-#    define LZ4F_DEPRECATE(x) x   /* no deprecation warning for this compiler */
-#  endif
-#endif
-
-
-/*-************************************
- *  Error management
- **************************************/
-typedef size_t LZ4F_errorCode_t;
-
-LZ4FLIB_API unsigned    LZ4F_isError(LZ4F_errorCode_t code);   /**< tells when a function result is an error code */
-LZ4FLIB_API const char* LZ4F_getErrorName(LZ4F_errorCode_t code);   /**< return error code string; for debugging */
-
-
-/*-************************************
- *  Frame compression types
- ************************************* */
-/* #define LZ4F_ENABLE_OBSOLETE_ENUMS   // uncomment to enable obsolete enums */
-#ifdef LZ4F_ENABLE_OBSOLETE_ENUMS
-#  define LZ4F_OBSOLETE_ENUM(x) , LZ4F_DEPRECATE(x) = LZ4F_##x
-#else
-#  define LZ4F_OBSOLETE_ENUM(x)
-#endif
-
-/* The larger the block size, the (slightly) better the compression ratio,
- * though there are diminishing returns.
- * Larger blocks also increase memory usage on both compression and decompression sides.
- */
-typedef enum {
-    LZ4F_default=0,
-    LZ4F_max64KB=4,
-    LZ4F_max256KB=5,
-    LZ4F_max1MB=6,
-    LZ4F_max4MB=7
-    LZ4F_OBSOLETE_ENUM(max64KB)
-    LZ4F_OBSOLETE_ENUM(max256KB)
-    LZ4F_OBSOLETE_ENUM(max1MB)
-    LZ4F_OBSOLETE_ENUM(max4MB)
-} LZ4F_blockSizeID_t;
-
-/* Linked blocks sharply reduce inefficiencies when using small blocks,
- * they compress better.
- * However, some LZ4 decoders are only compatible with independent blocks */
-typedef enum {
-    LZ4F_blockLinked=0,
-    LZ4F_blockIndependent
-    LZ4F_OBSOLETE_ENUM(blockLinked)
-    LZ4F_OBSOLETE_ENUM(blockIndependent)
-} LZ4F_blockMode_t;
-
-typedef enum {
-    LZ4F_noContentChecksum=0,
-    LZ4F_contentChecksumEnabled
-    LZ4F_OBSOLETE_ENUM(noContentChecksum)
-    LZ4F_OBSOLETE_ENUM(contentChecksumEnabled)
-} LZ4F_contentChecksum_t;
-
-typedef enum {
-    LZ4F_noBlockChecksum=0,
-    LZ4F_blockChecksumEnabled
-} LZ4F_blockChecksum_t;
-
-typedef enum {
-    LZ4F_frame=0,
-    LZ4F_skippableFrame
-    LZ4F_OBSOLETE_ENUM(skippableFrame)
-} LZ4F_frameType_t;
-
-#ifdef LZ4F_ENABLE_OBSOLETE_ENUMS
-typedef LZ4F_blockSizeID_t blockSizeID_t;
-typedef LZ4F_blockMode_t blockMode_t;
-typedef LZ4F_frameType_t frameType_t;
-typedef LZ4F_contentChecksum_t contentChecksum_t;
-#endif
-
-/*! LZ4F_frameInfo_t :
- *  makes it possible to set or read frame parameters.
- *  Structure must be first init to 0, using memset() or LZ4F_INIT_FRAMEINFO,
- *  setting all parameters to default.
- *  It's then possible to update selectively some parameters */
-typedef struct {
-  LZ4F_blockSizeID_t     blockSizeID;         /* max64KB, max256KB, max1MB, max4MB; 0 == default */
-  LZ4F_blockMode_t       blockMode;           /* LZ4F_blockLinked, LZ4F_blockIndependent; 0 == default */
-  LZ4F_contentChecksum_t contentChecksumFlag; /* 1: frame terminated with 32-bit checksum of decompressed data; 0: disabled (default) */
-  LZ4F_frameType_t       frameType;           /* read-only field : LZ4F_frame or LZ4F_skippableFrame */
-  unsigned long long     contentSize;         /* Size of uncompressed content ; 0 == unknown */
-  unsigned               dictID;              /* Dictionary ID, sent by compressor to help decoder select correct dictionary; 0 == no dictID provided */
-  LZ4F_blockChecksum_t   blockChecksumFlag;   /* 1: each block followed by a checksum of block's compressed data; 0: disabled (default) */
-} LZ4F_frameInfo_t;
-
-#define LZ4F_INIT_FRAMEINFO   { LZ4F_default, LZ4F_blockLinked, LZ4F_noContentChecksum, LZ4F_frame, 0ULL, 0U, LZ4F_noBlockChecksum }    /* v1.8.3+ */
-
-/*! LZ4F_preferences_t :
- *  makes it possible to supply advanced compression instructions to streaming interface.
- *  Structure must be first init to 0, using memset() or LZ4F_INIT_PREFERENCES,
- *  setting all parameters to default.
- *  All reserved fields must be set to zero. */
-typedef struct {
-  LZ4F_frameInfo_t frameInfo;
-  int      compressionLevel;    /* 0: default (fast mode); values > LZ4HC_CLEVEL_MAX count as LZ4HC_CLEVEL_MAX; values < 0 trigger "fast acceleration" */
-  unsigned autoFlush;           /* 1: always flush; reduces usage of internal buffers */
-  unsigned favorDecSpeed;       /* 1: parser favors decompression speed vs compression ratio. Only works for high compression modes (>= LZ4HC_CLEVEL_OPT_MIN) */  /* v1.8.2+ */
-  unsigned reserved[3];         /* must be zero for forward compatibility */
-} LZ4F_preferences_t;
-
-#define LZ4F_INIT_PREFERENCES   { LZ4F_INIT_FRAMEINFO, 0, 0u, 0u, { 0u, 0u, 0u } }    /* v1.8.3+ */
-
-
-/*-*********************************
-*  Simple compression function
-***********************************/
-
-LZ4FLIB_API int LZ4F_compressionLevel_max(void);   /* v1.8.0+ */
-
-/*! LZ4F_compressFrameBound() :
- *  Returns the maximum possible compressed size with LZ4F_compressFrame() given srcSize and preferences.
- * `preferencesPtr` is optional. It can be replaced by NULL, in which case, the function will assume default preferences.
- *  Note : this result is only usable with LZ4F_compressFrame().
- *         It may also be used with LZ4F_compressUpdate() _if no flush() operation_ is performed.
- */
-LZ4FLIB_API size_t LZ4F_compressFrameBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr);
-
-/*! LZ4F_compressFrame() :
- *  Compress an entire srcBuffer into a valid LZ4 frame.
- *  dstCapacity MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr).
- *  The LZ4F_preferences_t structure is optional : you can provide NULL as argument. All preferences will be set to default.
- * @return : number of bytes written into dstBuffer.
- *           or an error code if it fails (can be tested using LZ4F_isError())
- */
-LZ4FLIB_API size_t LZ4F_compressFrame(void* dstBuffer, size_t dstCapacity,
-                                const void* srcBuffer, size_t srcSize,
-                                const LZ4F_preferences_t* preferencesPtr);
-
-
-/*-***********************************
-*  Advanced compression functions
-*************************************/
-typedef struct LZ4F_cctx_s LZ4F_cctx;   /* incomplete type */
-typedef LZ4F_cctx* LZ4F_compressionContext_t;   /* for compatibility with previous API version */
-
-typedef struct {
-  unsigned stableSrc;    /* 1 == src content will remain present on future calls to LZ4F_compress(); skip copying src content within tmp buffer */
-  unsigned reserved[3];
-} LZ4F_compressOptions_t;
-
-/*---   Resource Management   ---*/
-
-#define LZ4F_VERSION 100    /* This number can be used to check for an incompatible API breaking change */
-LZ4FLIB_API unsigned LZ4F_getVersion(void);
-
-/*! LZ4F_createCompressionContext() :
- * The first thing to do is to create a compressionContext object, which will be used in all compression operations.
- * This is achieved using LZ4F_createCompressionContext(), which takes as argument a version.
- * The version provided MUST be LZ4F_VERSION. It is intended to track potential version mismatch, notably when using DLL.
- * The function will provide a pointer to a fully allocated LZ4F_cctx object.
- * If @return != zero, there was an error during context creation.
- * Object can release its memory using LZ4F_freeCompressionContext();
- */
-LZ4FLIB_API LZ4F_errorCode_t LZ4F_createCompressionContext(LZ4F_cctx** cctxPtr, unsigned version);
-LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_cctx* cctx);
-
-
-/*----    Compression    ----*/
-
-#define LZ4F_HEADER_SIZE_MIN  7   /* LZ4 Frame header size can vary, depending on selected paramaters */
-#define LZ4F_HEADER_SIZE_MAX 19
-
-/* Size in bytes of a block header in little-endian format. Highest bit indicates if block data is uncompressed */
-#define LZ4F_BLOCK_HEADER_SIZE 4
-
-/* Size in bytes of a block checksum footer in little-endian format. */
-#define LZ4F_BLOCK_CHECKSUM_SIZE 4
-
-/* Size in bytes of the content checksum. */
-#define LZ4F_CONTENT_CHECKSUM_SIZE 4
-
-/*! LZ4F_compressBegin() :
- *  will write the frame header into dstBuffer.
- *  dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes.
- * `prefsPtr` is optional : you can provide NULL as argument, all preferences will then be set to default.
- * @return : number of bytes written into dstBuffer for the header
- *           or an error code (which can be tested using LZ4F_isError())
- */
-LZ4FLIB_API size_t LZ4F_compressBegin(LZ4F_cctx* cctx,
-                                      void* dstBuffer, size_t dstCapacity,
-                                      const LZ4F_preferences_t* prefsPtr);
-
-/*! LZ4F_compressBound() :
- *  Provides minimum dstCapacity required to guarantee success of
- *  LZ4F_compressUpdate(), given a srcSize and preferences, for a worst case scenario.
- *  When srcSize==0, LZ4F_compressBound() provides an upper bound for LZ4F_flush() and LZ4F_compressEnd() instead.
- *  Note that the result is only valid for a single invocation of LZ4F_compressUpdate().
- *  When invoking LZ4F_compressUpdate() multiple times,
- *  if the output buffer is gradually filled up instead of emptied and re-used from its start,
- *  one must check if there is enough remaining capacity before each invocation, using LZ4F_compressBound().
- * @return is always the same for a srcSize and prefsPtr.
- *  prefsPtr is optional : when NULL is provided, preferences will be set to cover worst case scenario.
- *  tech details :
- * @return if automatic flushing is not enabled, includes the possibility that internal buffer might already be filled by up to (blockSize-1) bytes.
- *  It also includes frame footer (ending + checksum), since it might be generated by LZ4F_compressEnd().
- * @return doesn't include frame header, as it was already generated by LZ4F_compressBegin().
- */
-LZ4FLIB_API size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* prefsPtr);
-
-/*! LZ4F_compressUpdate() :
- *  LZ4F_compressUpdate() can be called repetitively to compress as much data as necessary.
- *  Important rule: dstCapacity MUST be large enough to ensure operation success even in worst case situations.
- *  This value is provided by LZ4F_compressBound().
- *  If this condition is not respected, LZ4F_compress() will fail (result is an errorCode).
- *  LZ4F_compressUpdate() doesn't guarantee error recovery.
- *  When an error occurs, compression context must be freed or resized.
- * `cOptPtr` is optional : NULL can be provided, in which case all options are set to default.
- * @return : number of bytes written into `dstBuffer` (it can be zero, meaning input data was just buffered).
- *           or an error code if it fails (which can be tested using LZ4F_isError())
- */
-LZ4FLIB_API size_t LZ4F_compressUpdate(LZ4F_cctx* cctx,
-                                       void* dstBuffer, size_t dstCapacity,
-                                 const void* srcBuffer, size_t srcSize,
-                                 const LZ4F_compressOptions_t* cOptPtr);
-
-/*! LZ4F_flush() :
- *  When data must be generated and sent immediately, without waiting for a block to be completely filled,
- *  it's possible to call LZ4_flush(). It will immediately compress any data buffered within cctx.
- * `dstCapacity` must be large enough to ensure the operation will be successful.
- * `cOptPtr` is optional : it's possible to provide NULL, all options will be set to default.
- * @return : nb of bytes written into dstBuffer (can be zero, when there is no data stored within cctx)
- *           or an error code if it fails (which can be tested using LZ4F_isError())
- *  Note : LZ4F_flush() is guaranteed to be successful when dstCapacity >= LZ4F_compressBound(0, prefsPtr).
- */
-LZ4FLIB_API size_t LZ4F_flush(LZ4F_cctx* cctx,
-                              void* dstBuffer, size_t dstCapacity,
-                        const LZ4F_compressOptions_t* cOptPtr);
-
-/*! LZ4F_compressEnd() :
- *  To properly finish an LZ4 frame, invoke LZ4F_compressEnd().
- *  It will flush whatever data remained within `cctx` (like LZ4_flush())
- *  and properly finalize the frame, with an endMark and a checksum.
- * `cOptPtr` is optional : NULL can be provided, in which case all options will be set to default.
- * @return : nb of bytes written into dstBuffer, necessarily >= 4 (endMark),
- *           or an error code if it fails (which can be tested using LZ4F_isError())
- *  Note : LZ4F_compressEnd() is guaranteed to be successful when dstCapacity >= LZ4F_compressBound(0, prefsPtr).
- *  A successful call to LZ4F_compressEnd() makes `cctx` available again for another compression task.
- */
-LZ4FLIB_API size_t LZ4F_compressEnd(LZ4F_cctx* cctx,
-                                    void* dstBuffer, size_t dstCapacity,
-                              const LZ4F_compressOptions_t* cOptPtr);
-
-
-/*-*********************************
-*  Decompression functions
-***********************************/
-typedef struct LZ4F_dctx_s LZ4F_dctx;   /* incomplete type */
-typedef LZ4F_dctx* LZ4F_decompressionContext_t;   /* compatibility with previous API versions */
-
-typedef struct {
-  unsigned stableDst;    /* pledges that last 64KB decompressed data will remain available unmodified. This optimization skips storage operations in tmp buffers. */
-  unsigned reserved[3];  /* must be set to zero for forward compatibility */
-} LZ4F_decompressOptions_t;
-
-
-/* Resource management */
-
-/*! LZ4F_createDecompressionContext() :
- *  Create an LZ4F_dctx object, to track all decompression operations.
- *  The version provided MUST be LZ4F_VERSION.
- *  The function provides a pointer to an allocated and initialized LZ4F_dctx object.
- *  The result is an errorCode, which can be tested using LZ4F_isError().
- *  dctx memory can be released using LZ4F_freeDecompressionContext();
- *  Result of LZ4F_freeDecompressionContext() indicates current state of decompressionContext when being released.
- *  That is, it should be == 0 if decompression has been completed fully and correctly.
- */
-LZ4FLIB_API LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_dctx** dctxPtr, unsigned version);
-LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_dctx* dctx);
-
-
-/*-***********************************
-*  Streaming decompression functions
-*************************************/
-
-#define LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH 5
-
-/*! LZ4F_headerSize() : v1.9.0+
- *  Provide the header size of a frame starting at `src`.
- * `srcSize` must be >= LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH,
- *  which is enough to decode the header length.
- * @return : size of frame header
- *           or an error code, which can be tested using LZ4F_isError()
- *  note : Frame header size is variable, but is guaranteed to be
- *         >= LZ4F_HEADER_SIZE_MIN bytes, and <= LZ4F_HEADER_SIZE_MAX bytes.
- */
-LZ4FLIB_API size_t LZ4F_headerSize(const void* src, size_t srcSize);
-
-/*! LZ4F_getFrameInfo() :
- *  This function extracts frame parameters (max blockSize, dictID, etc.).
- *  Its usage is optional: user can call LZ4F_decompress() directly.
- *
- *  Extracted information will fill an existing LZ4F_frameInfo_t structure.
- *  This can be useful for allocation and dictionary identification purposes.
- *
- *  LZ4F_getFrameInfo() can work in the following situations :
- *
- *  1) At the beginning of a new frame, before any invocation of LZ4F_decompress().
- *     It will decode header from `srcBuffer`,
- *     consuming the header and starting the decoding process.
- *
- *     Input size must be large enough to contain the full frame header.
- *     Frame header size can be known beforehand by LZ4F_headerSize().
- *     Frame header size is variable, but is guaranteed to be >= LZ4F_HEADER_SIZE_MIN bytes,
- *     and not more than <= LZ4F_HEADER_SIZE_MAX bytes.
- *     Hence, blindly providing LZ4F_HEADER_SIZE_MAX bytes or more will always work.
- *     It's allowed to provide more input data than the header size,
- *     LZ4F_getFrameInfo() will only consume the header.
- *
- *     If input size is not large enough,
- *     aka if it's smaller than header size,
- *     function will fail and return an error code.
- *
- *  2) After decoding has been started,
- *     it's possible to invoke LZ4F_getFrameInfo() anytime
- *     to extract already decoded frame parameters stored within dctx.
- *
- *     Note that, if decoding has barely started,
- *     and not yet read enough information to decode the header,
- *     LZ4F_getFrameInfo() will fail.
- *
- *  The number of bytes consumed from srcBuffer will be updated in *srcSizePtr (necessarily <= original value).
- *  LZ4F_getFrameInfo() only consumes bytes when decoding has not yet started,
- *  and when decoding the header has been successful.
- *  Decompression must then resume from (srcBuffer + *srcSizePtr).
- *
- * @return : a hint about how many srcSize bytes LZ4F_decompress() expects for next call,
- *           or an error code which can be tested using LZ4F_isError().
- *  note 1 : in case of error, dctx is not modified. Decoding operation can resume from beginning safely.
- *  note 2 : frame parameters are *copied into* an already allocated LZ4F_frameInfo_t structure.
- */
-LZ4FLIB_API size_t LZ4F_getFrameInfo(LZ4F_dctx* dctx,
-                                     LZ4F_frameInfo_t* frameInfoPtr,
-                                     const void* srcBuffer, size_t* srcSizePtr);
-
-/*! LZ4F_decompress() :
- *  Call this function repetitively to regenerate data compressed in `srcBuffer`.
- *
- *  The function requires a valid dctx state.
- *  It will read up to *srcSizePtr bytes from srcBuffer,
- *  and decompress data into dstBuffer, of capacity *dstSizePtr.
- *
- *  The nb of bytes consumed from srcBuffer will be written into *srcSizePtr (necessarily <= original value).
- *  The nb of bytes decompressed into dstBuffer will be written into *dstSizePtr (necessarily <= original value).
- *
- *  The function does not necessarily read all input bytes, so always check value in *srcSizePtr.
- *  Unconsumed source data must be presented again in subsequent invocations.
- *
- * `dstBuffer` can freely change between each consecutive function invocation.
- * `dstBuffer` content will be overwritten.
- *
- * @return : an hint of how many `srcSize` bytes LZ4F_decompress() expects for next call.
- *  Schematically, it's the size of the current (or remaining) compressed block + header of next block.
- *  Respecting the hint provides some small speed benefit, because it skips intermediate buffers.
- *  This is just a hint though, it's always possible to provide any srcSize.
- *
- *  When a frame is fully decoded, @return will be 0 (no more data expected).
- *  When provided with more bytes than necessary to decode a frame,
- *  LZ4F_decompress() will stop reading exactly at end of current frame, and @return 0.
- *
- *  If decompression failed, @return is an error code, which can be tested using LZ4F_isError().
- *  After a decompression error, the `dctx` context is not resumable.
- *  Use LZ4F_resetDecompressionContext() to return to clean state.
- *
- *  After a frame is fully decoded, dctx can be used again to decompress another frame.
- */
-LZ4FLIB_API size_t LZ4F_decompress(LZ4F_dctx* dctx,
-                                   void* dstBuffer, size_t* dstSizePtr,
-                                   const void* srcBuffer, size_t* srcSizePtr,
-                                   const LZ4F_decompressOptions_t* dOptPtr);
-
-
-/*! LZ4F_resetDecompressionContext() : added in v1.8.0
- *  In case of an error, the context is left in "undefined" state.
- *  In which case, it's necessary to reset it, before re-using it.
- *  This method can also be used to abruptly stop any unfinished decompression,
- *  and start a new one using same context resources. */
-LZ4FLIB_API void LZ4F_resetDecompressionContext(LZ4F_dctx* dctx);   /* always successful */
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* LZ4F_H_09782039843 */
-
-#if defined(LZ4F_STATIC_LINKING_ONLY) && !defined(LZ4F_H_STATIC_09782039843)
-#define LZ4F_H_STATIC_09782039843
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* These declarations are not stable and may change in the future.
- * They are therefore only safe to depend on
- * when the caller is statically linked against the library.
- * To access their declarations, define LZ4F_STATIC_LINKING_ONLY.
- *
- * By default, these symbols aren't published into shared/dynamic libraries.
- * You can override this behavior and force them to be published
- * by defining LZ4F_PUBLISH_STATIC_FUNCTIONS.
- * Use at your own risk.
- */
-#ifdef LZ4F_PUBLISH_STATIC_FUNCTIONS
-# define LZ4FLIB_STATIC_API LZ4FLIB_API
-#else
-# define LZ4FLIB_STATIC_API
-#endif
-
-
-/* ---   Error List   --- */
-#define LZ4F_LIST_ERRORS(ITEM) \
-        ITEM(OK_NoError) \
-        ITEM(ERROR_GENERIC) \
-        ITEM(ERROR_maxBlockSize_invalid) \
-        ITEM(ERROR_blockMode_invalid) \
-        ITEM(ERROR_contentChecksumFlag_invalid) \
-        ITEM(ERROR_compressionLevel_invalid) \
-        ITEM(ERROR_headerVersion_wrong) \
-        ITEM(ERROR_blockChecksum_invalid) \
-        ITEM(ERROR_reservedFlag_set) \
-        ITEM(ERROR_allocation_failed) \
-        ITEM(ERROR_srcSize_tooLarge) \
-        ITEM(ERROR_dstMaxSize_tooSmall) \
-        ITEM(ERROR_frameHeader_incomplete) \
-        ITEM(ERROR_frameType_unknown) \
-        ITEM(ERROR_frameSize_wrong) \
-        ITEM(ERROR_srcPtr_wrong) \
-        ITEM(ERROR_decompressionFailed) \
-        ITEM(ERROR_headerChecksum_invalid) \
-        ITEM(ERROR_contentChecksum_invalid) \
-        ITEM(ERROR_frameDecoding_alreadyStarted) \
-        ITEM(ERROR_maxCode)
-
-#define LZ4F_GENERATE_ENUM(ENUM) LZ4F_##ENUM,
-
-/* enum list is exposed, to handle specific errors */
-typedef enum { LZ4F_LIST_ERRORS(LZ4F_GENERATE_ENUM)
-              _LZ4F_dummy_error_enum_for_c89_never_used } LZ4F_errorCodes;
-
-LZ4FLIB_STATIC_API LZ4F_errorCodes LZ4F_getErrorCode(size_t functionResult);
-
-LZ4FLIB_STATIC_API size_t LZ4F_getBlockSize(unsigned);
-
-/**********************************
- *  Bulk processing dictionary API
- *********************************/
-
-/* A Dictionary is useful for the compression of small messages (KB range).
- * It dramatically improves compression efficiency.
- *
- * LZ4 can ingest any input as dictionary, though only the last 64 KB are useful.
- * Best results are generally achieved by using Zstandard's Dictionary Builder
- * to generate a high-quality dictionary from a set of samples.
- *
- * Loading a dictionary has a cost, since it involves construction of tables.
- * The Bulk processing dictionary API makes it possible to share this cost
- * over an arbitrary number of compression jobs, even concurrently,
- * markedly improving compression latency for these cases.
- *
- * The same dictionary will have to be used on the decompression side
- * for decoding to be successful.
- * To help identify the correct dictionary at decoding stage,
- * the frame header allows optional embedding of a dictID field.
- */
-typedef struct LZ4F_CDict_s LZ4F_CDict;
-
-/*! LZ4_createCDict() :
- *  When compressing multiple messages / blocks using the same dictionary, it's recommended to load it just once.
- *  LZ4_createCDict() will create a digested dictionary, ready to start future compression operations without startup delay.
- *  LZ4_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only.
- * `dictBuffer` can be released after LZ4_CDict creation, since its content is copied within CDict */
-LZ4FLIB_STATIC_API LZ4F_CDict* LZ4F_createCDict(const void* dictBuffer, size_t dictSize);
-LZ4FLIB_STATIC_API void        LZ4F_freeCDict(LZ4F_CDict* CDict);
-
-
-/*! LZ4_compressFrame_usingCDict() :
- *  Compress an entire srcBuffer into a valid LZ4 frame using a digested Dictionary.
- *  cctx must point to a context created by LZ4F_createCompressionContext().
- *  If cdict==NULL, compress without a dictionary.
- *  dstBuffer MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr).
- *  If this condition is not respected, function will fail (@return an errorCode).
- *  The LZ4F_preferences_t structure is optional : you may provide NULL as argument,
- *  but it's not recommended, as it's the only way to provide dictID in the frame header.
- * @return : number of bytes written into dstBuffer.
- *           or an error code if it fails (can be tested using LZ4F_isError()) */
-LZ4FLIB_STATIC_API size_t LZ4F_compressFrame_usingCDict(
-    LZ4F_cctx* cctx,
-    void* dst, size_t dstCapacity,
-    const void* src, size_t srcSize,
-    const LZ4F_CDict* cdict,
-    const LZ4F_preferences_t* preferencesPtr);
-
-
-/*! LZ4F_compressBegin_usingCDict() :
- *  Inits streaming dictionary compression, and writes the frame header into dstBuffer.
- *  dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes.
- * `prefsPtr` is optional : you may provide NULL as argument,
- *  however, it's the only way to provide dictID in the frame header.
- * @return : number of bytes written into dstBuffer for the header,
- *           or an error code (which can be tested using LZ4F_isError()) */
-LZ4FLIB_STATIC_API size_t LZ4F_compressBegin_usingCDict(
-    LZ4F_cctx* cctx,
-    void* dstBuffer, size_t dstCapacity,
-    const LZ4F_CDict* cdict,
-    const LZ4F_preferences_t* prefsPtr);
-
-
-/*! LZ4F_decompress_usingDict() :
- *  Same as LZ4F_decompress(), using a predefined dictionary.
- *  Dictionary is used "in place", without any preprocessing.
- *  It must remain accessible throughout the entire frame decoding. */
-LZ4FLIB_STATIC_API size_t LZ4F_decompress_usingDict(
-    LZ4F_dctx* dctxPtr,
-    void* dstBuffer, size_t* dstSizePtr,
-    const void* srcBuffer, size_t* srcSizePtr,
-    const void* dict, size_t dictSize,
-    const LZ4F_decompressOptions_t* decompressOptionsPtr);
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* defined(LZ4F_STATIC_LINKING_ONLY) && !defined(LZ4F_H_STATIC_09782039843) */
diff --git a/thirdparty/lz4/lz4frame_static.h b/thirdparty/lz4/lz4frame_static.h
deleted file mode 100644
index 2b44a63..0000000
--- a/thirdparty/lz4/lz4frame_static.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
-   LZ4 auto-framing library
-   Header File for static linking only
-   Copyright (C) 2011-2020, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - LZ4 source repository : https://github.com/lz4/lz4
-   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-#ifndef LZ4FRAME_STATIC_H_0398209384
-#define LZ4FRAME_STATIC_H_0398209384
-
-/* The declarations that formerly were made here have been merged into
- * lz4frame.h, protected by the LZ4F_STATIC_LINKING_ONLY macro. Going forward,
- * it is recommended to simply include that header directly.
- */
-
-#define LZ4F_STATIC_LINKING_ONLY
-#include "lz4frame.h"
-
-#endif /* LZ4FRAME_STATIC_H_0398209384 */
diff --git a/thirdparty/lz4/lz4hc.c b/thirdparty/lz4/lz4hc.c
deleted file mode 100644
index feee612..0000000
--- a/thirdparty/lz4/lz4hc.c
+++ /dev/null
@@ -1,1615 +0,0 @@
-/*
-    LZ4 HC - High Compression Mode of LZ4
-    Copyright (C) 2011-2020, Yann Collet.
-
-    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-
-    * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-    copyright notice, this list of conditions and the following disclaimer
-    in the documentation and/or other materials provided with the
-    distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-       - LZ4 source repository : https://github.com/lz4/lz4
-       - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-/* note : lz4hc is not an independent module, it requires lz4.h/lz4.c for proper compilation */
-
-
-/* *************************************
-*  Tuning Parameter
-***************************************/
-
-/*! HEAPMODE :
- *  Select how default compression function will allocate workplace memory,
- *  in stack (0:fastest), or in heap (1:requires malloc()).
- *  Since workplace is rather large, heap mode is recommended.
- */
-#ifndef LZ4HC_HEAPMODE
-#  define LZ4HC_HEAPMODE 1
-#endif
-
-
-/*===    Dependency    ===*/
-#define LZ4_HC_STATIC_LINKING_ONLY
-#include "lz4hc.h"
-
-
-/*===   Common definitions   ===*/
-#if defined(__GNUC__)
-#  pragma GCC diagnostic ignored "-Wunused-function"
-#endif
-#if defined (__clang__)
-#  pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
-#define LZ4_COMMONDEFS_ONLY
-#ifndef LZ4_SRC_INCLUDED
-#include "lz4.c"   /* LZ4_count, constants, mem */
-#endif
-
-
-/*===   Enums   ===*/
-typedef enum { noDictCtx, usingDictCtxHc } dictCtx_directive;
-
-
-/*===   Constants   ===*/
-#define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH)
-#define LZ4_OPT_NUM   (1<<12)
-
-
-/*===   Macros   ===*/
-#define MIN(a,b)   ( (a) < (b) ? (a) : (b) )
-#define MAX(a,b)   ( (a) > (b) ? (a) : (b) )
-#define HASH_FUNCTION(i)         (((i) * 2654435761U) >> ((MINMATCH*8)-LZ4HC_HASH_LOG))
-#define DELTANEXTMAXD(p)         chainTable[(p) & LZ4HC_MAXD_MASK]    /* flexible, LZ4HC_MAXD dependent */
-#define DELTANEXTU16(table, pos) table[(U16)(pos)]   /* faster */
-/* Make fields passed to, and updated by LZ4HC_encodeSequence explicit */
-#define UPDATABLE(ip, op, anchor) &ip, &op, &anchor
-
-static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)); }
-
-
-/**************************************
-*  HC Compression
-**************************************/
-static void LZ4HC_clearTables (LZ4HC_CCtx_internal* hc4)
-{
-    MEM_INIT(hc4->hashTable, 0, sizeof(hc4->hashTable));
-    MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable));
-}
-
-static void LZ4HC_init_internal (LZ4HC_CCtx_internal* hc4, const BYTE* start)
-{
-    uptrval startingOffset = (uptrval)(hc4->end - hc4->base);
-    if (startingOffset > 1 GB) {
-        LZ4HC_clearTables(hc4);
-        startingOffset = 0;
-    }
-    startingOffset += 64 KB;
-    hc4->nextToUpdate = (U32) startingOffset;
-    hc4->base = start - startingOffset;
-    hc4->end = start;
-    hc4->dictBase = start - startingOffset;
-    hc4->dictLimit = (U32) startingOffset;
-    hc4->lowLimit = (U32) startingOffset;
-}
-
-
-/* Update chains up to ip (excluded) */
-LZ4_FORCE_INLINE void LZ4HC_Insert (LZ4HC_CCtx_internal* hc4, const BYTE* ip)
-{
-    U16* const chainTable = hc4->chainTable;
-    U32* const hashTable  = hc4->hashTable;
-    const BYTE* const base = hc4->base;
-    U32 const target = (U32)(ip - base);
-    U32 idx = hc4->nextToUpdate;
-
-    while (idx < target) {
-        U32 const h = LZ4HC_hashPtr(base+idx);
-        size_t delta = idx - hashTable[h];
-        if (delta>LZ4_DISTANCE_MAX) delta = LZ4_DISTANCE_MAX;
-        DELTANEXTU16(chainTable, idx) = (U16)delta;
-        hashTable[h] = idx;
-        idx++;
-    }
-
-    hc4->nextToUpdate = target;
-}
-
-/** LZ4HC_countBack() :
- * @return : negative value, nb of common bytes before ip/match */
-LZ4_FORCE_INLINE
-int LZ4HC_countBack(const BYTE* const ip, const BYTE* const match,
-                    const BYTE* const iMin, const BYTE* const mMin)
-{
-    int back = 0;
-    int const min = (int)MAX(iMin - ip, mMin - match);
-    assert(min <= 0);
-    assert(ip >= iMin); assert((size_t)(ip-iMin) < (1U<<31));
-    assert(match >= mMin); assert((size_t)(match - mMin) < (1U<<31));
-    while ( (back > min)
-         && (ip[back-1] == match[back-1]) )
-            back--;
-    return back;
-}
-
-#if defined(_MSC_VER)
-#  define LZ4HC_rotl32(x,r) _rotl(x,r)
-#else
-#  define LZ4HC_rotl32(x,r) ((x << r) | (x >> (32 - r)))
-#endif
-
-
-static U32 LZ4HC_rotatePattern(size_t const rotate, U32 const pattern)
-{
-    size_t const bitsToRotate = (rotate & (sizeof(pattern) - 1)) << 3;
-    if (bitsToRotate == 0) return pattern;
-    return LZ4HC_rotl32(pattern, (int)bitsToRotate);
-}
-
-/* LZ4HC_countPattern() :
- * pattern32 must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!) */
-static unsigned
-LZ4HC_countPattern(const BYTE* ip, const BYTE* const iEnd, U32 const pattern32)
-{
-    const BYTE* const iStart = ip;
-    reg_t const pattern = (sizeof(pattern)==8) ?
-        (reg_t)pattern32 + (((reg_t)pattern32) << (sizeof(pattern)*4)) : pattern32;
-
-    while (likely(ip < iEnd-(sizeof(pattern)-1))) {
-        reg_t const diff = LZ4_read_ARCH(ip) ^ pattern;
-        if (!diff) { ip+=sizeof(pattern); continue; }
-        ip += LZ4_NbCommonBytes(diff);
-        return (unsigned)(ip - iStart);
-    }
-
-    if (LZ4_isLittleEndian()) {
-        reg_t patternByte = pattern;
-        while ((ip<iEnd) && (*ip == (BYTE)patternByte)) {
-            ip++; patternByte >>= 8;
-        }
-    } else {  /* big endian */
-        U32 bitOffset = (sizeof(pattern)*8) - 8;
-        while (ip < iEnd) {
-            BYTE const byte = (BYTE)(pattern >> bitOffset);
-            if (*ip != byte) break;
-            ip ++; bitOffset -= 8;
-        }
-    }
-
-    return (unsigned)(ip - iStart);
-}
-
-/* LZ4HC_reverseCountPattern() :
- * pattern must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!)
- * read using natural platform endianess */
-static unsigned
-LZ4HC_reverseCountPattern(const BYTE* ip, const BYTE* const iLow, U32 pattern)
-{
-    const BYTE* const iStart = ip;
-
-    while (likely(ip >= iLow+4)) {
-        if (LZ4_read32(ip-4) != pattern) break;
-        ip -= 4;
-    }
-    {   const BYTE* bytePtr = (const BYTE*)(&pattern) + 3; /* works for any endianess */
-        while (likely(ip>iLow)) {
-            if (ip[-1] != *bytePtr) break;
-            ip--; bytePtr--;
-    }   }
-    return (unsigned)(iStart - ip);
-}
-
-/* LZ4HC_protectDictEnd() :
- * Checks if the match is in the last 3 bytes of the dictionary, so reading the
- * 4 byte MINMATCH would overflow.
- * @returns true if the match index is okay.
- */
-static int LZ4HC_protectDictEnd(U32 const dictLimit, U32 const matchIndex)
-{
-    return ((U32)((dictLimit - 1) - matchIndex) >= 3);
-}
-
-typedef enum { rep_untested, rep_not, rep_confirmed } repeat_state_e;
-typedef enum { favorCompressionRatio=0, favorDecompressionSpeed } HCfavor_e;
-
-LZ4_FORCE_INLINE int
-LZ4HC_InsertAndGetWiderMatch (
-    LZ4HC_CCtx_internal* hc4,
-    const BYTE* const ip,
-    const BYTE* const iLowLimit,
-    const BYTE* const iHighLimit,
-    int longest,
-    const BYTE** matchpos,
-    const BYTE** startpos,
-    const int maxNbAttempts,
-    const int patternAnalysis,
-    const int chainSwap,
-    const dictCtx_directive dict,
-    const HCfavor_e favorDecSpeed)
-{
-    U16* const chainTable = hc4->chainTable;
-    U32* const HashTable = hc4->hashTable;
-    const LZ4HC_CCtx_internal * const dictCtx = hc4->dictCtx;
-    const BYTE* const base = hc4->base;
-    const U32 dictLimit = hc4->dictLimit;
-    const BYTE* const lowPrefixPtr = base + dictLimit;
-    const U32 ipIndex = (U32)(ip - base);
-    const U32 lowestMatchIndex = (hc4->lowLimit + (LZ4_DISTANCE_MAX + 1) > ipIndex) ? hc4->lowLimit : ipIndex - LZ4_DISTANCE_MAX;
-    const BYTE* const dictBase = hc4->dictBase;
-    int const lookBackLength = (int)(ip-iLowLimit);
-    int nbAttempts = maxNbAttempts;
-    U32 matchChainPos = 0;
-    U32 const pattern = LZ4_read32(ip);
-    U32 matchIndex;
-    repeat_state_e repeat = rep_untested;
-    size_t srcPatternLength = 0;
-
-    DEBUGLOG(7, "LZ4HC_InsertAndGetWiderMatch");
-    /* First Match */
-    LZ4HC_Insert(hc4, ip);
-    matchIndex = HashTable[LZ4HC_hashPtr(ip)];
-    DEBUGLOG(7, "First match at index %u / %u (lowestMatchIndex)",
-                matchIndex, lowestMatchIndex);
-
-    while ((matchIndex>=lowestMatchIndex) && (nbAttempts>0)) {
-        int matchLength=0;
-        nbAttempts--;
-        assert(matchIndex < ipIndex);
-        if (favorDecSpeed && (ipIndex - matchIndex < 8)) {
-            /* do nothing */
-        } else if (matchIndex >= dictLimit) {   /* within current Prefix */
-            const BYTE* const matchPtr = base + matchIndex;
-            assert(matchPtr >= lowPrefixPtr);
-            assert(matchPtr < ip);
-            assert(longest >= 1);
-            if (LZ4_read16(iLowLimit + longest - 1) == LZ4_read16(matchPtr - lookBackLength + longest - 1)) {
-                if (LZ4_read32(matchPtr) == pattern) {
-                    int const back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, lowPrefixPtr) : 0;
-                    matchLength = MINMATCH + (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, iHighLimit);
-                    matchLength -= back;
-                    if (matchLength > longest) {
-                        longest = matchLength;
-                        *matchpos = matchPtr + back;
-                        *startpos = ip + back;
-            }   }   }
-        } else {   /* lowestMatchIndex <= matchIndex < dictLimit */
-            const BYTE* const matchPtr = dictBase + matchIndex;
-            if (LZ4_read32(matchPtr) == pattern) {
-                const BYTE* const dictStart = dictBase + hc4->lowLimit;
-                int back = 0;
-                const BYTE* vLimit = ip + (dictLimit - matchIndex);
-                if (vLimit > iHighLimit) vLimit = iHighLimit;
-                matchLength = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;
-                if ((ip+matchLength == vLimit) && (vLimit < iHighLimit))
-                    matchLength += LZ4_count(ip+matchLength, lowPrefixPtr, iHighLimit);
-                back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictStart) : 0;
-                matchLength -= back;
-                if (matchLength > longest) {
-                    longest = matchLength;
-                    *matchpos = base + matchIndex + back;   /* virtual pos, relative to ip, to retrieve offset */
-                    *startpos = ip + back;
-        }   }   }
-
-        if (chainSwap && matchLength==longest) {    /* better match => select a better chain */
-            assert(lookBackLength==0);   /* search forward only */
-            if (matchIndex + (U32)longest <= ipIndex) {
-                int const kTrigger = 4;
-                U32 distanceToNextMatch = 1;
-                int const end = longest - MINMATCH + 1;
-                int step = 1;
-                int accel = 1 << kTrigger;
-                int pos;
-                for (pos = 0; pos < end; pos += step) {
-                    U32 const candidateDist = DELTANEXTU16(chainTable, matchIndex + (U32)pos);
-                    step = (accel++ >> kTrigger);
-                    if (candidateDist > distanceToNextMatch) {
-                        distanceToNextMatch = candidateDist;
-                        matchChainPos = (U32)pos;
-                        accel = 1 << kTrigger;
-                    }
-                }
-                if (distanceToNextMatch > 1) {
-                    if (distanceToNextMatch > matchIndex) break;   /* avoid overflow */
-                    matchIndex -= distanceToNextMatch;
-                    continue;
-        }   }   }
-
-        {   U32 const distNextMatch = DELTANEXTU16(chainTable, matchIndex);
-            if (patternAnalysis && distNextMatch==1 && matchChainPos==0) {
-                U32 const matchCandidateIdx = matchIndex-1;
-                /* may be a repeated pattern */
-                if (repeat == rep_untested) {
-                    if ( ((pattern & 0xFFFF) == (pattern >> 16))
-                      &  ((pattern & 0xFF)   == (pattern >> 24)) ) {
-                        repeat = rep_confirmed;
-                        srcPatternLength = LZ4HC_countPattern(ip+sizeof(pattern), iHighLimit, pattern) + sizeof(pattern);
-                    } else {
-                        repeat = rep_not;
-                }   }
-                if ( (repeat == rep_confirmed) && (matchCandidateIdx >= lowestMatchIndex)
-                  && LZ4HC_protectDictEnd(dictLimit, matchCandidateIdx) ) {
-                    const int extDict = matchCandidateIdx < dictLimit;
-                    const BYTE* const matchPtr = (extDict ? dictBase : base) + matchCandidateIdx;
-                    if (LZ4_read32(matchPtr) == pattern) {  /* good candidate */
-                        const BYTE* const dictStart = dictBase + hc4->lowLimit;
-                        const BYTE* const iLimit = extDict ? dictBase + dictLimit : iHighLimit;
-                        size_t forwardPatternLength = LZ4HC_countPattern(matchPtr+sizeof(pattern), iLimit, pattern) + sizeof(pattern);
-                        if (extDict && matchPtr + forwardPatternLength == iLimit) {
-                            U32 const rotatedPattern = LZ4HC_rotatePattern(forwardPatternLength, pattern);
-                            forwardPatternLength += LZ4HC_countPattern(lowPrefixPtr, iHighLimit, rotatedPattern);
-                        }
-                        {   const BYTE* const lowestMatchPtr = extDict ? dictStart : lowPrefixPtr;
-                            size_t backLength = LZ4HC_reverseCountPattern(matchPtr, lowestMatchPtr, pattern);
-                            size_t currentSegmentLength;
-                            if (!extDict && matchPtr - backLength == lowPrefixPtr && hc4->lowLimit < dictLimit) {
-                                U32 const rotatedPattern = LZ4HC_rotatePattern((U32)(-(int)backLength), pattern);
-                                backLength += LZ4HC_reverseCountPattern(dictBase + dictLimit, dictStart, rotatedPattern);
-                            }
-                            /* Limit backLength not go further than lowestMatchIndex */
-                            backLength = matchCandidateIdx - MAX(matchCandidateIdx - (U32)backLength, lowestMatchIndex);
-                            assert(matchCandidateIdx - backLength >= lowestMatchIndex);
-                            currentSegmentLength = backLength + forwardPatternLength;
-                            /* Adjust to end of pattern if the source pattern fits, otherwise the beginning of the pattern */
-                            if ( (currentSegmentLength >= srcPatternLength)   /* current pattern segment large enough to contain full srcPatternLength */
-                              && (forwardPatternLength <= srcPatternLength) ) { /* haven't reached this position yet */
-                                U32 const newMatchIndex = matchCandidateIdx + (U32)forwardPatternLength - (U32)srcPatternLength;  /* best position, full pattern, might be followed by more match */
-                                if (LZ4HC_protectDictEnd(dictLimit, newMatchIndex))
-                                    matchIndex = newMatchIndex;
-                                else {
-                                    /* Can only happen if started in the prefix */
-                                    assert(newMatchIndex >= dictLimit - 3 && newMatchIndex < dictLimit && !extDict);
-                                    matchIndex = dictLimit;
-                                }
-                            } else {
-                                U32 const newMatchIndex = matchCandidateIdx - (U32)backLength;   /* farthest position in current segment, will find a match of length currentSegmentLength + maybe some back */
-                                if (!LZ4HC_protectDictEnd(dictLimit, newMatchIndex)) {
-                                    assert(newMatchIndex >= dictLimit - 3 && newMatchIndex < dictLimit && !extDict);
-                                    matchIndex = dictLimit;
-                                } else {
-                                    matchIndex = newMatchIndex;
-                                    if (lookBackLength==0) {  /* no back possible */
-                                        size_t const maxML = MIN(currentSegmentLength, srcPatternLength);
-                                        if ((size_t)longest < maxML) {
-                                            assert(base + matchIndex != ip);
-                                            if ((size_t)(ip - base) - matchIndex > LZ4_DISTANCE_MAX) break;
-                                            assert(maxML < 2 GB);
-                                            longest = (int)maxML;
-                                            *matchpos = base + matchIndex;   /* virtual pos, relative to ip, to retrieve offset */
-                                            *startpos = ip;
-                                        }
-                                        {   U32 const distToNextPattern = DELTANEXTU16(chainTable, matchIndex);
-                                            if (distToNextPattern > matchIndex) break;  /* avoid overflow */
-                                            matchIndex -= distToNextPattern;
-                        }   }   }   }   }
-                        continue;
-                }   }
-        }   }   /* PA optimization */
-
-        /* follow current chain */
-        matchIndex -= DELTANEXTU16(chainTable, matchIndex + matchChainPos);
-
-    }  /* while ((matchIndex>=lowestMatchIndex) && (nbAttempts)) */
-
-    if ( dict == usingDictCtxHc
-      && nbAttempts > 0
-      && ipIndex - lowestMatchIndex < LZ4_DISTANCE_MAX) {
-        size_t const dictEndOffset = (size_t)(dictCtx->end - dictCtx->base);
-        U32 dictMatchIndex = dictCtx->hashTable[LZ4HC_hashPtr(ip)];
-        assert(dictEndOffset <= 1 GB);
-        matchIndex = dictMatchIndex + lowestMatchIndex - (U32)dictEndOffset;
-        while (ipIndex - matchIndex <= LZ4_DISTANCE_MAX && nbAttempts--) {
-            const BYTE* const matchPtr = dictCtx->base + dictMatchIndex;
-
-            if (LZ4_read32(matchPtr) == pattern) {
-                int mlt;
-                int back = 0;
-                const BYTE* vLimit = ip + (dictEndOffset - dictMatchIndex);
-                if (vLimit > iHighLimit) vLimit = iHighLimit;
-                mlt = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;
-                back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictCtx->base + dictCtx->dictLimit) : 0;
-                mlt -= back;
-                if (mlt > longest) {
-                    longest = mlt;
-                    *matchpos = base + matchIndex + back;
-                    *startpos = ip + back;
-            }   }
-
-            {   U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, dictMatchIndex);
-                dictMatchIndex -= nextOffset;
-                matchIndex -= nextOffset;
-    }   }   }
-
-    return longest;
-}
-
-LZ4_FORCE_INLINE
-int LZ4HC_InsertAndFindBestMatch(LZ4HC_CCtx_internal* const hc4,   /* Index table will be updated */
-                                 const BYTE* const ip, const BYTE* const iLimit,
-                                 const BYTE** matchpos,
-                                 const int maxNbAttempts,
-                                 const int patternAnalysis,
-                                 const dictCtx_directive dict)
-{
-    const BYTE* uselessPtr = ip;
-    /* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),
-     * but this won't be the case here, as we define iLowLimit==ip,
-     * so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */
-    return LZ4HC_InsertAndGetWiderMatch(hc4, ip, ip, iLimit, MINMATCH-1, matchpos, &uselessPtr, maxNbAttempts, patternAnalysis, 0 /*chainSwap*/, dict, favorCompressionRatio);
-}
-
-/* LZ4HC_encodeSequence() :
- * @return : 0 if ok,
- *           1 if buffer issue detected */
-LZ4_FORCE_INLINE int LZ4HC_encodeSequence (
-    const BYTE** _ip,
-    BYTE** _op,
-    const BYTE** _anchor,
-    int matchLength,
-    const BYTE* const match,
-    limitedOutput_directive limit,
-    BYTE* oend)
-{
-#define ip      (*_ip)
-#define op      (*_op)
-#define anchor  (*_anchor)
-
-    size_t length;
-    BYTE* const token = op++;
-
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 6)
-    static const BYTE* start = NULL;
-    static U32 totalCost = 0;
-    U32 const pos = (start==NULL) ? 0 : (U32)(anchor - start);
-    U32 const ll = (U32)(ip - anchor);
-    U32 const llAdd = (ll>=15) ? ((ll-15) / 255) + 1 : 0;
-    U32 const mlAdd = (matchLength>=19) ? ((matchLength-19) / 255) + 1 : 0;
-    U32 const cost = 1 + llAdd + ll + 2 + mlAdd;
-    if (start==NULL) start = anchor;  /* only works for single segment */
-    /* g_debuglog_enable = (pos >= 2228) & (pos <= 2262); */
-    DEBUGLOG(6, "pos:%7u -- literals:%4u, match:%4i, offset:%5u, cost:%4u + %5u",
-                pos,
-                (U32)(ip - anchor), matchLength, (U32)(ip-match),
-                cost, totalCost);
-    totalCost += cost;
-#endif
-
-    /* Encode Literal length */
-    length = (size_t)(ip - anchor);
-    LZ4_STATIC_ASSERT(notLimited == 0);
-    /* Check output limit */
-    if (limit && ((op + (length / 255) + length + (2 + 1 + LASTLITERALS)) > oend)) {
-        DEBUGLOG(6, "Not enough room to write %i literals (%i bytes remaining)",
-                (int)length, (int)(oend - op));
-        return 1;
-    }
-    if (length >= RUN_MASK) {
-        size_t len = length - RUN_MASK;
-        *token = (RUN_MASK << ML_BITS);
-        for(; len >= 255 ; len -= 255) *op++ = 255;
-        *op++ = (BYTE)len;
-    } else {
-        *token = (BYTE)(length << ML_BITS);
-    }
-
-    /* Copy Literals */
-    LZ4_wildCopy8(op, anchor, op + length);
-    op += length;
-
-    /* Encode Offset */
-    assert( (ip - match) <= LZ4_DISTANCE_MAX );   /* note : consider providing offset as a value, rather than as a pointer difference */
-    LZ4_writeLE16(op, (U16)(ip - match)); op += 2;
-
-    /* Encode MatchLength */
-    assert(matchLength >= MINMATCH);
-    length = (size_t)matchLength - MINMATCH;
-    if (limit && (op + (length / 255) + (1 + LASTLITERALS) > oend)) {
-        DEBUGLOG(6, "Not enough room to write match length");
-        return 1;   /* Check output limit */
-    }
-    if (length >= ML_MASK) {
-        *token += ML_MASK;
-        length -= ML_MASK;
-        for(; length >= 510 ; length -= 510) { *op++ = 255; *op++ = 255; }
-        if (length >= 255) { length -= 255; *op++ = 255; }
-        *op++ = (BYTE)length;
-    } else {
-        *token += (BYTE)(length);
-    }
-
-    /* Prepare next loop */
-    ip += matchLength;
-    anchor = ip;
-
-    return 0;
-}
-#undef ip
-#undef op
-#undef anchor
-
-LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (
-    LZ4HC_CCtx_internal* const ctx,
-    const char* const source,
-    char* const dest,
-    int* srcSizePtr,
-    int const maxOutputSize,
-    int maxNbAttempts,
-    const limitedOutput_directive limit,
-    const dictCtx_directive dict
-    )
-{
-    const int inputSize = *srcSizePtr;
-    const int patternAnalysis = (maxNbAttempts > 128);   /* levels 9+ */
-
-    const BYTE* ip = (const BYTE*) source;
-    const BYTE* anchor = ip;
-    const BYTE* const iend = ip + inputSize;
-    const BYTE* const mflimit = iend - MFLIMIT;
-    const BYTE* const matchlimit = (iend - LASTLITERALS);
-
-    BYTE* optr = (BYTE*) dest;
-    BYTE* op = (BYTE*) dest;
-    BYTE* oend = op + maxOutputSize;
-
-    int   ml0, ml, ml2, ml3;
-    const BYTE* start0;
-    const BYTE* ref0;
-    const BYTE* ref = NULL;
-    const BYTE* start2 = NULL;
-    const BYTE* ref2 = NULL;
-    const BYTE* start3 = NULL;
-    const BYTE* ref3 = NULL;
-
-    /* init */
-    *srcSizePtr = 0;
-    if (limit == fillOutput) oend -= LASTLITERALS;                  /* Hack for support LZ4 format restriction */
-    if (inputSize < LZ4_minLength) goto _last_literals;             /* Input too small, no compression (all literals) */
-
-    /* Main Loop */
-    while (ip <= mflimit) {
-        ml = LZ4HC_InsertAndFindBestMatch(ctx, ip, matchlimit, &ref, maxNbAttempts, patternAnalysis, dict);
-        if (ml<MINMATCH) { ip++; continue; }
-
-        /* saved, in case we would skip too much */
-        start0 = ip; ref0 = ref; ml0 = ml;
-
-_Search2:
-        if (ip+ml <= mflimit) {
-            ml2 = LZ4HC_InsertAndGetWiderMatch(ctx,
-                            ip + ml - 2, ip + 0, matchlimit, ml, &ref2, &start2,
-                            maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio);
-        } else {
-            ml2 = ml;
-        }
-
-        if (ml2 == ml) { /* No better match => encode ML1 */
-            optr = op;
-            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow;
-            continue;
-        }
-
-        if (start0 < ip) {   /* first match was skipped at least once */
-            if (start2 < ip + ml0) {  /* squeezing ML1 between ML0(original ML1) and ML2 */
-                ip = start0; ref = ref0; ml = ml0;  /* restore initial ML1 */
-        }   }
-
-        /* Here, start0==ip */
-        if ((start2 - ip) < 3) {  /* First Match too small : removed */
-            ml = ml2;
-            ip = start2;
-            ref =ref2;
-            goto _Search2;
-        }
-
-_Search3:
-        /* At this stage, we have :
-        *  ml2 > ml1, and
-        *  ip1+3 <= ip2 (usually < ip1+ml1) */
-        if ((start2 - ip) < OPTIMAL_ML) {
-            int correction;
-            int new_ml = ml;
-            if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML;
-            if (ip+new_ml > start2 + ml2 - MINMATCH) new_ml = (int)(start2 - ip) + ml2 - MINMATCH;
-            correction = new_ml - (int)(start2 - ip);
-            if (correction > 0) {
-                start2 += correction;
-                ref2 += correction;
-                ml2 -= correction;
-            }
-        }
-        /* Now, we have start2 = ip+new_ml, with new_ml = min(ml, OPTIMAL_ML=18) */
-
-        if (start2 + ml2 <= mflimit) {
-            ml3 = LZ4HC_InsertAndGetWiderMatch(ctx,
-                            start2 + ml2 - 3, start2, matchlimit, ml2, &ref3, &start3,
-                            maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio);
-        } else {
-            ml3 = ml2;
-        }
-
-        if (ml3 == ml2) {  /* No better match => encode ML1 and ML2 */
-            /* ip & ref are known; Now for ml */
-            if (start2 < ip+ml)  ml = (int)(start2 - ip);
-            /* Now, encode 2 sequences */
-            optr = op;
-            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow;
-            ip = start2;
-            optr = op;
-            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml2, ref2, limit, oend)) {
-                ml  = ml2;
-                ref = ref2;
-                goto _dest_overflow;
-            }
-            continue;
-        }
-
-        if (start3 < ip+ml+3) {  /* Not enough space for match 2 : remove it */
-            if (start3 >= (ip+ml)) {  /* can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 */
-                if (start2 < ip+ml) {
-                    int correction = (int)(ip+ml - start2);
-                    start2 += correction;
-                    ref2 += correction;
-                    ml2 -= correction;
-                    if (ml2 < MINMATCH) {
-                        start2 = start3;
-                        ref2 = ref3;
-                        ml2 = ml3;
-                    }
-                }
-
-                optr = op;
-                if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow;
-                ip  = start3;
-                ref = ref3;
-                ml  = ml3;
-
-                start0 = start2;
-                ref0 = ref2;
-                ml0 = ml2;
-                goto _Search2;
-            }
-
-            start2 = start3;
-            ref2 = ref3;
-            ml2 = ml3;
-            goto _Search3;
-        }
-
-        /*
-        * OK, now we have 3 ascending matches;
-        * let's write the first one ML1.
-        * ip & ref are known; Now decide ml.
-        */
-        if (start2 < ip+ml) {
-            if ((start2 - ip) < OPTIMAL_ML) {
-                int correction;
-                if (ml > OPTIMAL_ML) ml = OPTIMAL_ML;
-                if (ip + ml > start2 + ml2 - MINMATCH) ml = (int)(start2 - ip) + ml2 - MINMATCH;
-                correction = ml - (int)(start2 - ip);
-                if (correction > 0) {
-                    start2 += correction;
-                    ref2 += correction;
-                    ml2 -= correction;
-                }
-            } else {
-                ml = (int)(start2 - ip);
-            }
-        }
-        optr = op;
-        if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow;
-
-        /* ML2 becomes ML1 */
-        ip = start2; ref = ref2; ml = ml2;
-
-        /* ML3 becomes ML2 */
-        start2 = start3; ref2 = ref3; ml2 = ml3;
-
-        /* let's find a new ML3 */
-        goto _Search3;
-    }
-
-_last_literals:
-    /* Encode Last Literals */
-    {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */
-        size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;
-        size_t const totalSize = 1 + llAdd + lastRunSize;
-        if (limit == fillOutput) oend += LASTLITERALS;  /* restore correct value */
-        if (limit && (op + totalSize > oend)) {
-            if (limit == limitedOutput) return 0;
-            /* adapt lastRunSize to fill 'dest' */
-            lastRunSize  = (size_t)(oend - op) - 1 /*token*/;
-            llAdd = (lastRunSize + 256 - RUN_MASK) / 256;
-            lastRunSize -= llAdd;
-        }
-        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);
-        ip = anchor + lastRunSize;  /* can be != iend if limit==fillOutput */
-
-        if (lastRunSize >= RUN_MASK) {
-            size_t accumulator = lastRunSize - RUN_MASK;
-            *op++ = (RUN_MASK << ML_BITS);
-            for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255;
-            *op++ = (BYTE) accumulator;
-        } else {
-            *op++ = (BYTE)(lastRunSize << ML_BITS);
-        }
-        memcpy(op, anchor, lastRunSize);
-        op += lastRunSize;
-    }
-
-    /* End */
-    *srcSizePtr = (int) (((const char*)ip) - source);
-    return (int) (((char*)op)-dest);
-
-_dest_overflow:
-    if (limit == fillOutput) {
-        /* Assumption : ip, anchor, ml and ref must be set correctly */
-        size_t const ll = (size_t)(ip - anchor);
-        size_t const ll_addbytes = (ll + 240) / 255;
-        size_t const ll_totalCost = 1 + ll_addbytes + ll;
-        BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */
-        DEBUGLOG(6, "Last sequence overflowing");
-        op = optr;  /* restore correct out pointer */
-        if (op + ll_totalCost <= maxLitPos) {
-            /* ll validated; now adjust match length */
-            size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));
-            size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);
-            assert(maxMlSize < INT_MAX); assert(ml >= 0);
-            if ((size_t)ml > maxMlSize) ml = (int)maxMlSize;
-            if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + ml >= MFLIMIT) {
-                LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, notLimited, oend);
-        }   }
-        goto _last_literals;
-    }
-    /* compression failed */
-    return 0;
-}
-
-
-static int LZ4HC_compress_optimal( LZ4HC_CCtx_internal* ctx,
-    const char* const source, char* dst,
-    int* srcSizePtr, int dstCapacity,
-    int const nbSearches, size_t sufficient_len,
-    const limitedOutput_directive limit, int const fullUpdate,
-    const dictCtx_directive dict,
-    const HCfavor_e favorDecSpeed);
-
-
-LZ4_FORCE_INLINE int LZ4HC_compress_generic_internal (
-    LZ4HC_CCtx_internal* const ctx,
-    const char* const src,
-    char* const dst,
-    int* const srcSizePtr,
-    int const dstCapacity,
-    int cLevel,
-    const limitedOutput_directive limit,
-    const dictCtx_directive dict
-    )
-{
-    typedef enum { lz4hc, lz4opt } lz4hc_strat_e;
-    typedef struct {
-        lz4hc_strat_e strat;
-        int nbSearches;
-        U32 targetLength;
-    } cParams_t;
-    static const cParams_t clTable[LZ4HC_CLEVEL_MAX+1] = {
-        { lz4hc,     2, 16 },  /* 0, unused */
-        { lz4hc,     2, 16 },  /* 1, unused */
-        { lz4hc,     2, 16 },  /* 2, unused */
-        { lz4hc,     4, 16 },  /* 3 */
-        { lz4hc,     8, 16 },  /* 4 */
-        { lz4hc,    16, 16 },  /* 5 */
-        { lz4hc,    32, 16 },  /* 6 */
-        { lz4hc,    64, 16 },  /* 7 */
-        { lz4hc,   128, 16 },  /* 8 */
-        { lz4hc,   256, 16 },  /* 9 */
-        { lz4opt,   96, 64 },  /*10==LZ4HC_CLEVEL_OPT_MIN*/
-        { lz4opt,  512,128 },  /*11 */
-        { lz4opt,16384,LZ4_OPT_NUM },  /* 12==LZ4HC_CLEVEL_MAX */
-    };
-
-    DEBUGLOG(4, "LZ4HC_compress_generic(ctx=%p, src=%p, srcSize=%d, limit=%d)",
-                ctx, src, *srcSizePtr, limit);
-
-    if (limit == fillOutput && dstCapacity < 1) return 0;   /* Impossible to store anything */
-    if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0;    /* Unsupported input size (too large or negative) */
-
-    ctx->end += *srcSizePtr;
-    if (cLevel < 1) cLevel = LZ4HC_CLEVEL_DEFAULT;   /* note : convention is different from lz4frame, maybe something to review */
-    cLevel = MIN(LZ4HC_CLEVEL_MAX, cLevel);
-    {   cParams_t const cParam = clTable[cLevel];
-        HCfavor_e const favor = ctx->favorDecSpeed ? favorDecompressionSpeed : favorCompressionRatio;
-        int result;
-
-        if (cParam.strat == lz4hc) {
-            result = LZ4HC_compress_hashChain(ctx,
-                                src, dst, srcSizePtr, dstCapacity,
-                                cParam.nbSearches, limit, dict);
-        } else {
-            assert(cParam.strat == lz4opt);
-            result = LZ4HC_compress_optimal(ctx,
-                                src, dst, srcSizePtr, dstCapacity,
-                                cParam.nbSearches, cParam.targetLength, limit,
-                                cLevel == LZ4HC_CLEVEL_MAX,   /* ultra mode */
-                                dict, favor);
-        }
-        if (result <= 0) ctx->dirty = 1;
-        return result;
-    }
-}
-
-static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock);
-
-static int
-LZ4HC_compress_generic_noDictCtx (
-        LZ4HC_CCtx_internal* const ctx,
-        const char* const src,
-        char* const dst,
-        int* const srcSizePtr,
-        int const dstCapacity,
-        int cLevel,
-        limitedOutput_directive limit
-        )
-{
-    assert(ctx->dictCtx == NULL);
-    return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, noDictCtx);
-}
-
-static int
-LZ4HC_compress_generic_dictCtx (
-        LZ4HC_CCtx_internal* const ctx,
-        const char* const src,
-        char* const dst,
-        int* const srcSizePtr,
-        int const dstCapacity,
-        int cLevel,
-        limitedOutput_directive limit
-        )
-{
-    const size_t position = (size_t)(ctx->end - ctx->base) - ctx->lowLimit;
-    assert(ctx->dictCtx != NULL);
-    if (position >= 64 KB) {
-        ctx->dictCtx = NULL;
-        return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
-    } else if (position == 0 && *srcSizePtr > 4 KB) {
-        memcpy(ctx, ctx->dictCtx, sizeof(LZ4HC_CCtx_internal));
-        LZ4HC_setExternalDict(ctx, (const BYTE *)src);
-        ctx->compressionLevel = (short)cLevel;
-        return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
-    } else {
-        return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, usingDictCtxHc);
-    }
-}
-
-static int
-LZ4HC_compress_generic (
-        LZ4HC_CCtx_internal* const ctx,
-        const char* const src,
-        char* const dst,
-        int* const srcSizePtr,
-        int const dstCapacity,
-        int cLevel,
-        limitedOutput_directive limit
-        )
-{
-    if (ctx->dictCtx == NULL) {
-        return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
-    } else {
-        return LZ4HC_compress_generic_dictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
-    }
-}
-
-
-int LZ4_sizeofStateHC(void) { return (int)sizeof(LZ4_streamHC_t); }
-
-static size_t LZ4_streamHC_t_alignment(void)
-{
-#if LZ4_ALIGN_TEST
-    typedef struct { char c; LZ4_streamHC_t t; } t_a;
-    return sizeof(t_a) - sizeof(LZ4_streamHC_t);
-#else
-    return 1;  /* effectively disabled */
-#endif
-}
-
-/* state is presumed correctly initialized,
- * in which case its size and alignment have already been validate */
-int LZ4_compress_HC_extStateHC_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
-{
-    LZ4HC_CCtx_internal* const ctx = &((LZ4_streamHC_t*)state)->internal_donotuse;
-    if (!LZ4_isAligned(state, LZ4_streamHC_t_alignment())) return 0;
-    LZ4_resetStreamHC_fast((LZ4_streamHC_t*)state, compressionLevel);
-    LZ4HC_init_internal (ctx, (const BYTE*)src);
-    if (dstCapacity < LZ4_compressBound(srcSize))
-        return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, limitedOutput);
-    else
-        return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, notLimited);
-}
-
-int LZ4_compress_HC_extStateHC (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
-{
-    LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
-    if (ctx==NULL) return 0;   /* init failure */
-    return LZ4_compress_HC_extStateHC_fastReset(state, src, dst, srcSize, dstCapacity, compressionLevel);
-}
-
-int LZ4_compress_HC(const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
-{
-#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
-    LZ4_streamHC_t* const statePtr = (LZ4_streamHC_t*)ALLOC(sizeof(LZ4_streamHC_t));
-#else
-    LZ4_streamHC_t state;
-    LZ4_streamHC_t* const statePtr = &state;
-#endif
-    int const cSize = LZ4_compress_HC_extStateHC(statePtr, src, dst, srcSize, dstCapacity, compressionLevel);
-#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
-    FREEMEM(statePtr);
-#endif
-    return cSize;
-}
-
-/* state is presumed sized correctly (>= sizeof(LZ4_streamHC_t)) */
-int LZ4_compress_HC_destSize(void* state, const char* source, char* dest, int* sourceSizePtr, int targetDestSize, int cLevel)
-{
-    LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
-    if (ctx==NULL) return 0;   /* init failure */
-    LZ4HC_init_internal(&ctx->internal_donotuse, (const BYTE*) source);
-    LZ4_setCompressionLevel(ctx, cLevel);
-    return LZ4HC_compress_generic(&ctx->internal_donotuse, source, dest, sourceSizePtr, targetDestSize, cLevel, fillOutput);
-}
-
-
-
-/**************************************
-*  Streaming Functions
-**************************************/
-/* allocation */
-LZ4_streamHC_t* LZ4_createStreamHC(void)
-{
-    LZ4_streamHC_t* const state =
-        (LZ4_streamHC_t*)ALLOC_AND_ZERO(sizeof(LZ4_streamHC_t));
-    if (state == NULL) return NULL;
-    LZ4_setCompressionLevel(state, LZ4HC_CLEVEL_DEFAULT);
-    return state;
-}
-
-int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr)
-{
-    DEBUGLOG(4, "LZ4_freeStreamHC(%p)", LZ4_streamHCPtr);
-    if (!LZ4_streamHCPtr) return 0;  /* support free on NULL */
-    FREEMEM(LZ4_streamHCPtr);
-    return 0;
-}
-
-
-LZ4_streamHC_t* LZ4_initStreamHC (void* buffer, size_t size)
-{
-    LZ4_streamHC_t* const LZ4_streamHCPtr = (LZ4_streamHC_t*)buffer;
-    /* if compilation fails here, LZ4_STREAMHCSIZE must be increased */
-    LZ4_STATIC_ASSERT(sizeof(LZ4HC_CCtx_internal) <= LZ4_STREAMHCSIZE);
-    DEBUGLOG(4, "LZ4_initStreamHC(%p, %u)", buffer, (unsigned)size);
-    /* check conditions */
-    if (buffer == NULL) return NULL;
-    if (size < sizeof(LZ4_streamHC_t)) return NULL;
-    if (!LZ4_isAligned(buffer, LZ4_streamHC_t_alignment())) return NULL;
-    /* init */
-    { LZ4HC_CCtx_internal* const hcstate = &(LZ4_streamHCPtr->internal_donotuse);
-      MEM_INIT(hcstate, 0, sizeof(*hcstate)); }
-    LZ4_setCompressionLevel(LZ4_streamHCPtr, LZ4HC_CLEVEL_DEFAULT);
-    return LZ4_streamHCPtr;
-}
-
-/* just a stub */
-void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
-{
-    LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
-    LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel);
-}
-
-void LZ4_resetStreamHC_fast (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
-{
-    DEBUGLOG(4, "LZ4_resetStreamHC_fast(%p, %d)", LZ4_streamHCPtr, compressionLevel);
-    if (LZ4_streamHCPtr->internal_donotuse.dirty) {
-        LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
-    } else {
-        /* preserve end - base : can trigger clearTable's threshold */
-        LZ4_streamHCPtr->internal_donotuse.end -= (uptrval)LZ4_streamHCPtr->internal_donotuse.base;
-        LZ4_streamHCPtr->internal_donotuse.base = NULL;
-        LZ4_streamHCPtr->internal_donotuse.dictCtx = NULL;
-    }
-    LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel);
-}
-
-void LZ4_setCompressionLevel(LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
-{
-    DEBUGLOG(5, "LZ4_setCompressionLevel(%p, %d)", LZ4_streamHCPtr, compressionLevel);
-    if (compressionLevel < 1) compressionLevel = LZ4HC_CLEVEL_DEFAULT;
-    if (compressionLevel > LZ4HC_CLEVEL_MAX) compressionLevel = LZ4HC_CLEVEL_MAX;
-    LZ4_streamHCPtr->internal_donotuse.compressionLevel = (short)compressionLevel;
-}
-
-void LZ4_favorDecompressionSpeed(LZ4_streamHC_t* LZ4_streamHCPtr, int favor)
-{
-    LZ4_streamHCPtr->internal_donotuse.favorDecSpeed = (favor!=0);
-}
-
-/* LZ4_loadDictHC() :
- * LZ4_streamHCPtr is presumed properly initialized */
-int LZ4_loadDictHC (LZ4_streamHC_t* LZ4_streamHCPtr,
-              const char* dictionary, int dictSize)
-{
-    LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
-    DEBUGLOG(4, "LZ4_loadDictHC(ctx:%p, dict:%p, dictSize:%d)", LZ4_streamHCPtr, dictionary, dictSize);
-    assert(LZ4_streamHCPtr != NULL);
-    if (dictSize > 64 KB) {
-        dictionary += (size_t)dictSize - 64 KB;
-        dictSize = 64 KB;
-    }
-    /* need a full initialization, there are bad side-effects when using resetFast() */
-    {   int const cLevel = ctxPtr->compressionLevel;
-        LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
-        LZ4_setCompressionLevel(LZ4_streamHCPtr, cLevel);
-    }
-    LZ4HC_init_internal (ctxPtr, (const BYTE*)dictionary);
-    ctxPtr->end = (const BYTE*)dictionary + dictSize;
-    if (dictSize >= 4) LZ4HC_Insert (ctxPtr, ctxPtr->end-3);
-    return dictSize;
-}
-
-void LZ4_attach_HC_dictionary(LZ4_streamHC_t *working_stream, const LZ4_streamHC_t *dictionary_stream) {
-    working_stream->internal_donotuse.dictCtx = dictionary_stream != NULL ? &(dictionary_stream->internal_donotuse) : NULL;
-}
-
-/* compression */
-
-static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock)
-{
-    DEBUGLOG(4, "LZ4HC_setExternalDict(%p, %p)", ctxPtr, newBlock);
-    if (ctxPtr->end >= ctxPtr->base + ctxPtr->dictLimit + 4)
-        LZ4HC_Insert (ctxPtr, ctxPtr->end-3);   /* Referencing remaining dictionary content */
-
-    /* Only one memory segment for extDict, so any previous extDict is lost at this stage */
-    ctxPtr->lowLimit  = ctxPtr->dictLimit;
-    ctxPtr->dictLimit = (U32)(ctxPtr->end - ctxPtr->base);
-    ctxPtr->dictBase  = ctxPtr->base;
-    ctxPtr->base = newBlock - ctxPtr->dictLimit;
-    ctxPtr->end  = newBlock;
-    ctxPtr->nextToUpdate = ctxPtr->dictLimit;   /* match referencing will resume from there */
-
-    /* cannot reference an extDict and a dictCtx at the same time */
-    ctxPtr->dictCtx = NULL;
-}
-
-static int
-LZ4_compressHC_continue_generic (LZ4_streamHC_t* LZ4_streamHCPtr,
-                                 const char* src, char* dst,
-                                 int* srcSizePtr, int dstCapacity,
-                                 limitedOutput_directive limit)
-{
-    LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
-    DEBUGLOG(5, "LZ4_compressHC_continue_generic(ctx=%p, src=%p, srcSize=%d, limit=%d)",
-                LZ4_streamHCPtr, src, *srcSizePtr, limit);
-    assert(ctxPtr != NULL);
-    /* auto-init if forgotten */
-    if (ctxPtr->base == NULL) LZ4HC_init_internal (ctxPtr, (const BYTE*) src);
-
-    /* Check overflow */
-    if ((size_t)(ctxPtr->end - ctxPtr->base) > 2 GB) {
-        size_t dictSize = (size_t)(ctxPtr->end - ctxPtr->base) - ctxPtr->dictLimit;
-        if (dictSize > 64 KB) dictSize = 64 KB;
-        LZ4_loadDictHC(LZ4_streamHCPtr, (const char*)(ctxPtr->end) - dictSize, (int)dictSize);
-    }
-
-    /* Check if blocks follow each other */
-    if ((const BYTE*)src != ctxPtr->end)
-        LZ4HC_setExternalDict(ctxPtr, (const BYTE*)src);
-
-    /* Check overlapping input/dictionary space */
-    {   const BYTE* sourceEnd = (const BYTE*) src + *srcSizePtr;
-        const BYTE* const dictBegin = ctxPtr->dictBase + ctxPtr->lowLimit;
-        const BYTE* const dictEnd   = ctxPtr->dictBase + ctxPtr->dictLimit;
-        if ((sourceEnd > dictBegin) && ((const BYTE*)src < dictEnd)) {
-            if (sourceEnd > dictEnd) sourceEnd = dictEnd;
-            ctxPtr->lowLimit = (U32)(sourceEnd - ctxPtr->dictBase);
-            if (ctxPtr->dictLimit - ctxPtr->lowLimit < 4) ctxPtr->lowLimit = ctxPtr->dictLimit;
-    }   }
-
-    return LZ4HC_compress_generic (ctxPtr, src, dst, srcSizePtr, dstCapacity, ctxPtr->compressionLevel, limit);
-}
-
-int LZ4_compress_HC_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int srcSize, int dstCapacity)
-{
-    if (dstCapacity < LZ4_compressBound(srcSize))
-        return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, limitedOutput);
-    else
-        return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, notLimited);
-}
-
-int LZ4_compress_HC_continue_destSize (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int* srcSizePtr, int targetDestSize)
-{
-    return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, src, dst, srcSizePtr, targetDestSize, fillOutput);
-}
-
-
-
-/* LZ4_saveDictHC :
- * save history content
- * into a user-provided buffer
- * which is then used to continue compression
- */
-int LZ4_saveDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, char* safeBuffer, int dictSize)
-{
-    LZ4HC_CCtx_internal* const streamPtr = &LZ4_streamHCPtr->internal_donotuse;
-    int const prefixSize = (int)(streamPtr->end - (streamPtr->base + streamPtr->dictLimit));
-    DEBUGLOG(5, "LZ4_saveDictHC(%p, %p, %d)", LZ4_streamHCPtr, safeBuffer, dictSize);
-    assert(prefixSize >= 0);
-    if (dictSize > 64 KB) dictSize = 64 KB;
-    if (dictSize < 4) dictSize = 0;
-    if (dictSize > prefixSize) dictSize = prefixSize;
-    if (safeBuffer == NULL) assert(dictSize == 0);
-    if (dictSize > 0)
-        memmove(safeBuffer, streamPtr->end - dictSize, dictSize);
-    {   U32 const endIndex = (U32)(streamPtr->end - streamPtr->base);
-        streamPtr->end = (const BYTE*)safeBuffer + dictSize;
-        streamPtr->base = streamPtr->end - endIndex;
-        streamPtr->dictLimit = endIndex - (U32)dictSize;
-        streamPtr->lowLimit = endIndex - (U32)dictSize;
-        if (streamPtr->nextToUpdate < streamPtr->dictLimit)
-            streamPtr->nextToUpdate = streamPtr->dictLimit;
-    }
-    return dictSize;
-}
-
-
-/***************************************************
-*  Deprecated Functions
-***************************************************/
-
-/* These functions currently generate deprecation warnings */
-
-/* Wrappers for deprecated compression functions */
-int LZ4_compressHC(const char* src, char* dst, int srcSize) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), 0); }
-int LZ4_compressHC_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC(src, dst, srcSize, maxDstSize, 0); }
-int LZ4_compressHC2(const char* src, char* dst, int srcSize, int cLevel) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), cLevel); }
-int LZ4_compressHC2_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize, int cLevel) { return LZ4_compress_HC(src, dst, srcSize, maxDstSize, cLevel); }
-int LZ4_compressHC_withStateHC (void* state, const char* src, char* dst, int srcSize) { return LZ4_compress_HC_extStateHC (state, src, dst, srcSize, LZ4_compressBound(srcSize), 0); }
-int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC_extStateHC (state, src, dst, srcSize, maxDstSize, 0); }
-int LZ4_compressHC2_withStateHC (void* state, const char* src, char* dst, int srcSize, int cLevel) { return LZ4_compress_HC_extStateHC(state, src, dst, srcSize, LZ4_compressBound(srcSize), cLevel); }
-int LZ4_compressHC2_limitedOutput_withStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize, int cLevel) { return LZ4_compress_HC_extStateHC(state, src, dst, srcSize, maxDstSize, cLevel); }
-int LZ4_compressHC_continue (LZ4_streamHC_t* ctx, const char* src, char* dst, int srcSize) { return LZ4_compress_HC_continue (ctx, src, dst, srcSize, LZ4_compressBound(srcSize)); }
-int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* ctx, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC_continue (ctx, src, dst, srcSize, maxDstSize); }
-
-
-/* Deprecated streaming functions */
-int LZ4_sizeofStreamStateHC(void) { return LZ4_STREAMHCSIZE; }
-
-/* state is presumed correctly sized, aka >= sizeof(LZ4_streamHC_t)
- * @return : 0 on success, !=0 if error */
-int LZ4_resetStreamStateHC(void* state, char* inputBuffer)
-{
-    LZ4_streamHC_t* const hc4 = LZ4_initStreamHC(state, sizeof(*hc4));
-    if (hc4 == NULL) return 1;   /* init failed */
-    LZ4HC_init_internal (&hc4->internal_donotuse, (const BYTE*)inputBuffer);
-    return 0;
-}
-
-void* LZ4_createHC (const char* inputBuffer)
-{
-    LZ4_streamHC_t* const hc4 = LZ4_createStreamHC();
-    if (hc4 == NULL) return NULL;   /* not enough memory */
-    LZ4HC_init_internal (&hc4->internal_donotuse, (const BYTE*)inputBuffer);
-    return hc4;
-}
-
-int LZ4_freeHC (void* LZ4HC_Data)
-{
-    if (!LZ4HC_Data) return 0;  /* support free on NULL */
-    FREEMEM(LZ4HC_Data);
-    return 0;
-}
-
-int LZ4_compressHC2_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int cLevel)
-{
-    return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, 0, cLevel, notLimited);
-}
-
-int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int dstCapacity, int cLevel)
-{
-    return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, dstCapacity, cLevel, limitedOutput);
-}
-
-char* LZ4_slideInputBufferHC(void* LZ4HC_Data)
-{
-    LZ4_streamHC_t *ctx = (LZ4_streamHC_t*)LZ4HC_Data;
-    const BYTE *bufferStart = ctx->internal_donotuse.base + ctx->internal_donotuse.lowLimit;
-    LZ4_resetStreamHC_fast(ctx, ctx->internal_donotuse.compressionLevel);
-    /* avoid const char * -> char * conversion warning :( */
-    return (char *)(uptrval)bufferStart;
-}
-
-
-/* ================================================
- *  LZ4 Optimal parser (levels [LZ4HC_CLEVEL_OPT_MIN - LZ4HC_CLEVEL_MAX])
- * ===============================================*/
-typedef struct {
-    int price;
-    int off;
-    int mlen;
-    int litlen;
-} LZ4HC_optimal_t;
-
-/* price in bytes */
-LZ4_FORCE_INLINE int LZ4HC_literalsPrice(int const litlen)
-{
-    int price = litlen;
-    assert(litlen >= 0);
-    if (litlen >= (int)RUN_MASK)
-        price += 1 + ((litlen-(int)RUN_MASK) / 255);
-    return price;
-}
-
-
-/* requires mlen >= MINMATCH */
-LZ4_FORCE_INLINE int LZ4HC_sequencePrice(int litlen, int mlen)
-{
-    int price = 1 + 2 ; /* token + 16-bit offset */
-    assert(litlen >= 0);
-    assert(mlen >= MINMATCH);
-
-    price += LZ4HC_literalsPrice(litlen);
-
-    if (mlen >= (int)(ML_MASK+MINMATCH))
-        price += 1 + ((mlen-(int)(ML_MASK+MINMATCH)) / 255);
-
-    return price;
-}
-
-
-typedef struct {
-    int off;
-    int len;
-} LZ4HC_match_t;
-
-LZ4_FORCE_INLINE LZ4HC_match_t
-LZ4HC_FindLongerMatch(LZ4HC_CCtx_internal* const ctx,
-                      const BYTE* ip, const BYTE* const iHighLimit,
-                      int minLen, int nbSearches,
-                      const dictCtx_directive dict,
-                      const HCfavor_e favorDecSpeed)
-{
-    LZ4HC_match_t match = { 0 , 0 };
-    const BYTE* matchPtr = NULL;
-    /* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),
-     * but this won't be the case here, as we define iLowLimit==ip,
-     * so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */
-    int matchLength = LZ4HC_InsertAndGetWiderMatch(ctx, ip, ip, iHighLimit, minLen, &matchPtr, &ip, nbSearches, 1 /*patternAnalysis*/, 1 /*chainSwap*/, dict, favorDecSpeed);
-    if (matchLength <= minLen) return match;
-    if (favorDecSpeed) {
-        if ((matchLength>18) & (matchLength<=36)) matchLength=18;   /* favor shortcut */
-    }
-    match.len = matchLength;
-    match.off = (int)(ip-matchPtr);
-    return match;
-}
-
-
-static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
-                                    const char* const source,
-                                    char* dst,
-                                    int* srcSizePtr,
-                                    int dstCapacity,
-                                    int const nbSearches,
-                                    size_t sufficient_len,
-                                    const limitedOutput_directive limit,
-                                    int const fullUpdate,
-                                    const dictCtx_directive dict,
-                                    const HCfavor_e favorDecSpeed)
-{
-    int retval = 0;
-#define TRAILING_LITERALS 3
-#ifdef LZ4HC_HEAPMODE
-    LZ4HC_optimal_t* const opt = (LZ4HC_optimal_t*)ALLOC(sizeof(LZ4HC_optimal_t) * (LZ4_OPT_NUM + TRAILING_LITERALS));
-#else
-    LZ4HC_optimal_t opt[LZ4_OPT_NUM + TRAILING_LITERALS];   /* ~64 KB, which is a bit large for stack... */
-#endif
-
-    const BYTE* ip = (const BYTE*) source;
-    const BYTE* anchor = ip;
-    const BYTE* const iend = ip + *srcSizePtr;
-    const BYTE* const mflimit = iend - MFLIMIT;
-    const BYTE* const matchlimit = iend - LASTLITERALS;
-    BYTE* op = (BYTE*) dst;
-    BYTE* opSaved = (BYTE*) dst;
-    BYTE* oend = op + dstCapacity;
-    int ovml = MINMATCH;  /* overflow - last sequence */
-    const BYTE* ovref = NULL;
-
-    /* init */
-#ifdef LZ4HC_HEAPMODE
-    if (opt == NULL) goto _return_label;
-#endif
-    DEBUGLOG(5, "LZ4HC_compress_optimal(dst=%p, dstCapa=%u)", dst, (unsigned)dstCapacity);
-    *srcSizePtr = 0;
-    if (limit == fillOutput) oend -= LASTLITERALS;   /* Hack for support LZ4 format restriction */
-    if (sufficient_len >= LZ4_OPT_NUM) sufficient_len = LZ4_OPT_NUM-1;
-
-    /* Main Loop */
-    while (ip <= mflimit) {
-         int const llen = (int)(ip - anchor);
-         int best_mlen, best_off;
-         int cur, last_match_pos = 0;
-
-         LZ4HC_match_t const firstMatch = LZ4HC_FindLongerMatch(ctx, ip, matchlimit, MINMATCH-1, nbSearches, dict, favorDecSpeed);
-         if (firstMatch.len==0) { ip++; continue; }
-
-         if ((size_t)firstMatch.len > sufficient_len) {
-             /* good enough solution : immediate encoding */
-             int const firstML = firstMatch.len;
-             const BYTE* const matchPos = ip - firstMatch.off;
-             opSaved = op;
-             if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), firstML, matchPos, limit, oend) ) {  /* updates ip, op and anchor */
-                 ovml = firstML;
-                 ovref = matchPos;
-                 goto _dest_overflow;
-             }
-             continue;
-         }
-
-         /* set prices for first positions (literals) */
-         {   int rPos;
-             for (rPos = 0 ; rPos < MINMATCH ; rPos++) {
-                 int const cost = LZ4HC_literalsPrice(llen + rPos);
-                 opt[rPos].mlen = 1;
-                 opt[rPos].off = 0;
-                 opt[rPos].litlen = llen + rPos;
-                 opt[rPos].price = cost;
-                 DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup",
-                             rPos, cost, opt[rPos].litlen);
-         }   }
-         /* set prices using initial match */
-         {   int mlen = MINMATCH;
-             int const matchML = firstMatch.len;   /* necessarily < sufficient_len < LZ4_OPT_NUM */
-             int const offset = firstMatch.off;
-             assert(matchML < LZ4_OPT_NUM);
-             for ( ; mlen <= matchML ; mlen++) {
-                 int const cost = LZ4HC_sequencePrice(llen, mlen);
-                 opt[mlen].mlen = mlen;
-                 opt[mlen].off = offset;
-                 opt[mlen].litlen = llen;
-                 opt[mlen].price = cost;
-                 DEBUGLOG(7, "rPos:%3i => price:%3i (matchlen=%i) -- initial setup",
-                             mlen, cost, mlen);
-         }   }
-         last_match_pos = firstMatch.len;
-         {   int addLit;
-             for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) {
-                 opt[last_match_pos+addLit].mlen = 1; /* literal */
-                 opt[last_match_pos+addLit].off = 0;
-                 opt[last_match_pos+addLit].litlen = addLit;
-                 opt[last_match_pos+addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit);
-                 DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup",
-                             last_match_pos+addLit, opt[last_match_pos+addLit].price, addLit);
-         }   }
-
-         /* check further positions */
-         for (cur = 1; cur < last_match_pos; cur++) {
-             const BYTE* const curPtr = ip + cur;
-             LZ4HC_match_t newMatch;
-
-             if (curPtr > mflimit) break;
-             DEBUGLOG(7, "rPos:%u[%u] vs [%u]%u",
-                     cur, opt[cur].price, opt[cur+1].price, cur+1);
-             if (fullUpdate) {
-                 /* not useful to search here if next position has same (or lower) cost */
-                 if ( (opt[cur+1].price <= opt[cur].price)
-                   /* in some cases, next position has same cost, but cost rises sharply after, so a small match would still be beneficial */
-                   && (opt[cur+MINMATCH].price < opt[cur].price + 3/*min seq price*/) )
-                     continue;
-             } else {
-                 /* not useful to search here if next position has same (or lower) cost */
-                 if (opt[cur+1].price <= opt[cur].price) continue;
-             }
-
-             DEBUGLOG(7, "search at rPos:%u", cur);
-             if (fullUpdate)
-                 newMatch = LZ4HC_FindLongerMatch(ctx, curPtr, matchlimit, MINMATCH-1, nbSearches, dict, favorDecSpeed);
-             else
-                 /* only test matches of minimum length; slightly faster, but misses a few bytes */
-                 newMatch = LZ4HC_FindLongerMatch(ctx, curPtr, matchlimit, last_match_pos - cur, nbSearches, dict, favorDecSpeed);
-             if (!newMatch.len) continue;
-
-             if ( ((size_t)newMatch.len > sufficient_len)
-               || (newMatch.len + cur >= LZ4_OPT_NUM) ) {
-                 /* immediate encoding */
-                 best_mlen = newMatch.len;
-                 best_off = newMatch.off;
-                 last_match_pos = cur + 1;
-                 goto encode;
-             }
-
-             /* before match : set price with literals at beginning */
-             {   int const baseLitlen = opt[cur].litlen;
-                 int litlen;
-                 for (litlen = 1; litlen < MINMATCH; litlen++) {
-                     int const price = opt[cur].price - LZ4HC_literalsPrice(baseLitlen) + LZ4HC_literalsPrice(baseLitlen+litlen);
-                     int const pos = cur + litlen;
-                     if (price < opt[pos].price) {
-                         opt[pos].mlen = 1; /* literal */
-                         opt[pos].off = 0;
-                         opt[pos].litlen = baseLitlen+litlen;
-                         opt[pos].price = price;
-                         DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)",
-                                     pos, price, opt[pos].litlen);
-             }   }   }
-
-             /* set prices using match at position = cur */
-             {   int const matchML = newMatch.len;
-                 int ml = MINMATCH;
-
-                 assert(cur + newMatch.len < LZ4_OPT_NUM);
-                 for ( ; ml <= matchML ; ml++) {
-                     int const pos = cur + ml;
-                     int const offset = newMatch.off;
-                     int price;
-                     int ll;
-                     DEBUGLOG(7, "testing price rPos %i (last_match_pos=%i)",
-                                 pos, last_match_pos);
-                     if (opt[cur].mlen == 1) {
-                         ll = opt[cur].litlen;
-                         price = ((cur > ll) ? opt[cur - ll].price : 0)
-                               + LZ4HC_sequencePrice(ll, ml);
-                     } else {
-                         ll = 0;
-                         price = opt[cur].price + LZ4HC_sequencePrice(0, ml);
-                     }
-
-                    assert((U32)favorDecSpeed <= 1);
-                     if (pos > last_match_pos+TRAILING_LITERALS
-                      || price <= opt[pos].price - (int)favorDecSpeed) {
-                         DEBUGLOG(7, "rPos:%3i => price:%3i (matchlen=%i)",
-                                     pos, price, ml);
-                         assert(pos < LZ4_OPT_NUM);
-                         if ( (ml == matchML)  /* last pos of last match */
-                           && (last_match_pos < pos) )
-                             last_match_pos = pos;
-                         opt[pos].mlen = ml;
-                         opt[pos].off = offset;
-                         opt[pos].litlen = ll;
-                         opt[pos].price = price;
-             }   }   }
-             /* complete following positions with literals */
-             {   int addLit;
-                 for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) {
-                     opt[last_match_pos+addLit].mlen = 1; /* literal */
-                     opt[last_match_pos+addLit].off = 0;
-                     opt[last_match_pos+addLit].litlen = addLit;
-                     opt[last_match_pos+addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit);
-                     DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)", last_match_pos+addLit, opt[last_match_pos+addLit].price, addLit);
-             }   }
-         }  /* for (cur = 1; cur <= last_match_pos; cur++) */
-
-         assert(last_match_pos < LZ4_OPT_NUM + TRAILING_LITERALS);
-         best_mlen = opt[last_match_pos].mlen;
-         best_off = opt[last_match_pos].off;
-         cur = last_match_pos - best_mlen;
-
-encode: /* cur, last_match_pos, best_mlen, best_off must be set */
-         assert(cur < LZ4_OPT_NUM);
-         assert(last_match_pos >= 1);  /* == 1 when only one candidate */
-         DEBUGLOG(6, "reverse traversal, looking for shortest path (last_match_pos=%i)", last_match_pos);
-         {   int candidate_pos = cur;
-             int selected_matchLength = best_mlen;
-             int selected_offset = best_off;
-             while (1) {  /* from end to beginning */
-                 int const next_matchLength = opt[candidate_pos].mlen;  /* can be 1, means literal */
-                 int const next_offset = opt[candidate_pos].off;
-                 DEBUGLOG(7, "pos %i: sequence length %i", candidate_pos, selected_matchLength);
-                 opt[candidate_pos].mlen = selected_matchLength;
-                 opt[candidate_pos].off = selected_offset;
-                 selected_matchLength = next_matchLength;
-                 selected_offset = next_offset;
-                 if (next_matchLength > candidate_pos) break; /* last match elected, first match to encode */
-                 assert(next_matchLength > 0);  /* can be 1, means literal */
-                 candidate_pos -= next_matchLength;
-         }   }
-
-         /* encode all recorded sequences in order */
-         {   int rPos = 0;  /* relative position (to ip) */
-             while (rPos < last_match_pos) {
-                 int const ml = opt[rPos].mlen;
-                 int const offset = opt[rPos].off;
-                 if (ml == 1) { ip++; rPos++; continue; }  /* literal; note: can end up with several literals, in which case, skip them */
-                 rPos += ml;
-                 assert(ml >= MINMATCH);
-                 assert((offset >= 1) && (offset <= LZ4_DISTANCE_MAX));
-                 opSaved = op;
-                 if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ip - offset, limit, oend) ) {  /* updates ip, op and anchor */
-                     ovml = ml;
-                     ovref = ip - offset;
-                     goto _dest_overflow;
-         }   }   }
-     }  /* while (ip <= mflimit) */
-
-_last_literals:
-     /* Encode Last Literals */
-     {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */
-         size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;
-         size_t const totalSize = 1 + llAdd + lastRunSize;
-         if (limit == fillOutput) oend += LASTLITERALS;  /* restore correct value */
-         if (limit && (op + totalSize > oend)) {
-             if (limit == limitedOutput) { /* Check output limit */
-                retval = 0;
-                goto _return_label;
-             }
-             /* adapt lastRunSize to fill 'dst' */
-             lastRunSize  = (size_t)(oend - op) - 1 /*token*/;
-             llAdd = (lastRunSize + 256 - RUN_MASK) / 256;
-             lastRunSize -= llAdd;
-         }
-         DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);
-         ip = anchor + lastRunSize; /* can be != iend if limit==fillOutput */
-
-         if (lastRunSize >= RUN_MASK) {
-             size_t accumulator = lastRunSize - RUN_MASK;
-             *op++ = (RUN_MASK << ML_BITS);
-             for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255;
-             *op++ = (BYTE) accumulator;
-         } else {
-             *op++ = (BYTE)(lastRunSize << ML_BITS);
-         }
-         memcpy(op, anchor, lastRunSize);
-         op += lastRunSize;
-     }
-
-     /* End */
-     *srcSizePtr = (int) (((const char*)ip) - source);
-     retval = (int) ((char*)op-dst);
-     goto _return_label;
-
-_dest_overflow:
-if (limit == fillOutput) {
-     /* Assumption : ip, anchor, ovml and ovref must be set correctly */
-     size_t const ll = (size_t)(ip - anchor);
-     size_t const ll_addbytes = (ll + 240) / 255;
-     size_t const ll_totalCost = 1 + ll_addbytes + ll;
-     BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */
-     DEBUGLOG(6, "Last sequence overflowing (only %i bytes remaining)", (int)(oend-1-opSaved));
-     op = opSaved;  /* restore correct out pointer */
-     if (op + ll_totalCost <= maxLitPos) {
-         /* ll validated; now adjust match length */
-         size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));
-         size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);
-         assert(maxMlSize < INT_MAX); assert(ovml >= 0);
-         if ((size_t)ovml > maxMlSize) ovml = (int)maxMlSize;
-         if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + ovml >= MFLIMIT) {
-             DEBUGLOG(6, "Space to end : %i + ml (%i)", (int)((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1), ovml);
-             DEBUGLOG(6, "Before : ip = %p, anchor = %p", ip, anchor);
-             LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ovml, ovref, notLimited, oend);
-             DEBUGLOG(6, "After : ip = %p, anchor = %p", ip, anchor);
-     }   }
-     goto _last_literals;
-}
-_return_label:
-#ifdef LZ4HC_HEAPMODE
-     FREEMEM(opt);
-#endif
-     return retval;
-}
diff --git a/thirdparty/lz4/lz4hc.h b/thirdparty/lz4/lz4hc.h
deleted file mode 100644
index b423990..0000000
--- a/thirdparty/lz4/lz4hc.h
+++ /dev/null
@@ -1,413 +0,0 @@
-/*
-   LZ4 HC - High Compression Mode of LZ4
-   Header File
-   Copyright (C) 2011-2020, Yann Collet.
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - LZ4 source repository : https://github.com/lz4/lz4
-   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#ifndef LZ4_HC_H_19834876238432
-#define LZ4_HC_H_19834876238432
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* --- Dependency --- */
-/* note : lz4hc requires lz4.h/lz4.c for compilation */
-#include "lz4.h"   /* stddef, LZ4LIB_API, LZ4_DEPRECATED */
-
-
-/* --- Useful constants --- */
-#define LZ4HC_CLEVEL_MIN         3
-#define LZ4HC_CLEVEL_DEFAULT     9
-#define LZ4HC_CLEVEL_OPT_MIN    10
-#define LZ4HC_CLEVEL_MAX        12
-
-
-/*-************************************
- *  Block Compression
- **************************************/
-/*! LZ4_compress_HC() :
- *  Compress data from `src` into `dst`, using the powerful but slower "HC" algorithm.
- * `dst` must be already allocated.
- *  Compression is guaranteed to succeed if `dstCapacity >= LZ4_compressBound(srcSize)` (see "lz4.h")
- *  Max supported `srcSize` value is LZ4_MAX_INPUT_SIZE (see "lz4.h")
- * `compressionLevel` : any value between 1 and LZ4HC_CLEVEL_MAX will work.
- *                      Values > LZ4HC_CLEVEL_MAX behave the same as LZ4HC_CLEVEL_MAX.
- * @return : the number of bytes written into 'dst'
- *           or 0 if compression fails.
- */
-LZ4LIB_API int LZ4_compress_HC (const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel);
-
-
-/* Note :
- *   Decompression functions are provided within "lz4.h" (BSD license)
- */
-
-
-/*! LZ4_compress_HC_extStateHC() :
- *  Same as LZ4_compress_HC(), but using an externally allocated memory segment for `state`.
- * `state` size is provided by LZ4_sizeofStateHC().
- *  Memory segment must be aligned on 8-bytes boundaries (which a normal malloc() should do properly).
- */
-LZ4LIB_API int LZ4_sizeofStateHC(void);
-LZ4LIB_API int LZ4_compress_HC_extStateHC(void* stateHC, const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel);
-
-
-/*! LZ4_compress_HC_destSize() : v1.9.0+
- *  Will compress as much data as possible from `src`
- *  to fit into `targetDstSize` budget.
- *  Result is provided in 2 parts :
- * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize)
- *           or 0 if compression fails.
- * `srcSizePtr` : on success, *srcSizePtr is updated to indicate how much bytes were read from `src`
- */
-LZ4LIB_API int LZ4_compress_HC_destSize(void* stateHC,
-                                  const char* src, char* dst,
-                                        int* srcSizePtr, int targetDstSize,
-                                        int compressionLevel);
-
-
-/*-************************************
- *  Streaming Compression
- *  Bufferless synchronous API
- **************************************/
- typedef union LZ4_streamHC_u LZ4_streamHC_t;   /* incomplete type (defined later) */
-
-/*! LZ4_createStreamHC() and LZ4_freeStreamHC() :
- *  These functions create and release memory for LZ4 HC streaming state.
- *  Newly created states are automatically initialized.
- *  A same state can be used multiple times consecutively,
- *  starting with LZ4_resetStreamHC_fast() to start a new stream of blocks.
- */
-LZ4LIB_API LZ4_streamHC_t* LZ4_createStreamHC(void);
-LZ4LIB_API int             LZ4_freeStreamHC (LZ4_streamHC_t* streamHCPtr);
-
-/*
-  These functions compress data in successive blocks of any size,
-  using previous blocks as dictionary, to improve compression ratio.
-  One key assumption is that previous blocks (up to 64 KB) remain read-accessible while compressing next blocks.
-  There is an exception for ring buffers, which can be smaller than 64 KB.
-  Ring-buffer scenario is automatically detected and handled within LZ4_compress_HC_continue().
-
-  Before starting compression, state must be allocated and properly initialized.
-  LZ4_createStreamHC() does both, though compression level is set to LZ4HC_CLEVEL_DEFAULT.
-
-  Selecting the compression level can be done with LZ4_resetStreamHC_fast() (starts a new stream)
-  or LZ4_setCompressionLevel() (anytime, between blocks in the same stream) (experimental).
-  LZ4_resetStreamHC_fast() only works on states which have been properly initialized at least once,
-  which is automatically the case when state is created using LZ4_createStreamHC().
-
-  After reset, a first "fictional block" can be designated as initial dictionary,
-  using LZ4_loadDictHC() (Optional).
-
-  Invoke LZ4_compress_HC_continue() to compress each successive block.
-  The number of blocks is unlimited.
-  Previous input blocks, including initial dictionary when present,
-  must remain accessible and unmodified during compression.
-
-  It's allowed to update compression level anytime between blocks,
-  using LZ4_setCompressionLevel() (experimental).
-
-  'dst' buffer should be sized to handle worst case scenarios
-  (see LZ4_compressBound(), it ensures compression success).
-  In case of failure, the API does not guarantee recovery,
-  so the state _must_ be reset.
-  To ensure compression success
-  whenever `dst` buffer size cannot be made >= LZ4_compressBound(),
-  consider using LZ4_compress_HC_continue_destSize().
-
-  Whenever previous input blocks can't be preserved unmodified in-place during compression of next blocks,
-  it's possible to copy the last blocks into a more stable memory space, using LZ4_saveDictHC().
-  Return value of LZ4_saveDictHC() is the size of dictionary effectively saved into 'safeBuffer' (<= 64 KB)
-
-  After completing a streaming compression,
-  it's possible to start a new stream of blocks, using the same LZ4_streamHC_t state,
-  just by resetting it, using LZ4_resetStreamHC_fast().
-*/
-
-LZ4LIB_API void LZ4_resetStreamHC_fast(LZ4_streamHC_t* streamHCPtr, int compressionLevel);   /* v1.9.0+ */
-LZ4LIB_API int  LZ4_loadDictHC (LZ4_streamHC_t* streamHCPtr, const char* dictionary, int dictSize);
-
-LZ4LIB_API int LZ4_compress_HC_continue (LZ4_streamHC_t* streamHCPtr,
-                                   const char* src, char* dst,
-                                         int srcSize, int maxDstSize);
-
-/*! LZ4_compress_HC_continue_destSize() : v1.9.0+
- *  Similar to LZ4_compress_HC_continue(),
- *  but will read as much data as possible from `src`
- *  to fit into `targetDstSize` budget.
- *  Result is provided into 2 parts :
- * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize)
- *           or 0 if compression fails.
- * `srcSizePtr` : on success, *srcSizePtr will be updated to indicate how much bytes were read from `src`.
- *           Note that this function may not consume the entire input.
- */
-LZ4LIB_API int LZ4_compress_HC_continue_destSize(LZ4_streamHC_t* LZ4_streamHCPtr,
-                                           const char* src, char* dst,
-                                                 int* srcSizePtr, int targetDstSize);
-
-LZ4LIB_API int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSize);
-
-
-
-/*^**********************************************
- * !!!!!!   STATIC LINKING ONLY   !!!!!!
- ***********************************************/
-
-/*-******************************************************************
- * PRIVATE DEFINITIONS :
- * Do not use these definitions directly.
- * They are merely exposed to allow static allocation of `LZ4_streamHC_t`.
- * Declare an `LZ4_streamHC_t` directly, rather than any type below.
- * Even then, only do so in the context of static linking, as definitions may change between versions.
- ********************************************************************/
-
-#define LZ4HC_DICTIONARY_LOGSIZE 16
-#define LZ4HC_MAXD (1<<LZ4HC_DICTIONARY_LOGSIZE)
-#define LZ4HC_MAXD_MASK (LZ4HC_MAXD - 1)
-
-#define LZ4HC_HASH_LOG 15
-#define LZ4HC_HASHTABLESIZE (1 << LZ4HC_HASH_LOG)
-#define LZ4HC_HASH_MASK (LZ4HC_HASHTABLESIZE - 1)
-
-
-typedef struct LZ4HC_CCtx_internal LZ4HC_CCtx_internal;
-struct LZ4HC_CCtx_internal
-{
-    LZ4_u32   hashTable[LZ4HC_HASHTABLESIZE];
-    LZ4_u16   chainTable[LZ4HC_MAXD];
-    const LZ4_byte* end;       /* next block here to continue on current prefix */
-    const LZ4_byte* base;      /* All index relative to this position */
-    const LZ4_byte* dictBase;  /* alternate base for extDict */
-    LZ4_u32   dictLimit;       /* below that point, need extDict */
-    LZ4_u32   lowLimit;        /* below that point, no more dict */
-    LZ4_u32   nextToUpdate;    /* index from which to continue dictionary update */
-    short     compressionLevel;
-    LZ4_i8    favorDecSpeed;   /* favor decompression speed if this flag set,
-                                  otherwise, favor compression ratio */
-    LZ4_i8    dirty;           /* stream has to be fully reset if this flag is set */
-    const LZ4HC_CCtx_internal* dictCtx;
-};
-
-
-/* Do not use these definitions directly !
- * Declare or allocate an LZ4_streamHC_t instead.
- */
-#define LZ4_STREAMHCSIZE       262200  /* static size, for inter-version compatibility */
-#define LZ4_STREAMHCSIZE_VOIDP (LZ4_STREAMHCSIZE / sizeof(void*))
-union LZ4_streamHC_u {
-    void* table[LZ4_STREAMHCSIZE_VOIDP];
-    LZ4HC_CCtx_internal internal_donotuse;
-}; /* previously typedef'd to LZ4_streamHC_t */
-
-/* LZ4_streamHC_t :
- * This structure allows static allocation of LZ4 HC streaming state.
- * This can be used to allocate statically, on state, or as part of a larger structure.
- *
- * Such state **must** be initialized using LZ4_initStreamHC() before first use.
- *
- * Note that invoking LZ4_initStreamHC() is not required when
- * the state was created using LZ4_createStreamHC() (which is recommended).
- * Using the normal builder, a newly created state is automatically initialized.
- *
- * Static allocation shall only be used in combination with static linking.
- */
-
-/* LZ4_initStreamHC() : v1.9.0+
- * Required before first use of a statically allocated LZ4_streamHC_t.
- * Before v1.9.0 : use LZ4_resetStreamHC() instead
- */
-LZ4LIB_API LZ4_streamHC_t* LZ4_initStreamHC (void* buffer, size_t size);
-
-
-/*-************************************
-*  Deprecated Functions
-**************************************/
-/* see lz4.h LZ4_DISABLE_DEPRECATE_WARNINGS to turn off deprecation warnings */
-
-/* deprecated compression functions */
-LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC               (const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC2              (const char* source, char* dest, int inputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC2_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC_withStateHC               (void* state, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC2_withStateHC              (void* state, const char* source, char* dest, int inputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC_continue               (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
-
-/* Obsolete streaming functions; degraded functionality; do not use!
- *
- * In order to perform streaming compression, these functions depended on data
- * that is no longer tracked in the state. They have been preserved as well as
- * possible: using them will still produce a correct output. However, use of
- * LZ4_slideInputBufferHC() will truncate the history of the stream, rather
- * than preserve a window-sized chunk of history.
- */
-LZ4_DEPRECATED("use LZ4_createStreamHC() instead") LZ4LIB_API void* LZ4_createHC (const char* inputBuffer);
-LZ4_DEPRECATED("use LZ4_saveDictHC() instead") LZ4LIB_API     char* LZ4_slideInputBufferHC (void* LZ4HC_Data);
-LZ4_DEPRECATED("use LZ4_freeStreamHC() instead") LZ4LIB_API   int   LZ4_freeHC (void* LZ4HC_Data);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC2_continue               (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_createStreamHC() instead") LZ4LIB_API int   LZ4_sizeofStreamStateHC(void);
-LZ4_DEPRECATED("use LZ4_initStreamHC() instead") LZ4LIB_API  int   LZ4_resetStreamStateHC(void* state, char* inputBuffer);
-
-
-/* LZ4_resetStreamHC() is now replaced by LZ4_initStreamHC().
- * The intention is to emphasize the difference with LZ4_resetStreamHC_fast(),
- * which is now the recommended function to start a new stream of blocks,
- * but cannot be used to initialize a memory segment containing arbitrary garbage data.
- *
- * It is recommended to switch to LZ4_initStreamHC().
- * LZ4_resetStreamHC() will generate deprecation warnings in a future version.
- */
-LZ4LIB_API void LZ4_resetStreamHC (LZ4_streamHC_t* streamHCPtr, int compressionLevel);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* LZ4_HC_H_19834876238432 */
-
-
-/*-**************************************************
- * !!!!!     STATIC LINKING ONLY     !!!!!
- * Following definitions are considered experimental.
- * They should not be linked from DLL,
- * as there is no guarantee of API stability yet.
- * Prototypes will be promoted to "stable" status
- * after successfull usage in real-life scenarios.
- ***************************************************/
-#ifdef LZ4_HC_STATIC_LINKING_ONLY   /* protection macro */
-#ifndef LZ4_HC_SLO_098092834
-#define LZ4_HC_SLO_098092834
-
-#define LZ4_STATIC_LINKING_ONLY   /* LZ4LIB_STATIC_API */
-#include "lz4.h"
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*! LZ4_setCompressionLevel() : v1.8.0+ (experimental)
- *  It's possible to change compression level
- *  between successive invocations of LZ4_compress_HC_continue*()
- *  for dynamic adaptation.
- */
-LZ4LIB_STATIC_API void LZ4_setCompressionLevel(
-    LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel);
-
-/*! LZ4_favorDecompressionSpeed() : v1.8.2+ (experimental)
- *  Opt. Parser will favor decompression speed over compression ratio.
- *  Only applicable to levels >= LZ4HC_CLEVEL_OPT_MIN.
- */
-LZ4LIB_STATIC_API void LZ4_favorDecompressionSpeed(
-    LZ4_streamHC_t* LZ4_streamHCPtr, int favor);
-
-/*! LZ4_resetStreamHC_fast() : v1.9.0+
- *  When an LZ4_streamHC_t is known to be in a internally coherent state,
- *  it can often be prepared for a new compression with almost no work, only
- *  sometimes falling back to the full, expensive reset that is always required
- *  when the stream is in an indeterminate state (i.e., the reset performed by
- *  LZ4_resetStreamHC()).
- *
- *  LZ4_streamHCs are guaranteed to be in a valid state when:
- *  - returned from LZ4_createStreamHC()
- *  - reset by LZ4_resetStreamHC()
- *  - memset(stream, 0, sizeof(LZ4_streamHC_t))
- *  - the stream was in a valid state and was reset by LZ4_resetStreamHC_fast()
- *  - the stream was in a valid state and was then used in any compression call
- *    that returned success
- *  - the stream was in an indeterminate state and was used in a compression
- *    call that fully reset the state (LZ4_compress_HC_extStateHC()) and that
- *    returned success
- *
- *  Note:
- *  A stream that was last used in a compression call that returned an error
- *  may be passed to this function. However, it will be fully reset, which will
- *  clear any existing history and settings from the context.
- */
-LZ4LIB_STATIC_API void LZ4_resetStreamHC_fast(
-    LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel);
-
-/*! LZ4_compress_HC_extStateHC_fastReset() :
- *  A variant of LZ4_compress_HC_extStateHC().
- *
- *  Using this variant avoids an expensive initialization step. It is only safe
- *  to call if the state buffer is known to be correctly initialized already
- *  (see above comment on LZ4_resetStreamHC_fast() for a definition of
- *  "correctly initialized"). From a high level, the difference is that this
- *  function initializes the provided state with a call to
- *  LZ4_resetStreamHC_fast() while LZ4_compress_HC_extStateHC() starts with a
- *  call to LZ4_resetStreamHC().
- */
-LZ4LIB_STATIC_API int LZ4_compress_HC_extStateHC_fastReset (
-    void* state,
-    const char* src, char* dst,
-    int srcSize, int dstCapacity,
-    int compressionLevel);
-
-/*! LZ4_attach_HC_dictionary() :
- *  This is an experimental API that allows for the efficient use of a
- *  static dictionary many times.
- *
- *  Rather than re-loading the dictionary buffer into a working context before
- *  each compression, or copying a pre-loaded dictionary's LZ4_streamHC_t into a
- *  working LZ4_streamHC_t, this function introduces a no-copy setup mechanism,
- *  in which the working stream references the dictionary stream in-place.
- *
- *  Several assumptions are made about the state of the dictionary stream.
- *  Currently, only streams which have been prepared by LZ4_loadDictHC() should
- *  be expected to work.
- *
- *  Alternatively, the provided dictionary stream pointer may be NULL, in which
- *  case any existing dictionary stream is unset.
- *
- *  A dictionary should only be attached to a stream without any history (i.e.,
- *  a stream that has just been reset).
- *
- *  The dictionary will remain attached to the working stream only for the
- *  current stream session. Calls to LZ4_resetStreamHC(_fast) will remove the
- *  dictionary context association from the working stream. The dictionary
- *  stream (and source buffer) must remain in-place / accessible / unchanged
- *  through the lifetime of the stream session.
- */
-LZ4LIB_STATIC_API void LZ4_attach_HC_dictionary(
-          LZ4_streamHC_t *working_stream,
-    const LZ4_streamHC_t *dictionary_stream);
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* LZ4_HC_SLO_098092834 */
-#endif   /* LZ4_HC_STATIC_LINKING_ONLY */
diff --git a/thirdparty/lz4/xxhash.c b/thirdparty/lz4/xxhash.c
deleted file mode 100644
index ff28749..0000000
--- a/thirdparty/lz4/xxhash.c
+++ /dev/null
@@ -1,1030 +0,0 @@
-/*
-*  xxHash - Fast Hash algorithm
-*  Copyright (C) 2012-2016, Yann Collet
-*
-*  BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-*
-*  Redistribution and use in source and binary forms, with or without
-*  modification, are permitted provided that the following conditions are
-*  met:
-*
-*  * Redistributions of source code must retain the above copyright
-*  notice, this list of conditions and the following disclaimer.
-*  * Redistributions in binary form must reproduce the above
-*  copyright notice, this list of conditions and the following disclaimer
-*  in the documentation and/or other materials provided with the
-*  distribution.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-*  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*
-*  You can contact the author at :
-*  - xxHash homepage: http://www.xxhash.com
-*  - xxHash source repository : https://github.com/Cyan4973/xxHash
-*/
-
-
-/* *************************************
-*  Tuning parameters
-***************************************/
-/*!XXH_FORCE_MEMORY_ACCESS :
- * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
- * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
- * The below switch allow to select different access method for improved performance.
- * Method 0 (default) : use `memcpy()`. Safe and portable.
- * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
- *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
- * Method 2 : direct access. This method doesn't depend on compiler but violate C standard.
- *            It can generate buggy code on targets which do not support unaligned memory accesses.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://stackoverflow.com/a/32095106/646947 for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
-#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
-                        || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) \
-                        || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
-#    define XXH_FORCE_MEMORY_ACCESS 2
-#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || \
-  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
-                    || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) \
-                    || defined(__ARM_ARCH_7S__) ))
-#    define XXH_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-/*!XXH_ACCEPT_NULL_INPUT_POINTER :
- * If input pointer is NULL, xxHash default behavior is to dereference it, triggering a segfault.
- * When this macro is enabled, xxHash actively checks input for null pointer.
- * It it is, result for null input pointers is the same as a null-length input.
- */
-#ifndef XXH_ACCEPT_NULL_INPUT_POINTER   /* can be defined externally */
-#  define XXH_ACCEPT_NULL_INPUT_POINTER 0
-#endif
-
-/*!XXH_FORCE_NATIVE_FORMAT :
- * By default, xxHash library provides endian-independent Hash values, based on little-endian convention.
- * Results are therefore identical for little-endian and big-endian CPU.
- * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
- * Should endian-independence be of no importance for your application, you may set the #define below to 1,
- * to improve speed for Big-endian CPU.
- * This option has no impact on Little_Endian CPU.
- */
-#ifndef XXH_FORCE_NATIVE_FORMAT   /* can be defined externally */
-#  define XXH_FORCE_NATIVE_FORMAT 0
-#endif
-
-/*!XXH_FORCE_ALIGN_CHECK :
- * This is a minor performance trick, only useful with lots of very small keys.
- * It means : check for aligned/unaligned input.
- * The check costs one initial branch per hash;
- * set it to 0 when the input is guaranteed to be aligned,
- * or when alignment doesn't matter for performance.
- */
-#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */
-#  if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
-#    define XXH_FORCE_ALIGN_CHECK 0
-#  else
-#    define XXH_FORCE_ALIGN_CHECK 1
-#  endif
-#endif
-
-
-/* *************************************
-*  Includes & Memory related functions
-***************************************/
-/*! Modify the local functions below should you wish to use some other memory routines
-*   for malloc(), free() */
-#include <stdlib.h>
-static void* XXH_malloc(size_t s) { return malloc(s); }
-static void  XXH_free  (void* p)  { free(p); }
-/*! and for memcpy() */
-#include <string.h>
-static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }
-
-#include <assert.h>   /* assert */
-
-#define XXH_STATIC_LINKING_ONLY
-#include "xxhash.h"
-
-
-/* *************************************
-*  Compiler Specific Options
-***************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
-#  define FORCE_INLINE static __forceinline
-#else
-#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#    ifdef __GNUC__
-#      define FORCE_INLINE static inline __attribute__((always_inline))
-#    else
-#      define FORCE_INLINE static inline
-#    endif
-#  else
-#    define FORCE_INLINE static
-#  endif /* __STDC_VERSION__ */
-#endif
-
-
-/* *************************************
-*  Basic Types
-***************************************/
-#ifndef MEM_MODULE
-# if !defined (__VMS) \
-  && (defined (__cplusplus) \
-  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-#   include <stdint.h>
-    typedef uint8_t  BYTE;
-    typedef uint16_t U16;
-    typedef uint32_t U32;
-# else
-    typedef unsigned char      BYTE;
-    typedef unsigned short     U16;
-    typedef unsigned int       U32;
-# endif
-#endif
-
-#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
-
-/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
-static U32 XXH_read32(const void* memPtr) { return *(const U32*) memPtr; }
-
-#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-typedef union { U32 u32; } __attribute__((packed)) unalign;
-static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-
-#else
-
-/* portable and safe solution. Generally efficient.
- * see : http://stackoverflow.com/a/32095106/646947
- */
-static U32 XXH_read32(const void* memPtr)
-{
-    U32 val;
-    memcpy(&val, memPtr, sizeof(val));
-    return val;
-}
-
-#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
-
-
-/* ****************************************
-*  Compiler-specific Functions and Macros
-******************************************/
-#define XXH_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-
-/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */
-#if defined(_MSC_VER)
-#  define XXH_rotl32(x,r) _rotl(x,r)
-#  define XXH_rotl64(x,r) _rotl64(x,r)
-#else
-#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))
-#  define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r)))
-#endif
-
-#if defined(_MSC_VER)     /* Visual Studio */
-#  define XXH_swap32 _byteswap_ulong
-#elif XXH_GCC_VERSION >= 403
-#  define XXH_swap32 __builtin_bswap32
-#else
-static U32 XXH_swap32 (U32 x)
-{
-    return  ((x << 24) & 0xff000000 ) |
-            ((x <<  8) & 0x00ff0000 ) |
-            ((x >>  8) & 0x0000ff00 ) |
-            ((x >> 24) & 0x000000ff );
-}
-#endif
-
-
-/* *************************************
-*  Architecture Macros
-***************************************/
-typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
-
-/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
-#ifndef XXH_CPU_LITTLE_ENDIAN
-static int XXH_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-}
-#   define XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()
-#endif
-
-
-/* ***************************
-*  Memory reads
-*****************************/
-typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
-
-FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
-{
-    if (align==XXH_unaligned)
-        return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
-    else
-        return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
-}
-
-FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianess endian)
-{
-    return XXH_readLE32_align(ptr, endian, XXH_unaligned);
-}
-
-static U32 XXH_readBE32(const void* ptr)
-{
-    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
-}
-
-
-/* *************************************
-*  Macros
-***************************************/
-#define XXH_STATIC_ASSERT(c)  { enum { XXH_sa = 1/(int)(!!(c)) }; }  /* use after variable declarations */
-XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
-
-
-/* *******************************************************************
-*  32-bit hash functions
-*********************************************************************/
-static const U32 PRIME32_1 = 2654435761U;
-static const U32 PRIME32_2 = 2246822519U;
-static const U32 PRIME32_3 = 3266489917U;
-static const U32 PRIME32_4 =  668265263U;
-static const U32 PRIME32_5 =  374761393U;
-
-static U32 XXH32_round(U32 seed, U32 input)
-{
-    seed += input * PRIME32_2;
-    seed  = XXH_rotl32(seed, 13);
-    seed *= PRIME32_1;
-    return seed;
-}
-
-/* mix all bits */
-static U32 XXH32_avalanche(U32 h32)
-{
-    h32 ^= h32 >> 15;
-    h32 *= PRIME32_2;
-    h32 ^= h32 >> 13;
-    h32 *= PRIME32_3;
-    h32 ^= h32 >> 16;
-    return(h32);
-}
-
-#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)
-
-static U32
-XXH32_finalize(U32 h32, const void* ptr, size_t len,
-                XXH_endianess endian, XXH_alignment align)
-
-{
-    const BYTE* p = (const BYTE*)ptr;
-
-#define PROCESS1               \
-    h32 += (*p++) * PRIME32_5; \
-    h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
-
-#define PROCESS4                         \
-    h32 += XXH_get32bits(p) * PRIME32_3; \
-    p+=4;                                \
-    h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
-
-    switch(len&15)  /* or switch(bEnd - p) */
-    {
-      case 12:      PROCESS4;
-                    /* fallthrough */
-      case 8:       PROCESS4;
-                    /* fallthrough */
-      case 4:       PROCESS4;
-                    return XXH32_avalanche(h32);
-
-      case 13:      PROCESS4;
-                    /* fallthrough */
-      case 9:       PROCESS4;
-                    /* fallthrough */
-      case 5:       PROCESS4;
-                    PROCESS1;
-                    return XXH32_avalanche(h32);
-
-      case 14:      PROCESS4;
-                    /* fallthrough */
-      case 10:      PROCESS4;
-                    /* fallthrough */
-      case 6:       PROCESS4;
-                    PROCESS1;
-                    PROCESS1;
-                    return XXH32_avalanche(h32);
-
-      case 15:      PROCESS4;
-                    /* fallthrough */
-      case 11:      PROCESS4;
-                    /* fallthrough */
-      case 7:       PROCESS4;
-                    /* fallthrough */
-      case 3:       PROCESS1;
-                    /* fallthrough */
-      case 2:       PROCESS1;
-                    /* fallthrough */
-      case 1:       PROCESS1;
-                    /* fallthrough */
-      case 0:       return XXH32_avalanche(h32);
-    }
-    assert(0);
-    return h32;   /* reaching this point is deemed impossible */
-}
-
-
-FORCE_INLINE U32
-XXH32_endian_align(const void* input, size_t len, U32 seed,
-                    XXH_endianess endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* bEnd = p + len;
-    U32 h32;
-
-#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
-    if (p==NULL) {
-        len=0;
-        bEnd=p=(const BYTE*)(size_t)16;
-    }
-#endif
-
-    if (len>=16) {
-        const BYTE* const limit = bEnd - 15;
-        U32 v1 = seed + PRIME32_1 + PRIME32_2;
-        U32 v2 = seed + PRIME32_2;
-        U32 v3 = seed + 0;
-        U32 v4 = seed - PRIME32_1;
-
-        do {
-            v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4;
-            v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
-            v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
-            v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
-        } while (p < limit);
-
-        h32 = XXH_rotl32(v1, 1)  + XXH_rotl32(v2, 7)
-            + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
-    } else {
-        h32  = seed + PRIME32_5;
-    }
-
-    h32 += (U32)len;
-
-    return XXH32_finalize(h32, p, len&15, endian, align);
-}
-
-
-XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
-{
-#if 0
-    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH32_state_t state;
-    XXH32_reset(&state, seed);
-    XXH32_update(&state, input, len);
-    return XXH32_digest(&state);
-#else
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if (XXH_FORCE_ALIGN_CHECK) {
-        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
-            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
-            else
-                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
-    }   }
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
-    else
-        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
-#endif
-}
-
-
-
-/*======   Hash streaming   ======*/
-
-XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
-{
-    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
-}
-XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
-{
-    XXH_free(statePtr);
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState)
-{
-    memcpy(dstState, srcState, sizeof(*dstState));
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
-{
-    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state));
-    state.v1 = seed + PRIME32_1 + PRIME32_2;
-    state.v2 = seed + PRIME32_2;
-    state.v3 = seed + 0;
-    state.v4 = seed - PRIME32_1;
-    /* do not write into reserved, planned to be removed in a future version */
-    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
-    return XXH_OK;
-}
-
-
-FORCE_INLINE XXH_errorcode
-XXH32_update_endian(XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
-{
-    if (input==NULL)
-#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
-        return XXH_OK;
-#else
-        return XXH_ERROR;
-#endif
-
-    {   const BYTE* p = (const BYTE*)input;
-        const BYTE* const bEnd = p + len;
-
-        state->total_len_32 += (unsigned)len;
-        state->large_len |= (len>=16) | (state->total_len_32>=16);
-
-        if (state->memsize + len < 16)  {   /* fill in tmp buffer */
-            XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
-            state->memsize += (unsigned)len;
-            return XXH_OK;
-        }
-
-        if (state->memsize) {   /* some data left from previous update */
-            XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
-            {   const U32* p32 = state->mem32;
-                state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
-                state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
-                state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
-                state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian));
-            }
-            p += 16-state->memsize;
-            state->memsize = 0;
-        }
-
-        if (p <= bEnd-16) {
-            const BYTE* const limit = bEnd - 16;
-            U32 v1 = state->v1;
-            U32 v2 = state->v2;
-            U32 v3 = state->v3;
-            U32 v4 = state->v4;
-
-            do {
-                v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4;
-                v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4;
-                v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4;
-                v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4;
-            } while (p<=limit);
-
-            state->v1 = v1;
-            state->v2 = v2;
-            state->v3 = v3;
-            state->v4 = v4;
-        }
-
-        if (p < bEnd) {
-            XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
-            state->memsize = (unsigned)(bEnd-p);
-        }
-    }
-
-    return XXH_OK;
-}
-
-
-XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
-    else
-        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
-}
-
-
-FORCE_INLINE U32
-XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
-{
-    U32 h32;
-
-    if (state->large_len) {
-        h32 = XXH_rotl32(state->v1, 1)
-            + XXH_rotl32(state->v2, 7)
-            + XXH_rotl32(state->v3, 12)
-            + XXH_rotl32(state->v4, 18);
-    } else {
-        h32 = state->v3 /* == seed */ + PRIME32_5;
-    }
-
-    h32 += state->total_len_32;
-
-    return XXH32_finalize(h32, state->mem32, state->memsize, endian, XXH_aligned);
-}
-
-
-XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_digest_endian(state_in, XXH_littleEndian);
-    else
-        return XXH32_digest_endian(state_in, XXH_bigEndian);
-}
-
-
-/*======   Canonical representation   ======*/
-
-/*! Default XXH result types are basic unsigned 32 and 64 bits.
-*   The canonical representation follows human-readable write convention, aka big-endian (large digits first).
-*   These functions allow transformation of hash result into and from its canonical format.
-*   This way, hash values can be written into a file or buffer, remaining comparable across different systems.
-*/
-
-XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)
-{
-    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
-    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
-    memcpy(dst, &hash, sizeof(*dst));
-}
-
-XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
-{
-    return XXH_readBE32(src);
-}
-
-
-#ifndef XXH_NO_LONG_LONG
-
-/* *******************************************************************
-*  64-bit hash functions
-*********************************************************************/
-
-/*======   Memory access   ======*/
-
-#ifndef MEM_MODULE
-# define MEM_MODULE
-# if !defined (__VMS) \
-  && (defined (__cplusplus) \
-  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-#   include <stdint.h>
-    typedef uint64_t U64;
-# else
-    /* if compiler doesn't support unsigned long long, replace by another 64-bit type */
-    typedef unsigned long long U64;
-# endif
-#endif
-
-
-#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
-
-/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
-static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign64;
-static U64 XXH_read64(const void* ptr) { return ((const unalign64*)ptr)->u64; }
-
-#else
-
-/* portable and safe solution. Generally efficient.
- * see : http://stackoverflow.com/a/32095106/646947
- */
-
-static U64 XXH_read64(const void* memPtr)
-{
-    U64 val;
-    memcpy(&val, memPtr, sizeof(val));
-    return val;
-}
-
-#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
-
-#if defined(_MSC_VER)     /* Visual Studio */
-#  define XXH_swap64 _byteswap_uint64
-#elif XXH_GCC_VERSION >= 403
-#  define XXH_swap64 __builtin_bswap64
-#else
-static U64 XXH_swap64 (U64 x)
-{
-    return  ((x << 56) & 0xff00000000000000ULL) |
-            ((x << 40) & 0x00ff000000000000ULL) |
-            ((x << 24) & 0x0000ff0000000000ULL) |
-            ((x << 8)  & 0x000000ff00000000ULL) |
-            ((x >> 8)  & 0x00000000ff000000ULL) |
-            ((x >> 24) & 0x0000000000ff0000ULL) |
-            ((x >> 40) & 0x000000000000ff00ULL) |
-            ((x >> 56) & 0x00000000000000ffULL);
-}
-#endif
-
-FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
-{
-    if (align==XXH_unaligned)
-        return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
-    else
-        return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
-}
-
-FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianess endian)
-{
-    return XXH_readLE64_align(ptr, endian, XXH_unaligned);
-}
-
-static U64 XXH_readBE64(const void* ptr)
-{
-    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
-}
-
-
-/*======   xxh64   ======*/
-
-static const U64 PRIME64_1 = 11400714785074694791ULL;
-static const U64 PRIME64_2 = 14029467366897019727ULL;
-static const U64 PRIME64_3 =  1609587929392839161ULL;
-static const U64 PRIME64_4 =  9650029242287828579ULL;
-static const U64 PRIME64_5 =  2870177450012600261ULL;
-
-static U64 XXH64_round(U64 acc, U64 input)
-{
-    acc += input * PRIME64_2;
-    acc  = XXH_rotl64(acc, 31);
-    acc *= PRIME64_1;
-    return acc;
-}
-
-static U64 XXH64_mergeRound(U64 acc, U64 val)
-{
-    val  = XXH64_round(0, val);
-    acc ^= val;
-    acc  = acc * PRIME64_1 + PRIME64_4;
-    return acc;
-}
-
-static U64 XXH64_avalanche(U64 h64)
-{
-    h64 ^= h64 >> 33;
-    h64 *= PRIME64_2;
-    h64 ^= h64 >> 29;
-    h64 *= PRIME64_3;
-    h64 ^= h64 >> 32;
-    return h64;
-}
-
-
-#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)
-
-static U64
-XXH64_finalize(U64 h64, const void* ptr, size_t len,
-               XXH_endianess endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)ptr;
-
-#define PROCESS1_64            \
-    h64 ^= (*p++) * PRIME64_5; \
-    h64 = XXH_rotl64(h64, 11) * PRIME64_1;
-
-#define PROCESS4_64          \
-    h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; \
-    p+=4;                    \
-    h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-
-#define PROCESS8_64 {        \
-    U64 const k1 = XXH64_round(0, XXH_get64bits(p)); \
-    p+=8;                    \
-    h64 ^= k1;               \
-    h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; \
-}
-
-    switch(len&31) {
-      case 24: PROCESS8_64;
-                    /* fallthrough */
-      case 16: PROCESS8_64;
-                    /* fallthrough */
-      case  8: PROCESS8_64;
-               return XXH64_avalanche(h64);
-
-      case 28: PROCESS8_64;
-                    /* fallthrough */
-      case 20: PROCESS8_64;
-                    /* fallthrough */
-      case 12: PROCESS8_64;
-                    /* fallthrough */
-      case  4: PROCESS4_64;
-               return XXH64_avalanche(h64);
-
-      case 25: PROCESS8_64;
-                    /* fallthrough */
-      case 17: PROCESS8_64;
-                    /* fallthrough */
-      case  9: PROCESS8_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 29: PROCESS8_64;
-                    /* fallthrough */
-      case 21: PROCESS8_64;
-                    /* fallthrough */
-      case 13: PROCESS8_64;
-                    /* fallthrough */
-      case  5: PROCESS4_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 26: PROCESS8_64;
-                    /* fallthrough */
-      case 18: PROCESS8_64;
-                    /* fallthrough */
-      case 10: PROCESS8_64;
-               PROCESS1_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 30: PROCESS8_64;
-                    /* fallthrough */
-      case 22: PROCESS8_64;
-                    /* fallthrough */
-      case 14: PROCESS8_64;
-                    /* fallthrough */
-      case  6: PROCESS4_64;
-               PROCESS1_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 27: PROCESS8_64;
-                    /* fallthrough */
-      case 19: PROCESS8_64;
-                    /* fallthrough */
-      case 11: PROCESS8_64;
-               PROCESS1_64;
-               PROCESS1_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 31: PROCESS8_64;
-                    /* fallthrough */
-      case 23: PROCESS8_64;
-                    /* fallthrough */
-      case 15: PROCESS8_64;
-                    /* fallthrough */
-      case  7: PROCESS4_64;
-                    /* fallthrough */
-      case  3: PROCESS1_64;
-                    /* fallthrough */
-      case  2: PROCESS1_64;
-                    /* fallthrough */
-      case  1: PROCESS1_64;
-                    /* fallthrough */
-      case  0: return XXH64_avalanche(h64);
-    }
-
-    /* impossible to reach */
-    assert(0);
-    return 0;  /* unreachable, but some compilers complain without it */
-}
-
-FORCE_INLINE U64
-XXH64_endian_align(const void* input, size_t len, U64 seed,
-                XXH_endianess endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* bEnd = p + len;
-    U64 h64;
-
-#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
-    if (p==NULL) {
-        len=0;
-        bEnd=p=(const BYTE*)(size_t)32;
-    }
-#endif
-
-    if (len>=32) {
-        const BYTE* const limit = bEnd - 32;
-        U64 v1 = seed + PRIME64_1 + PRIME64_2;
-        U64 v2 = seed + PRIME64_2;
-        U64 v3 = seed + 0;
-        U64 v4 = seed - PRIME64_1;
-
-        do {
-            v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8;
-            v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8;
-            v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8;
-            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
-        } while (p<=limit);
-
-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
-        h64 = XXH64_mergeRound(h64, v1);
-        h64 = XXH64_mergeRound(h64, v2);
-        h64 = XXH64_mergeRound(h64, v3);
-        h64 = XXH64_mergeRound(h64, v4);
-
-    } else {
-        h64  = seed + PRIME64_5;
-    }
-
-    h64 += (U64) len;
-
-    return XXH64_finalize(h64, p, len, endian, align);
-}
-
-
-XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
-{
-#if 0
-    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH64_state_t state;
-    XXH64_reset(&state, seed);
-    XXH64_update(&state, input, len);
-    return XXH64_digest(&state);
-#else
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if (XXH_FORCE_ALIGN_CHECK) {
-        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
-            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
-            else
-                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
-    }   }
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
-    else
-        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
-#endif
-}
-
-/*======   Hash Streaming   ======*/
-
-XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
-{
-    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
-}
-XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
-{
-    XXH_free(statePtr);
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dstState, const XXH64_state_t* srcState)
-{
-    memcpy(dstState, srcState, sizeof(*dstState));
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
-{
-    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state));
-    state.v1 = seed + PRIME64_1 + PRIME64_2;
-    state.v2 = seed + PRIME64_2;
-    state.v3 = seed + 0;
-    state.v4 = seed - PRIME64_1;
-     /* do not write into reserved, planned to be removed in a future version */
-    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
-    return XXH_OK;
-}
-
-FORCE_INLINE XXH_errorcode
-XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
-{
-    if (input==NULL)
-#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
-        return XXH_OK;
-#else
-        return XXH_ERROR;
-#endif
-
-    {   const BYTE* p = (const BYTE*)input;
-        const BYTE* const bEnd = p + len;
-
-        state->total_len += len;
-
-        if (state->memsize + len < 32) {  /* fill in tmp buffer */
-            XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
-            state->memsize += (U32)len;
-            return XXH_OK;
-        }
-
-        if (state->memsize) {   /* tmp buffer is full */
-            XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
-            state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian));
-            state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian));
-            state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian));
-            state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian));
-            p += 32-state->memsize;
-            state->memsize = 0;
-        }
-
-        if (p+32 <= bEnd) {
-            const BYTE* const limit = bEnd - 32;
-            U64 v1 = state->v1;
-            U64 v2 = state->v2;
-            U64 v3 = state->v3;
-            U64 v4 = state->v4;
-
-            do {
-                v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8;
-                v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8;
-                v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8;
-                v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8;
-            } while (p<=limit);
-
-            state->v1 = v1;
-            state->v2 = v2;
-            state->v3 = v3;
-            state->v4 = v4;
-        }
-
-        if (p < bEnd) {
-            XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
-            state->memsize = (unsigned)(bEnd-p);
-        }
-    }
-
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
-    else
-        return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
-}
-
-FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian)
-{
-    U64 h64;
-
-    if (state->total_len >= 32) {
-        U64 const v1 = state->v1;
-        U64 const v2 = state->v2;
-        U64 const v3 = state->v3;
-        U64 const v4 = state->v4;
-
-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
-        h64 = XXH64_mergeRound(h64, v1);
-        h64 = XXH64_mergeRound(h64, v2);
-        h64 = XXH64_mergeRound(h64, v3);
-        h64 = XXH64_mergeRound(h64, v4);
-    } else {
-        h64  = state->v3 /*seed*/ + PRIME64_5;
-    }
-
-    h64 += (U64) state->total_len;
-
-    return XXH64_finalize(h64, state->mem64, (size_t)state->total_len, endian, XXH_aligned);
-}
-
-XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_digest_endian(state_in, XXH_littleEndian);
-    else
-        return XXH64_digest_endian(state_in, XXH_bigEndian);
-}
-
-
-/*====== Canonical representation   ======*/
-
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
-{
-    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
-    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
-    memcpy(dst, &hash, sizeof(*dst));
-}
-
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
-{
-    return XXH_readBE64(src);
-}
-
-#endif  /* XXH_NO_LONG_LONG */
diff --git a/thirdparty/lz4/xxhash.h b/thirdparty/lz4/xxhash.h
deleted file mode 100644
index d6bad94..0000000
--- a/thirdparty/lz4/xxhash.h
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
-   xxHash - Extremely Fast Hash algorithm
-   Header File
-   Copyright (C) 2012-2016, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - xxHash source repository : https://github.com/Cyan4973/xxHash
-*/
-
-/* Notice extracted from xxHash homepage :
-
-xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
-It also successfully passes all tests from the SMHasher suite.
-
-Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
-
-Name            Speed       Q.Score   Author
-xxHash          5.4 GB/s     10
-CrapWow         3.2 GB/s      2       Andrew
-MumurHash 3a    2.7 GB/s     10       Austin Appleby
-SpookyHash      2.0 GB/s     10       Bob Jenkins
-SBox            1.4 GB/s      9       Bret Mulvey
-Lookup3         1.2 GB/s      9       Bob Jenkins
-SuperFastHash   1.2 GB/s      1       Paul Hsieh
-CityHash64      1.05 GB/s    10       Pike & Alakuijala
-FNV             0.55 GB/s     5       Fowler, Noll, Vo
-CRC32           0.43 GB/s     9
-MD5-32          0.33 GB/s    10       Ronald L. Rivest
-SHA1-32         0.28 GB/s    10
-
-Q.Score is a measure of quality of the hash function.
-It depends on successfully passing SMHasher test set.
-10 is a perfect score.
-
-A 64-bit version, named XXH64, is available since r35.
-It offers much better speed, but for 64-bit applications only.
-Name     Speed on 64 bits    Speed on 32 bits
-XXH64       13.8 GB/s            1.9 GB/s
-XXH32        6.8 GB/s            6.0 GB/s
-*/
-
-#ifndef XXHASH_H_5627135585666179
-#define XXHASH_H_5627135585666179 1
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************
-*  Definitions
-******************************/
-#include <stddef.h>   /* size_t */
-typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
-
-
-/* ****************************
- *  API modifier
- ******************************/
-/** XXH_INLINE_ALL (and XXH_PRIVATE_API)
- *  This is useful to include xxhash functions in `static` mode
- *  in order to inline them, and remove their symbol from the public list.
- *  Inlining can offer dramatic performance improvement on small keys.
- *  Methodology :
- *     #define XXH_INLINE_ALL
- *     #include "xxhash.h"
- * `xxhash.c` is automatically included.
- *  It's not useful to compile and link it as a separate module.
- */
-#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
-#  ifndef XXH_STATIC_LINKING_ONLY
-#    define XXH_STATIC_LINKING_ONLY
-#  endif
-#  if defined(__GNUC__)
-#    define XXH_PUBLIC_API static __inline __attribute__((unused))
-#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#    define XXH_PUBLIC_API static inline
-#  elif defined(_MSC_VER)
-#    define XXH_PUBLIC_API static __inline
-#  else
-     /* this version may generate warnings for unused static functions */
-#    define XXH_PUBLIC_API static
-#  endif
-#else
-#  define XXH_PUBLIC_API   /* do nothing */
-#endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */
-
-/*! XXH_NAMESPACE, aka Namespace Emulation :
- *
- * If you want to include _and expose_ xxHash functions from within your own library,
- * but also want to avoid symbol collisions with other libraries which may also include xxHash,
- *
- * you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
- * with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values).
- *
- * Note that no change is required within the calling program as long as it includes `xxhash.h` :
- * regular symbol name will be automatically translated by this header.
- */
-#ifdef XXH_NAMESPACE
-#  define XXH_CAT(A,B) A##B
-#  define XXH_NAME2(A,B) XXH_CAT(A,B)
-#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
-#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
-#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
-#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
-#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
-#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
-#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
-#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
-#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
-#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
-#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
-#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
-#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
-#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
-#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
-#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
-#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
-#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
-#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
-#endif
-
-
-/* *************************************
-*  Version
-***************************************/
-#define XXH_VERSION_MAJOR    0
-#define XXH_VERSION_MINOR    6
-#define XXH_VERSION_RELEASE  5
-#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
-XXH_PUBLIC_API unsigned XXH_versionNumber (void);
-
-
-/*-**********************************************************************
-*  32-bit hash
-************************************************************************/
-typedef unsigned int XXH32_hash_t;
-
-/*! XXH32() :
-    Calculate the 32-bit hash of sequence "length" bytes stored at memory address "input".
-    The memory between input & input+length must be valid (allocated and read-accessible).
-    "seed" can be used to alter the result predictably.
-    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s */
-XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
-
-/*======   Streaming   ======*/
-typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
-XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
-XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
-XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);
-
-XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
-XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
-
-/*
- * Streaming functions generate the xxHash of an input provided in multiple segments.
- * Note that, for small input, they are slower than single-call functions, due to state management.
- * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.
- *
- * XXH state must first be allocated, using XXH*_createState() .
- *
- * Start a new hash by initializing state with a seed, using XXH*_reset().
- *
- * Then, feed the hash state by calling XXH*_update() as many times as necessary.
- * The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
- *
- * Finally, a hash value can be produced anytime, by using XXH*_digest().
- * This function returns the nn-bits hash as an int or long long.
- *
- * It's still possible to continue inserting input into the hash state after a digest,
- * and generate some new hashes later on, by calling again XXH*_digest().
- *
- * When done, free XXH state space if it was allocated dynamically.
- */
-
-/*======   Canonical representation   ======*/
-
-typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
-XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
-XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
-
-/* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
- * The canonical representation uses human-readable write convention, aka big-endian (large digits first).
- * These functions allow transformation of hash result into and from its canonical format.
- * This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
- */
-
-
-#ifndef XXH_NO_LONG_LONG
-/*-**********************************************************************
-*  64-bit hash
-************************************************************************/
-typedef unsigned long long XXH64_hash_t;
-
-/*! XXH64() :
-    Calculate the 64-bit hash of sequence of length "len" stored at memory address "input".
-    "seed" can be used to alter the result predictably.
-    This function runs faster on 64-bit systems, but slower on 32-bit systems (see benchmark).
-*/
-XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
-
-/*======   Streaming   ======*/
-typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
-XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
-XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
-XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
-
-XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
-XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
-
-/*======   Canonical representation   ======*/
-typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
-#endif  /* XXH_NO_LONG_LONG */
-
-
-
-#ifdef XXH_STATIC_LINKING_ONLY
-
-/* ================================================================================================
-   This section contains declarations which are not guaranteed to remain stable.
-   They may change in future versions, becoming incompatible with a different version of the library.
-   These declarations should only be used with static linking.
-   Never use them in association with dynamic linking !
-=================================================================================================== */
-
-/* These definitions are only present to allow
- * static allocation of XXH state, on stack or in a struct for example.
- * Never **ever** use members directly. */
-
-#if !defined (__VMS) \
-  && (defined (__cplusplus) \
-  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-#   include <stdint.h>
-
-struct XXH32_state_s {
-   uint32_t total_len_32;
-   uint32_t large_len;
-   uint32_t v1;
-   uint32_t v2;
-   uint32_t v3;
-   uint32_t v4;
-   uint32_t mem32[4];
-   uint32_t memsize;
-   uint32_t reserved;   /* never read nor write, might be removed in a future version */
-};   /* typedef'd to XXH32_state_t */
-
-struct XXH64_state_s {
-   uint64_t total_len;
-   uint64_t v1;
-   uint64_t v2;
-   uint64_t v3;
-   uint64_t v4;
-   uint64_t mem64[4];
-   uint32_t memsize;
-   uint32_t reserved[2];          /* never read nor write, might be removed in a future version */
-};   /* typedef'd to XXH64_state_t */
-
-# else
-
-struct XXH32_state_s {
-   unsigned total_len_32;
-   unsigned large_len;
-   unsigned v1;
-   unsigned v2;
-   unsigned v3;
-   unsigned v4;
-   unsigned mem32[4];
-   unsigned memsize;
-   unsigned reserved;   /* never read nor write, might be removed in a future version */
-};   /* typedef'd to XXH32_state_t */
-
-#   ifndef XXH_NO_LONG_LONG  /* remove 64-bit support */
-struct XXH64_state_s {
-   unsigned long long total_len;
-   unsigned long long v1;
-   unsigned long long v2;
-   unsigned long long v3;
-   unsigned long long v4;
-   unsigned long long mem64[4];
-   unsigned memsize;
-   unsigned reserved[2];     /* never read nor write, might be removed in a future version */
-};   /* typedef'd to XXH64_state_t */
-#    endif
-
-# endif
-
-
-#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
-#  include "xxhash.c"   /* include xxhash function bodies as `static`, for inlining */
-#endif
-
-#endif /* XXH_STATIC_LINKING_ONLY */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* XXHASH_H_5627135585666179 */
diff --git a/thirdparty/rapidjson/allocators.h b/thirdparty/rapidjson/allocators.h
deleted file mode 100644
index 3ec83c1..0000000
--- a/thirdparty/rapidjson/allocators.h
+++ /dev/null
@@ -1,692 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ALLOCATORS_H_
-#define RAPIDJSON_ALLOCATORS_H_
-
-#include "rapidjson.h"
-#include "internal/meta.h"
-
-#include <memory>
-
-#if RAPIDJSON_HAS_CXX11
-#include <type_traits>
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Allocator
-
-/*! \class rapidjson::Allocator
-    \brief Concept for allocating, resizing and freeing memory block.
-    
-    Note that Malloc() and Realloc() are non-static but Free() is static.
-    
-    So if an allocator need to support Free(), it needs to put its pointer in 
-    the header of memory block.
-
-\code
-concept Allocator {
-    static const bool kNeedFree;    //!< Whether this allocator needs to call Free().
-
-    // Allocate a memory block.
-    // \param size of the memory block in bytes.
-    // \returns pointer to the memory block.
-    void* Malloc(size_t size);
-
-    // Resize a memory block.
-    // \param originalPtr The pointer to current memory block. Null pointer is permitted.
-    // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.)
-    // \param newSize the new size in bytes.
-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize);
-
-    // Free a memory block.
-    // \param pointer to the memory block. Null pointer is permitted.
-    static void Free(void *ptr);
-};
-\endcode
-*/
-
-
-/*! \def RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-defined kDefaultChunkCapacity definition.
-
-    User can define this as any \c size that is a power of 2.
-*/
-
-#ifndef RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
-#define RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024)
-#endif
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CrtAllocator
-
-//! C-runtime library allocator.
-/*! This class is just wrapper for standard C library memory routines.
-    \note implements Allocator concept
-*/
-class CrtAllocator {
-public:
-    static const bool kNeedFree = true;
-    void* Malloc(size_t size) { 
-        if (size) //  behavior of malloc(0) is implementation defined.
-            return RAPIDJSON_MALLOC(size);
-        else
-            return NULL; // standardize to returning NULL.
-    }
-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
-        (void)originalSize;
-        if (newSize == 0) {
-            RAPIDJSON_FREE(originalPtr);
-            return NULL;
-        }
-        return RAPIDJSON_REALLOC(originalPtr, newSize);
-    }
-    static void Free(void *ptr) RAPIDJSON_NOEXCEPT { RAPIDJSON_FREE(ptr); }
-
-    bool operator==(const CrtAllocator&) const RAPIDJSON_NOEXCEPT {
-        return true;
-    }
-    bool operator!=(const CrtAllocator&) const RAPIDJSON_NOEXCEPT {
-        return false;
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// MemoryPoolAllocator
-
-//! Default memory allocator used by the parser and DOM.
-/*! This allocator allocate memory blocks from pre-allocated memory chunks. 
-
-    It does not free memory blocks. And Realloc() only allocate new memory.
-
-    The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.
-
-    User may also supply a buffer as the first chunk.
-
-    If the user-buffer is full then additional chunks are allocated by BaseAllocator.
-
-    The user-buffer is not deallocated by this allocator.
-
-    \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator.
-    \note implements Allocator concept
-*/
-template <typename BaseAllocator = CrtAllocator>
-class MemoryPoolAllocator {
-    //! Chunk header for perpending to each chunk.
-    /*! Chunks are stored as a singly linked list.
-    */
-    struct ChunkHeader {
-        size_t capacity;    //!< Capacity of the chunk in bytes (excluding the header itself).
-        size_t size;        //!< Current size of allocated memory in bytes.
-        ChunkHeader *next;  //!< Next chunk in the linked list.
-    };
-
-    struct SharedData {
-        ChunkHeader *chunkHead;  //!< Head of the chunk linked-list. Only the head chunk serves allocation.
-        BaseAllocator* ownBaseAllocator; //!< base allocator created by this object.
-        size_t refcount;
-        bool ownBuffer;
-    };
-
-    static const size_t SIZEOF_SHARED_DATA = RAPIDJSON_ALIGN(sizeof(SharedData));
-    static const size_t SIZEOF_CHUNK_HEADER = RAPIDJSON_ALIGN(sizeof(ChunkHeader));
-
-    static inline ChunkHeader *GetChunkHead(SharedData *shared)
-    {
-        return reinterpret_cast<ChunkHeader*>(reinterpret_cast<uint8_t*>(shared) + SIZEOF_SHARED_DATA);
-    }
-    static inline uint8_t *GetChunkBuffer(SharedData *shared)
-    {
-        return reinterpret_cast<uint8_t*>(shared->chunkHead) + SIZEOF_CHUNK_HEADER;
-    }
-
-    static const size_t kDefaultChunkCapacity = RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< Default chunk capacity.
-
-public:
-    static const bool kNeedFree = false;    //!< Tell users that no need to call Free() with this allocator. (concept Allocator)
-    static const bool kRefCounted = true;   //!< Tell users that this allocator is reference counted on copy
-
-    //! Constructor with chunkSize.
-    /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
-        \param baseAllocator The allocator for allocating memory chunks.
-    */
-    explicit
-    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 
-        chunk_capacity_(chunkSize),
-        baseAllocator_(baseAllocator ? baseAllocator : RAPIDJSON_NEW(BaseAllocator)()),
-        shared_(static_cast<SharedData*>(baseAllocator_ ? baseAllocator_->Malloc(SIZEOF_SHARED_DATA + SIZEOF_CHUNK_HEADER) : 0))
-    {
-        RAPIDJSON_ASSERT(baseAllocator_ != 0);
-        RAPIDJSON_ASSERT(shared_ != 0);
-        if (baseAllocator) {
-            shared_->ownBaseAllocator = 0;
-        }
-        else {
-            shared_->ownBaseAllocator = baseAllocator_;
-        }
-        shared_->chunkHead = GetChunkHead(shared_);
-        shared_->chunkHead->capacity = 0;
-        shared_->chunkHead->size = 0;
-        shared_->chunkHead->next = 0;
-        shared_->ownBuffer = true;
-        shared_->refcount = 1;
-    }
-
-    //! Constructor with user-supplied buffer.
-    /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.
-
-        The user buffer will not be deallocated when this allocator is destructed.
-
-        \param buffer User supplied buffer.
-        \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
-        \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
-        \param baseAllocator The allocator for allocating memory chunks.
-    */
-    MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) :
-        chunk_capacity_(chunkSize),
-        baseAllocator_(baseAllocator),
-        shared_(static_cast<SharedData*>(AlignBuffer(buffer, size)))
-    {
-        RAPIDJSON_ASSERT(size >= SIZEOF_SHARED_DATA + SIZEOF_CHUNK_HEADER);
-        shared_->chunkHead = GetChunkHead(shared_);
-        shared_->chunkHead->capacity = size - SIZEOF_SHARED_DATA - SIZEOF_CHUNK_HEADER;
-        shared_->chunkHead->size = 0;
-        shared_->chunkHead->next = 0;
-        shared_->ownBaseAllocator = 0;
-        shared_->ownBuffer = false;
-        shared_->refcount = 1;
-    }
-
-    MemoryPoolAllocator(const MemoryPoolAllocator& rhs) RAPIDJSON_NOEXCEPT :
-        chunk_capacity_(rhs.chunk_capacity_),
-        baseAllocator_(rhs.baseAllocator_),
-        shared_(rhs.shared_)
-    {
-        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
-        ++shared_->refcount;
-    }
-    MemoryPoolAllocator& operator=(const MemoryPoolAllocator& rhs) RAPIDJSON_NOEXCEPT
-    {
-        RAPIDJSON_NOEXCEPT_ASSERT(rhs.shared_->refcount > 0);
-        ++rhs.shared_->refcount;
-        this->~MemoryPoolAllocator();
-        baseAllocator_ = rhs.baseAllocator_;
-        chunk_capacity_ = rhs.chunk_capacity_;
-        shared_ = rhs.shared_;
-        return *this;
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    MemoryPoolAllocator(MemoryPoolAllocator&& rhs) RAPIDJSON_NOEXCEPT :
-        chunk_capacity_(rhs.chunk_capacity_),
-        baseAllocator_(rhs.baseAllocator_),
-        shared_(rhs.shared_)
-    {
-        RAPIDJSON_NOEXCEPT_ASSERT(rhs.shared_->refcount > 0);
-        rhs.shared_ = 0;
-    }
-    MemoryPoolAllocator& operator=(MemoryPoolAllocator&& rhs) RAPIDJSON_NOEXCEPT
-    {
-        RAPIDJSON_NOEXCEPT_ASSERT(rhs.shared_->refcount > 0);
-        this->~MemoryPoolAllocator();
-        baseAllocator_ = rhs.baseAllocator_;
-        chunk_capacity_ = rhs.chunk_capacity_;
-        shared_ = rhs.shared_;
-        rhs.shared_ = 0;
-        return *this;
-    }
-#endif
-
-    //! Destructor.
-    /*! This deallocates all memory chunks, excluding the user-supplied buffer.
-    */
-    ~MemoryPoolAllocator() RAPIDJSON_NOEXCEPT {
-        if (!shared_) {
-            // do nothing if moved
-            return;
-        }
-        if (shared_->refcount > 1) {
-            --shared_->refcount;
-            return;
-        }
-        Clear();
-        BaseAllocator *a = shared_->ownBaseAllocator;
-        if (shared_->ownBuffer) {
-            baseAllocator_->Free(shared_);
-        }
-        RAPIDJSON_DELETE(a);
-    }
-
-    //! Deallocates all memory chunks, excluding the first/user one.
-    void Clear() RAPIDJSON_NOEXCEPT {
-        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
-        for (;;) {
-            ChunkHeader* c = shared_->chunkHead;
-            if (!c->next) {
-                break;
-            }
-            shared_->chunkHead = c->next;
-            baseAllocator_->Free(c);
-        }
-        shared_->chunkHead->size = 0;
-    }
-
-    //! Computes the total capacity of allocated memory chunks.
-    /*! \return total capacity in bytes.
-    */
-    size_t Capacity() const RAPIDJSON_NOEXCEPT {
-        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
-        size_t capacity = 0;
-        for (ChunkHeader* c = shared_->chunkHead; c != 0; c = c->next)
-            capacity += c->capacity;
-        return capacity;
-    }
-
-    //! Computes the memory blocks allocated.
-    /*! \return total used bytes.
-    */
-    size_t Size() const RAPIDJSON_NOEXCEPT {
-        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
-        size_t size = 0;
-        for (ChunkHeader* c = shared_->chunkHead; c != 0; c = c->next)
-            size += c->size;
-        return size;
-    }
-
-    //! Whether the allocator is shared.
-    /*! \return true or false.
-    */
-    bool Shared() const RAPIDJSON_NOEXCEPT {
-        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
-        return shared_->refcount > 1;
-    }
-
-    //! Allocates a memory block. (concept Allocator)
-    void* Malloc(size_t size) {
-        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
-        if (!size)
-            return NULL;
-
-        size = RAPIDJSON_ALIGN(size);
-        if (RAPIDJSON_UNLIKELY(shared_->chunkHead->size + size > shared_->chunkHead->capacity))
-            if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
-                return NULL;
-
-        void *buffer = GetChunkBuffer(shared_) + shared_->chunkHead->size;
-        shared_->chunkHead->size += size;
-        return buffer;
-    }
-
-    //! Resizes a memory block (concept Allocator)
-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
-        if (originalPtr == 0)
-            return Malloc(newSize);
-
-        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
-        if (newSize == 0)
-            return NULL;
-
-        originalSize = RAPIDJSON_ALIGN(originalSize);
-        newSize = RAPIDJSON_ALIGN(newSize);
-
-        // Do not shrink if new size is smaller than original
-        if (originalSize >= newSize)
-            return originalPtr;
-
-        // Simply expand it if it is the last allocation and there is sufficient space
-        if (originalPtr == GetChunkBuffer(shared_) + shared_->chunkHead->size - originalSize) {
-            size_t increment = static_cast<size_t>(newSize - originalSize);
-            if (shared_->chunkHead->size + increment <= shared_->chunkHead->capacity) {
-                shared_->chunkHead->size += increment;
-                return originalPtr;
-            }
-        }
-
-        // Realloc process: allocate and copy memory, do not free original buffer.
-        if (void* newBuffer = Malloc(newSize)) {
-            if (originalSize)
-                std::memcpy(newBuffer, originalPtr, originalSize);
-            return newBuffer;
-        }
-        else
-            return NULL;
-    }
-
-    //! Frees a memory block (concept Allocator)
-    static void Free(void *ptr) RAPIDJSON_NOEXCEPT { (void)ptr; } // Do nothing
-
-    //! Compare (equality) with another MemoryPoolAllocator
-    bool operator==(const MemoryPoolAllocator& rhs) const RAPIDJSON_NOEXCEPT {
-        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
-        RAPIDJSON_NOEXCEPT_ASSERT(rhs.shared_->refcount > 0);
-        return shared_ == rhs.shared_;
-    }
-    //! Compare (inequality) with another MemoryPoolAllocator
-    bool operator!=(const MemoryPoolAllocator& rhs) const RAPIDJSON_NOEXCEPT {
-        return !operator==(rhs);
-    }
-
-private:
-    //! Creates a new chunk.
-    /*! \param capacity Capacity of the chunk in bytes.
-        \return true if success.
-    */
-    bool AddChunk(size_t capacity) {
-        if (!baseAllocator_)
-            shared_->ownBaseAllocator = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator)();
-        if (ChunkHeader* chunk = static_cast<ChunkHeader*>(baseAllocator_->Malloc(SIZEOF_CHUNK_HEADER + capacity))) {
-            chunk->capacity = capacity;
-            chunk->size = 0;
-            chunk->next = shared_->chunkHead;
-            shared_->chunkHead = chunk;
-            return true;
-        }
-        else
-            return false;
-    }
-
-    static inline void* AlignBuffer(void* buf, size_t &size)
-    {
-        RAPIDJSON_NOEXCEPT_ASSERT(buf != 0);
-        const uintptr_t mask = sizeof(void*) - 1;
-        const uintptr_t ubuf = reinterpret_cast<uintptr_t>(buf);
-        if (RAPIDJSON_UNLIKELY(ubuf & mask)) {
-            const uintptr_t abuf = (ubuf + mask) & ~mask;
-            RAPIDJSON_ASSERT(size >= abuf - ubuf);
-            buf = reinterpret_cast<void*>(abuf);
-            size -= abuf - ubuf;
-        }
-        return buf;
-    }
-
-    size_t chunk_capacity_;     //!< The minimum capacity of chunk when they are allocated.
-    BaseAllocator* baseAllocator_;  //!< base allocator for allocating memory chunks.
-    SharedData *shared_;        //!< The shared data of the allocator
-};
-
-namespace internal {
-    template<typename, typename = void>
-    struct IsRefCounted :
-        public FalseType
-    { };
-    template<typename T>
-    struct IsRefCounted<T, typename internal::EnableIfCond<T::kRefCounted>::Type> :
-        public TrueType
-    { };
-}
-
-template<typename T, typename A>
-inline T* Realloc(A& a, T* old_p, size_t old_n, size_t new_n)
-{
-    RAPIDJSON_NOEXCEPT_ASSERT(old_n <= SIZE_MAX / sizeof(T) && new_n <= SIZE_MAX / sizeof(T));
-    return static_cast<T*>(a.Realloc(old_p, old_n * sizeof(T), new_n * sizeof(T)));
-}
-
-template<typename T, typename A>
-inline T *Malloc(A& a, size_t n = 1)
-{
-    return Realloc<T, A>(a, NULL, 0, n);
-}
-
-template<typename T, typename A>
-inline void Free(A& a, T *p, size_t n = 1)
-{
-    static_cast<void>(Realloc<T, A>(a, p, n, 0));
-}
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++) // std::allocator can safely be inherited
-#endif
-
-template <typename T, typename BaseAllocator = CrtAllocator>
-class StdAllocator :
-    public std::allocator<T>
-{
-    typedef std::allocator<T> allocator_type;
-#if RAPIDJSON_HAS_CXX11
-    typedef std::allocator_traits<allocator_type> traits_type;
-#else
-    typedef allocator_type traits_type;
-#endif
-
-public:
-    typedef BaseAllocator BaseAllocatorType;
-
-    StdAllocator() RAPIDJSON_NOEXCEPT :
-        allocator_type(),
-        baseAllocator_()
-    { }
-
-    StdAllocator(const StdAllocator& rhs) RAPIDJSON_NOEXCEPT :
-        allocator_type(rhs),
-        baseAllocator_(rhs.baseAllocator_)
-    { }
-
-    template<typename U>
-    StdAllocator(const StdAllocator<U, BaseAllocator>& rhs) RAPIDJSON_NOEXCEPT :
-        allocator_type(rhs),
-        baseAllocator_(rhs.baseAllocator_)
-    { }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    StdAllocator(StdAllocator&& rhs) RAPIDJSON_NOEXCEPT :
-        allocator_type(std::move(rhs)),
-        baseAllocator_(std::move(rhs.baseAllocator_))
-    { }
-#endif
-#if RAPIDJSON_HAS_CXX11
-    using propagate_on_container_move_assignment = std::true_type;
-    using propagate_on_container_swap = std::true_type;
-#endif
-
-    /* implicit */
-    StdAllocator(const BaseAllocator& allocator) RAPIDJSON_NOEXCEPT :
-        allocator_type(),
-        baseAllocator_(allocator)
-    { }
-
-    ~StdAllocator() RAPIDJSON_NOEXCEPT
-    { }
-
-    template<typename U>
-    struct rebind {
-        typedef StdAllocator<U, BaseAllocator> other;
-    };
-
-    typedef typename traits_type::size_type         size_type;
-    typedef typename traits_type::difference_type   difference_type;
-
-    typedef typename traits_type::value_type        value_type;
-    typedef typename traits_type::pointer           pointer;
-    typedef typename traits_type::const_pointer     const_pointer;
-
-#if RAPIDJSON_HAS_CXX11
-
-    typedef typename std::add_lvalue_reference<value_type>::type &reference;
-    typedef typename std::add_lvalue_reference<typename std::add_const<value_type>::type>::type &const_reference;
-
-    pointer address(reference r) const RAPIDJSON_NOEXCEPT
-    {
-        return std::addressof(r);
-    }
-    const_pointer address(const_reference r) const RAPIDJSON_NOEXCEPT
-    {
-        return std::addressof(r);
-    }
-
-    size_type max_size() const RAPIDJSON_NOEXCEPT
-    {
-        return traits_type::max_size(*this);
-    }
-
-    template <typename ...Args>
-    void construct(pointer p, Args&&... args)
-    {
-        traits_type::construct(*this, p, std::forward<Args>(args)...);
-    }
-    void destroy(pointer p)
-    {
-        traits_type::destroy(*this, p);
-    }
-
-#else // !RAPIDJSON_HAS_CXX11
-
-    typedef typename allocator_type::reference       reference;
-    typedef typename allocator_type::const_reference const_reference;
-
-    pointer address(reference r) const RAPIDJSON_NOEXCEPT
-    {
-        return allocator_type::address(r);
-    }
-    const_pointer address(const_reference r) const RAPIDJSON_NOEXCEPT
-    {
-        return allocator_type::address(r);
-    }
-
-    size_type max_size() const RAPIDJSON_NOEXCEPT
-    {
-        return allocator_type::max_size();
-    }
-
-    void construct(pointer p, const_reference r)
-    {
-        allocator_type::construct(p, r);
-    }
-    void destroy(pointer p)
-    {
-        allocator_type::destroy(p);
-    }
-
-#endif // !RAPIDJSON_HAS_CXX11
-
-    template <typename U>
-    U* allocate(size_type n = 1, const void* = 0)
-    {
-        return RAPIDJSON_NAMESPACE::Malloc<U>(baseAllocator_, n);
-    }
-    template <typename U>
-    void deallocate(U* p, size_type n = 1)
-    {
-        RAPIDJSON_NAMESPACE::Free<U>(baseAllocator_, p, n);
-    }
-
-    pointer allocate(size_type n = 1, const void* = 0)
-    {
-        return allocate<value_type>(n);
-    }
-    void deallocate(pointer p, size_type n = 1)
-    {
-        deallocate<value_type>(p, n);
-    }
-
-#if RAPIDJSON_HAS_CXX11
-    using is_always_equal = std::is_empty<BaseAllocator>;
-#endif
-
-    template<typename U>
-    bool operator==(const StdAllocator<U, BaseAllocator>& rhs) const RAPIDJSON_NOEXCEPT
-    {
-        return baseAllocator_ == rhs.baseAllocator_;
-    }
-    template<typename U>
-    bool operator!=(const StdAllocator<U, BaseAllocator>& rhs) const RAPIDJSON_NOEXCEPT
-    {
-        return !operator==(rhs);
-    }
-
-    //! rapidjson Allocator concept
-    static const bool kNeedFree = BaseAllocator::kNeedFree;
-    static const bool kRefCounted = internal::IsRefCounted<BaseAllocator>::Value;
-    void* Malloc(size_t size)
-    {
-        return baseAllocator_.Malloc(size);
-    }
-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize)
-    {
-        return baseAllocator_.Realloc(originalPtr, originalSize, newSize);
-    }
-    static void Free(void *ptr) RAPIDJSON_NOEXCEPT
-    {
-        BaseAllocator::Free(ptr);
-    }
-
-private:
-    template <typename, typename>
-    friend class StdAllocator; // access to StdAllocator<!T>.*
-
-    BaseAllocator baseAllocator_;
-};
-
-#if !RAPIDJSON_HAS_CXX17 // std::allocator<void> deprecated in C++17
-template <typename BaseAllocator>
-class StdAllocator<void, BaseAllocator> :
-    public std::allocator<void>
-{
-    typedef std::allocator<void> allocator_type;
-
-public:
-    typedef BaseAllocator BaseAllocatorType;
-
-    StdAllocator() RAPIDJSON_NOEXCEPT :
-        allocator_type(),
-        baseAllocator_()
-    { }
-
-    StdAllocator(const StdAllocator& rhs) RAPIDJSON_NOEXCEPT :
-        allocator_type(rhs),
-        baseAllocator_(rhs.baseAllocator_)
-    { }
-
-    template<typename U>
-    StdAllocator(const StdAllocator<U, BaseAllocator>& rhs) RAPIDJSON_NOEXCEPT :
-        allocator_type(rhs),
-        baseAllocator_(rhs.baseAllocator_)
-    { }
-
-    /* implicit */
-    StdAllocator(const BaseAllocator& allocator) RAPIDJSON_NOEXCEPT :
-        allocator_type(),
-        baseAllocator_(allocator)
-    { }
-
-    ~StdAllocator() RAPIDJSON_NOEXCEPT
-    { }
-
-    template<typename U>
-    struct rebind {
-        typedef StdAllocator<U, BaseAllocator> other;
-    };
-
-    typedef typename allocator_type::value_type value_type;
-
-private:
-    template <typename, typename>
-    friend class StdAllocator; // access to StdAllocator<!T>.*
-
-    BaseAllocator baseAllocator_;
-};
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/thirdparty/rapidjson/cursorstreamwrapper.h b/thirdparty/rapidjson/cursorstreamwrapper.h
deleted file mode 100644
index fd6513d..0000000
--- a/thirdparty/rapidjson/cursorstreamwrapper.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_CURSORSTREAMWRAPPER_H_
-#define RAPIDJSON_CURSORSTREAMWRAPPER_H_
-
-#include "stream.h"
-
-#if defined(__GNUC__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-
-//! Cursor stream wrapper for counting line and column number if error exists.
-/*!
-    \tparam InputStream     Any stream that implements Stream Concept
-*/
-template <typename InputStream, typename Encoding = UTF8<> >
-class CursorStreamWrapper : public GenericStreamWrapper<InputStream, Encoding> {
-public:
-    typedef typename Encoding::Ch Ch;
-
-    CursorStreamWrapper(InputStream& is):
-        GenericStreamWrapper<InputStream, Encoding>(is), line_(1), col_(0) {}
-
-    // counting line and column number
-    Ch Take() {
-        Ch ch = this->is_.Take();
-        if(ch == '\n') {
-            line_ ++;
-            col_ = 0;
-        } else {
-            col_ ++;
-        }
-        return ch;
-    }
-
-    //! Get the error line number, if error exists.
-    size_t GetLine() const { return line_; }
-    //! Get the error column number, if error exists.
-    size_t GetColumn() const { return col_; }
-
-private:
-    size_t line_;   //!< Current Line
-    size_t col_;    //!< Current Column
-};
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-RAPIDJSON_DIAG_POP
-#endif
-
-#if defined(__GNUC__)
-RAPIDJSON_DIAG_POP
-#endif
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_CURSORSTREAMWRAPPER_H_
diff --git a/thirdparty/rapidjson/document.h b/thirdparty/rapidjson/document.h
deleted file mode 100644
index 54e2936..0000000
--- a/thirdparty/rapidjson/document.h
+++ /dev/null
@@ -1,3011 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_DOCUMENT_H_
-#define RAPIDJSON_DOCUMENT_H_
-
-/*! \file document.h */
-
-#include "reader.h"
-#include "internal/meta.h"
-#include "internal/strfunc.h"
-#include "memorystream.h"
-#include "encodedstream.h"
-#include <new>      // placement new
-#include <limits>
-#ifdef __cpp_lib_three_way_comparison
-#include <compare>
-#endif
-
-RAPIDJSON_DIAG_PUSH
-#ifdef __clang__
-RAPIDJSON_DIAG_OFF(padded)
-RAPIDJSON_DIAG_OFF(switch-enum)
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_OFF(effc++)
-#endif // __GNUC__
-
-#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
-#include <iterator> // std::random_access_iterator_tag
-#endif
-
-#if RAPIDJSON_USE_MEMBERSMAP
-#include <map> // std::multimap
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-// Forward declaration.
-template <typename Encoding, typename Allocator>
-class GenericValue;
-
-template <typename Encoding, typename Allocator, typename StackAllocator>
-class GenericDocument;
-
-/*! \def RAPIDJSON_DEFAULT_ALLOCATOR
-    \ingroup RAPIDJSON_CONFIG
-    \brief Allows to choose default allocator.
-
-    User can define this to use CrtAllocator or MemoryPoolAllocator.
-*/
-#ifndef RAPIDJSON_DEFAULT_ALLOCATOR
-#define RAPIDJSON_DEFAULT_ALLOCATOR MemoryPoolAllocator<CrtAllocator>
-#endif
-
-/*! \def RAPIDJSON_DEFAULT_STACK_ALLOCATOR
-    \ingroup RAPIDJSON_CONFIG
-    \brief Allows to choose default stack allocator for Document.
-
-    User can define this to use CrtAllocator or MemoryPoolAllocator.
-*/
-#ifndef RAPIDJSON_DEFAULT_STACK_ALLOCATOR
-#define RAPIDJSON_DEFAULT_STACK_ALLOCATOR CrtAllocator
-#endif
-
-/*! \def RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY
-    \ingroup RAPIDJSON_CONFIG
-    \brief User defined kDefaultObjectCapacity value.
-
-    User can define this as any natural number.
-*/
-#ifndef RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY
-// number of objects that rapidjson::Value allocates memory for by default
-#define RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY 16
-#endif
-
-/*! \def RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY
-    \ingroup RAPIDJSON_CONFIG
-    \brief User defined kDefaultArrayCapacity value.
-
-    User can define this as any natural number.
-*/
-#ifndef RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY
-// number of array elements that rapidjson::Value allocates memory for by default
-#define RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY 16
-#endif
-
-//! Name-value pair in a JSON object value.
-/*!
-    This class was internal to GenericValue. It used to be a inner struct.
-    But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct.
-    https://code.google.com/p/rapidjson/issues/detail?id=64
-*/
-template <typename Encoding, typename Allocator> 
-class GenericMember {
-public:
-    GenericValue<Encoding, Allocator> name;     //!< name of member (must be a string)
-    GenericValue<Encoding, Allocator> value;    //!< value of member.
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move constructor in C++11
-    GenericMember(GenericMember&& rhs) RAPIDJSON_NOEXCEPT
-        : name(std::move(rhs.name)),
-          value(std::move(rhs.value))
-    {
-    }
-
-    //! Move assignment in C++11
-    GenericMember& operator=(GenericMember&& rhs) RAPIDJSON_NOEXCEPT {
-        return *this = static_cast<GenericMember&>(rhs);
-    }
-#endif
-
-    //! Assignment with move semantics.
-    /*! \param rhs Source of the assignment. Its name and value will become a null value after assignment.
-    */
-    GenericMember& operator=(GenericMember& rhs) RAPIDJSON_NOEXCEPT {
-        if (RAPIDJSON_LIKELY(this != &rhs)) {
-            name = rhs.name;
-            value = rhs.value;
-        }
-        return *this;
-    }
-
-    // swap() for std::sort() and other potential use in STL.
-    friend inline void swap(GenericMember& a, GenericMember& b) RAPIDJSON_NOEXCEPT {
-        a.name.Swap(b.name);
-        a.value.Swap(b.value);
-    }
-
-private:
-    //! Copy constructor is not permitted.
-    GenericMember(const GenericMember& rhs);
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericMemberIterator
-
-#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
-
-//! (Constant) member iterator for a JSON object value
-/*!
-    \tparam Const Is this a constant iterator?
-    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
-    \tparam Allocator   Allocator type for allocating memory of object, array and string.
-
-    This class implements a Random Access Iterator for GenericMember elements
-    of a GenericValue, see ISO/IEC 14882:2003(E) C++ standard, 24.1 [lib.iterator.requirements].
-
-    \note This iterator implementation is mainly intended to avoid implicit
-        conversions from iterator values to \c NULL,
-        e.g. from GenericValue::FindMember.
-
-    \note Define \c RAPIDJSON_NOMEMBERITERATORCLASS to fall back to a
-        pointer-based implementation, if your platform doesn't provide
-        the C++ <iterator> header.
-
-    \see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator
- */
-template <bool Const, typename Encoding, typename Allocator>
-class GenericMemberIterator {
-
-    friend class GenericValue<Encoding,Allocator>;
-    template <bool, typename, typename> friend class GenericMemberIterator;
-
-    typedef GenericMember<Encoding,Allocator> PlainType;
-    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
-
-public:
-    //! Iterator type itself
-    typedef GenericMemberIterator Iterator;
-    //! Constant iterator type
-    typedef GenericMemberIterator<true,Encoding,Allocator>  ConstIterator;
-    //! Non-constant iterator type
-    typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;
-
-    /** \name std::iterator_traits support */
-    //@{
-    typedef ValueType      value_type;
-    typedef ValueType *    pointer;
-    typedef ValueType &    reference;
-    typedef std::ptrdiff_t difference_type;
-    typedef std::random_access_iterator_tag iterator_category;
-    //@}
-
-    //! Pointer to (const) GenericMember
-    typedef pointer         Pointer;
-    //! Reference to (const) GenericMember
-    typedef reference       Reference;
-    //! Signed integer type (e.g. \c ptrdiff_t)
-    typedef difference_type DifferenceType;
-
-    //! Default constructor (singular value)
-    /*! Creates an iterator pointing to no element.
-        \note All operations, except for comparisons, are undefined on such values.
-     */
-    GenericMemberIterator() : ptr_() {}
-
-    //! Iterator conversions to more const
-    /*!
-        \param it (Non-const) iterator to copy from
-
-        Allows the creation of an iterator from another GenericMemberIterator
-        that is "less const".  Especially, creating a non-constant iterator
-        from a constant iterator are disabled:
-        \li const -> non-const (not ok)
-        \li const -> const (ok)
-        \li non-const -> const (ok)
-        \li non-const -> non-const (ok)
-
-        \note If the \c Const template parameter is already \c false, this
-            constructor effectively defines a regular copy-constructor.
-            Otherwise, the copy constructor is implicitly defined.
-    */
-    GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {}
-    Iterator& operator=(const NonConstIterator & it) { ptr_ = it.ptr_; return *this; }
-
-    //! @name stepping
-    //@{
-    Iterator& operator++(){ ++ptr_; return *this; }
-    Iterator& operator--(){ --ptr_; return *this; }
-    Iterator  operator++(int){ Iterator old(*this); ++ptr_; return old; }
-    Iterator  operator--(int){ Iterator old(*this); --ptr_; return old; }
-    //@}
-
-    //! @name increment/decrement
-    //@{
-    Iterator operator+(DifferenceType n) const { return Iterator(ptr_+n); }
-    Iterator operator-(DifferenceType n) const { return Iterator(ptr_-n); }
-
-    Iterator& operator+=(DifferenceType n) { ptr_+=n; return *this; }
-    Iterator& operator-=(DifferenceType n) { ptr_-=n; return *this; }
-    //@}
-
-    //! @name relations
-    //@{
-    template <bool Const_> bool operator==(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ == that.ptr_; }
-    template <bool Const_> bool operator!=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ != that.ptr_; }
-    template <bool Const_> bool operator<=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ <= that.ptr_; }
-    template <bool Const_> bool operator>=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ >= that.ptr_; }
-    template <bool Const_> bool operator< (const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ < that.ptr_; }
-    template <bool Const_> bool operator> (const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ > that.ptr_; }
-
-#ifdef __cpp_lib_three_way_comparison
-    template <bool Const_> std::strong_ordering operator<=>(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ <=> that.ptr_; }
-#endif
-    //@}
-
-    //! @name dereference
-    //@{
-    Reference operator*() const { return *ptr_; }
-    Pointer   operator->() const { return ptr_; }
-    Reference operator[](DifferenceType n) const { return ptr_[n]; }
-    //@}
-
-    //! Distance
-    DifferenceType operator-(ConstIterator that) const { return ptr_-that.ptr_; }
-
-private:
-    //! Internal constructor from plain pointer
-    explicit GenericMemberIterator(Pointer p) : ptr_(p) {}
-
-    Pointer ptr_; //!< raw pointer
-};
-
-#else // RAPIDJSON_NOMEMBERITERATORCLASS
-
-// class-based member iterator implementation disabled, use plain pointers
-
-template <bool Const, typename Encoding, typename Allocator>
-class GenericMemberIterator;
-
-//! non-const GenericMemberIterator
-template <typename Encoding, typename Allocator>
-class GenericMemberIterator<false,Encoding,Allocator> {
-public:
-    //! use plain pointer as iterator type
-    typedef GenericMember<Encoding,Allocator>* Iterator;
-};
-//! const GenericMemberIterator
-template <typename Encoding, typename Allocator>
-class GenericMemberIterator<true,Encoding,Allocator> {
-public:
-    //! use plain const pointer as iterator type
-    typedef const GenericMember<Encoding,Allocator>* Iterator;
-};
-
-#endif // RAPIDJSON_NOMEMBERITERATORCLASS
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericStringRef
-
-//! Reference to a constant string (not taking a copy)
-/*!
-    \tparam CharType character type of the string
-
-    This helper class is used to automatically infer constant string
-    references for string literals, especially from \c const \b (!)
-    character arrays.
-
-    The main use is for creating JSON string values without copying the
-    source string via an \ref Allocator.  This requires that the referenced
-    string pointers have a sufficient lifetime, which exceeds the lifetime
-    of the associated GenericValue.
-
-    \b Example
-    \code
-    Value v("foo");   // ok, no need to copy & calculate length
-    const char foo[] = "foo";
-    v.SetString(foo); // ok
-
-    const char* bar = foo;
-    // Value x(bar); // not ok, can't rely on bar's lifetime
-    Value x(StringRef(bar)); // lifetime explicitly guaranteed by user
-    Value y(StringRef(bar, 3));  // ok, explicitly pass length
-    \endcode
-
-    \see StringRef, GenericValue::SetString
-*/
-template<typename CharType>
-struct GenericStringRef {
-    typedef CharType Ch; //!< character type of the string
-
-    //! Create string reference from \c const character array
-#ifndef __clang__ // -Wdocumentation
-    /*!
-        This constructor implicitly creates a constant string reference from
-        a \c const character array.  It has better performance than
-        \ref StringRef(const CharType*) by inferring the string \ref length
-        from the array length, and also supports strings containing null
-        characters.
-
-        \tparam N length of the string, automatically inferred
-
-        \param str Constant character array, lifetime assumed to be longer
-            than the use of the string in e.g. a GenericValue
-
-        \post \ref s == str
-
-        \note Constant complexity.
-        \note There is a hidden, private overload to disallow references to
-            non-const character arrays to be created via this constructor.
-            By this, e.g. function-scope arrays used to be filled via
-            \c snprintf are excluded from consideration.
-            In such cases, the referenced string should be \b copied to the
-            GenericValue instead.
-     */
-#endif
-    template<SizeType N>
-    GenericStringRef(const CharType (&str)[N]) RAPIDJSON_NOEXCEPT
-        : s(str), length(N-1) {}
-
-    //! Explicitly create string reference from \c const character pointer
-#ifndef __clang__ // -Wdocumentation
-    /*!
-        This constructor can be used to \b explicitly  create a reference to
-        a constant string pointer.
-
-        \see StringRef(const CharType*)
-
-        \param str Constant character pointer, lifetime assumed to be longer
-            than the use of the string in e.g. a GenericValue
-
-        \post \ref s == str
-
-        \note There is a hidden, private overload to disallow references to
-            non-const character arrays to be created via this constructor.
-            By this, e.g. function-scope arrays used to be filled via
-            \c snprintf are excluded from consideration.
-            In such cases, the referenced string should be \b copied to the
-            GenericValue instead.
-     */
-#endif
-    explicit GenericStringRef(const CharType* str)
-        : s(str), length(NotNullStrLen(str)) {}
-
-    //! Create constant string reference from pointer and length
-#ifndef __clang__ // -Wdocumentation
-    /*! \param str constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
-        \param len length of the string, excluding the trailing NULL terminator
-
-        \post \ref s == str && \ref length == len
-        \note Constant complexity.
-     */
-#endif
-    GenericStringRef(const CharType* str, SizeType len)
-        : s(RAPIDJSON_LIKELY(str) ? str : emptyString), length(len) { RAPIDJSON_ASSERT(str != 0 || len == 0u); }
-
-    GenericStringRef(const GenericStringRef& rhs) : s(rhs.s), length(rhs.length) {}
-
-    //! implicit conversion to plain CharType pointer
-    operator const Ch *() const { return s; }
-
-    const Ch* const s; //!< plain CharType pointer
-    const SizeType length; //!< length of the string (excluding the trailing NULL terminator)
-
-private:
-    SizeType NotNullStrLen(const CharType* str) {
-        RAPIDJSON_ASSERT(str != 0);
-        return internal::StrLen(str);
-    }
-
-    /// Empty string - used when passing in a NULL pointer
-    static const Ch emptyString[];
-
-    //! Disallow construction from non-const array
-    template<SizeType N>
-    GenericStringRef(CharType (&str)[N]) /* = delete */;
-    //! Copy assignment operator not permitted - immutable type
-    GenericStringRef& operator=(const GenericStringRef& rhs) /* = delete */;
-};
-
-template<typename CharType>
-const CharType GenericStringRef<CharType>::emptyString[] = { CharType() };
-
-//! Mark a character pointer as constant string
-/*! Mark a plain character pointer as a "string literal".  This function
-    can be used to avoid copying a character string to be referenced as a
-    value in a JSON GenericValue object, if the string's lifetime is known
-    to be valid long enough.
-    \tparam CharType Character type of the string
-    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
-    \return GenericStringRef string reference object
-    \relatesalso GenericStringRef
-
-    \see GenericValue::GenericValue(StringRefType), GenericValue::operator=(StringRefType), GenericValue::SetString(StringRefType), GenericValue::PushBack(StringRefType, Allocator&), GenericValue::AddMember
-*/
-template<typename CharType>
-inline GenericStringRef<CharType> StringRef(const CharType* str) {
-    return GenericStringRef<CharType>(str);
-}
-
-//! Mark a character pointer as constant string
-/*! Mark a plain character pointer as a "string literal".  This function
-    can be used to avoid copying a character string to be referenced as a
-    value in a JSON GenericValue object, if the string's lifetime is known
-    to be valid long enough.
-
-    This version has better performance with supplied length, and also
-    supports string containing null characters.
-
-    \tparam CharType character type of the string
-    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
-    \param length The length of source string.
-    \return GenericStringRef string reference object
-    \relatesalso GenericStringRef
-*/
-template<typename CharType>
-inline GenericStringRef<CharType> StringRef(const CharType* str, size_t length) {
-    return GenericStringRef<CharType>(str, SizeType(length));
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-//! Mark a string object as constant string
-/*! Mark a string object (e.g. \c std::string) as a "string literal".
-    This function can be used to avoid copying a string to be referenced as a
-    value in a JSON GenericValue object, if the string's lifetime is known
-    to be valid long enough.
-
-    \tparam CharType character type of the string
-    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
-    \return GenericStringRef string reference object
-    \relatesalso GenericStringRef
-    \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-*/
-template<typename CharType>
-inline GenericStringRef<CharType> StringRef(const std::basic_string<CharType>& str) {
-    return GenericStringRef<CharType>(str.data(), SizeType(str.size()));
-}
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericValue type traits
-namespace internal {
-
-template <typename T, typename Encoding = void, typename Allocator = void>
-struct IsGenericValueImpl : FalseType {};
-
-// select candidates according to nested encoding and allocator types
-template <typename T> struct IsGenericValueImpl<T, typename Void<typename T::EncodingType>::Type, typename Void<typename T::AllocatorType>::Type>
-    : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>::Type {};
-
-// helper to match arbitrary GenericValue instantiations, including derived classes
-template <typename T> struct IsGenericValue : IsGenericValueImpl<T>::Type {};
-
-} // namespace internal
-
-///////////////////////////////////////////////////////////////////////////////
-// TypeHelper
-
-namespace internal {
-
-template <typename ValueType, typename T>
-struct TypeHelper {};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, bool> {
-    static bool Is(const ValueType& v) { return v.IsBool(); }
-    static bool Get(const ValueType& v) { return v.GetBool(); }
-    static ValueType& Set(ValueType& v, bool data) { return v.SetBool(data); }
-    static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); }
-};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, int> {
-    static bool Is(const ValueType& v) { return v.IsInt(); }
-    static int Get(const ValueType& v) { return v.GetInt(); }
-    static ValueType& Set(ValueType& v, int data) { return v.SetInt(data); }
-    static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
-};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, unsigned> {
-    static bool Is(const ValueType& v) { return v.IsUint(); }
-    static unsigned Get(const ValueType& v) { return v.GetUint(); }
-    static ValueType& Set(ValueType& v, unsigned data) { return v.SetUint(data); }
-    static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
-};
-
-#ifdef _MSC_VER
-RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int));
-template<typename ValueType>
-struct TypeHelper<ValueType, long> {
-    static bool Is(const ValueType& v) { return v.IsInt(); }
-    static long Get(const ValueType& v) { return v.GetInt(); }
-    static ValueType& Set(ValueType& v, long data) { return v.SetInt(data); }
-    static ValueType& Set(ValueType& v, long data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
-};
-
-RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned));
-template<typename ValueType>
-struct TypeHelper<ValueType, unsigned long> {
-    static bool Is(const ValueType& v) { return v.IsUint(); }
-    static unsigned long Get(const ValueType& v) { return v.GetUint(); }
-    static ValueType& Set(ValueType& v, unsigned long data) { return v.SetUint(data); }
-    static ValueType& Set(ValueType& v, unsigned long data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
-};
-#endif
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, int64_t> {
-    static bool Is(const ValueType& v) { return v.IsInt64(); }
-    static int64_t Get(const ValueType& v) { return v.GetInt64(); }
-    static ValueType& Set(ValueType& v, int64_t data) { return v.SetInt64(data); }
-    static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); }
-};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, uint64_t> {
-    static bool Is(const ValueType& v) { return v.IsUint64(); }
-    static uint64_t Get(const ValueType& v) { return v.GetUint64(); }
-    static ValueType& Set(ValueType& v, uint64_t data) { return v.SetUint64(data); }
-    static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); }
-};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, double> {
-    static bool Is(const ValueType& v) { return v.IsDouble(); }
-    static double Get(const ValueType& v) { return v.GetDouble(); }
-    static ValueType& Set(ValueType& v, double data) { return v.SetDouble(data); }
-    static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); }
-};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, float> {
-    static bool Is(const ValueType& v) { return v.IsFloat(); }
-    static float Get(const ValueType& v) { return v.GetFloat(); }
-    static ValueType& Set(ValueType& v, float data) { return v.SetFloat(data); }
-    static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); }
-};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, const typename ValueType::Ch*> {
-    typedef const typename ValueType::Ch* StringType;
-    static bool Is(const ValueType& v) { return v.IsString(); }
-    static StringType Get(const ValueType& v) { return v.GetString(); }
-    static ValueType& Set(ValueType& v, const StringType data) { return v.SetString(typename ValueType::StringRefType(data)); }
-    static ValueType& Set(ValueType& v, const StringType data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }
-};
-
-#if RAPIDJSON_HAS_STDSTRING
-template<typename ValueType> 
-struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
-    typedef std::basic_string<typename ValueType::Ch> StringType;
-    static bool Is(const ValueType& v) { return v.IsString(); }
-    static StringType Get(const ValueType& v) { return StringType(v.GetString(), v.GetStringLength()); }
-    static ValueType& Set(ValueType& v, const StringType& data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }
-};
-#endif
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, typename ValueType::Array> {
-    typedef typename ValueType::Array ArrayType;
-    static bool Is(const ValueType& v) { return v.IsArray(); }
-    static ArrayType Get(ValueType& v) { return v.GetArray(); }
-    static ValueType& Set(ValueType& v, ArrayType data) { return v = data; }
-    static ValueType& Set(ValueType& v, ArrayType data, typename ValueType::AllocatorType&) { return v = data; }
-};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, typename ValueType::ConstArray> {
-    typedef typename ValueType::ConstArray ArrayType;
-    static bool Is(const ValueType& v) { return v.IsArray(); }
-    static ArrayType Get(const ValueType& v) { return v.GetArray(); }
-};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, typename ValueType::Object> {
-    typedef typename ValueType::Object ObjectType;
-    static bool Is(const ValueType& v) { return v.IsObject(); }
-    static ObjectType Get(ValueType& v) { return v.GetObject(); }
-    static ValueType& Set(ValueType& v, ObjectType data) { return v = data; }
-    static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { return v = data; }
-};
-
-template<typename ValueType> 
-struct TypeHelper<ValueType, typename ValueType::ConstObject> {
-    typedef typename ValueType::ConstObject ObjectType;
-    static bool Is(const ValueType& v) { return v.IsObject(); }
-    static ObjectType Get(const ValueType& v) { return v.GetObject(); }
-};
-
-} // namespace internal
-
-// Forward declarations
-template <bool, typename> class GenericArray;
-template <bool, typename> class GenericObject;
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericValue
-
-//! Represents a JSON value. Use Value for UTF8 encoding and default allocator.
-/*!
-    A JSON value can be one of 7 types. This class is a variant type supporting
-    these types.
-
-    Use the Value if UTF8 and default allocator
-
-    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
-    \tparam Allocator   Allocator type for allocating memory of object, array and string.
-*/
-template <typename Encoding, typename Allocator = RAPIDJSON_DEFAULT_ALLOCATOR >
-class GenericValue {
-public:
-    //! Name-value pair in an object.
-    typedef GenericMember<Encoding, Allocator> Member;
-    typedef Encoding EncodingType;                  //!< Encoding type from template parameter.
-    typedef Allocator AllocatorType;                //!< Allocator type from template parameter.
-    typedef typename Encoding::Ch Ch;               //!< Character type derived from Encoding.
-    typedef GenericStringRef<Ch> StringRefType;     //!< Reference to a constant string
-    typedef typename GenericMemberIterator<false,Encoding,Allocator>::Iterator MemberIterator;  //!< Member iterator for iterating in object.
-    typedef typename GenericMemberIterator<true,Encoding,Allocator>::Iterator ConstMemberIterator;  //!< Constant member iterator for iterating in object.
-    typedef GenericValue* ValueIterator;            //!< Value iterator for iterating in array.
-    typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array.
-    typedef GenericValue<Encoding, Allocator> ValueType;    //!< Value type of itself.
-    typedef GenericArray<false, ValueType> Array;
-    typedef GenericArray<true, ValueType> ConstArray;
-    typedef GenericObject<false, ValueType> Object;
-    typedef GenericObject<true, ValueType> ConstObject;
-
-    //!@name Constructors and destructor.
-    //@{
-
-    //! Default constructor creates a null value.
-    GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move constructor in C++11
-    GenericValue(GenericValue&& rhs) RAPIDJSON_NOEXCEPT : data_(rhs.data_) {
-        rhs.data_.f.flags = kNullFlag; // give up contents
-    }
-#endif
-
-private:
-    //! Copy constructor is not permitted.
-    GenericValue(const GenericValue& rhs);
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Moving from a GenericDocument is not permitted.
-    template <typename StackAllocator>
-    GenericValue(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);
-
-    //! Move assignment from a GenericDocument is not permitted.
-    template <typename StackAllocator>
-    GenericValue& operator=(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);
-#endif
-
-public:
-
-    //! Constructor with JSON value type.
-    /*! This creates a Value of specified type with default content.
-        \param type Type of the value.
-        \note Default content for number is zero.
-    */
-    explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
-        static const uint16_t defaultFlags[] = {
-            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
-            kNumberAnyFlag
-        };
-        RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);
-        data_.f.flags = defaultFlags[type];
-
-        // Use ShortString to store empty string.
-        if (type == kStringType)
-            data_.ss.SetLength(0);
-    }
-
-    //! Explicit copy constructor (with allocator)
-    /*! Creates a copy of a Value by using the given Allocator
-        \tparam SourceAllocator allocator of \c rhs
-        \param rhs Value to copy from (read-only)
-        \param allocator Allocator for allocating copied elements and buffers. Commonly use GenericDocument::GetAllocator().
-        \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer)
-        \see CopyFrom()
-    */
-    template <typename SourceAllocator>
-    GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator, bool copyConstStrings = false) {
-        switch (rhs.GetType()) {
-        case kObjectType:
-            DoCopyMembers(rhs, allocator, copyConstStrings);
-            break;
-        case kArrayType: {
-                SizeType count = rhs.data_.a.size;
-                GenericValue* le = reinterpret_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
-                const GenericValue<Encoding,SourceAllocator>* re = rhs.GetElementsPointer();
-                for (SizeType i = 0; i < count; i++)
-                    new (&le[i]) GenericValue(re[i], allocator, copyConstStrings);
-                data_.f.flags = kArrayFlag;
-                data_.a.size = data_.a.capacity = count;
-                SetElementsPointer(le);
-            }
-            break;
-        case kStringType:
-            if (rhs.data_.f.flags == kConstStringFlag && !copyConstStrings) {
-                data_.f.flags = rhs.data_.f.flags;
-                data_  = *reinterpret_cast<const Data*>(&rhs.data_);
-            }
-            else
-                SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator);
-            break;
-        default:
-            data_.f.flags = rhs.data_.f.flags;
-            data_  = *reinterpret_cast<const Data*>(&rhs.data_);
-            break;
-        }
-    }
-
-    //! Constructor for boolean value.
-    /*! \param b Boolean value
-        \note This constructor is limited to \em real boolean values and rejects
-            implicitly converted types like arbitrary pointers.  Use an explicit cast
-            to \c bool, if you want to construct a boolean JSON value in such cases.
-     */
-#ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen
-    template <typename T>
-    explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame<bool, T>))) RAPIDJSON_NOEXCEPT  // See #472
-#else
-    explicit GenericValue(bool b) RAPIDJSON_NOEXCEPT
-#endif
-        : data_() {
-            // safe-guard against failing SFINAE
-            RAPIDJSON_STATIC_ASSERT((internal::IsSame<bool,T>::Value));
-            data_.f.flags = b ? kTrueFlag : kFalseFlag;
-    }
-
-    //! Constructor for int value.
-    explicit GenericValue(int i) RAPIDJSON_NOEXCEPT : data_() {
-        data_.n.i64 = i;
-        data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag;
-    }
-
-    //! Constructor for unsigned value.
-    explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_() {
-        data_.n.u64 = u; 
-        data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);
-    }
-
-    //! Constructor for int64_t value.
-    explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() {
-        data_.n.i64 = i64;
-        data_.f.flags = kNumberInt64Flag;
-        if (i64 >= 0) {
-            data_.f.flags |= kNumberUint64Flag;
-            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
-                data_.f.flags |= kUintFlag;
-            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
-                data_.f.flags |= kIntFlag;
-        }
-        else if (i64 >= static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
-            data_.f.flags |= kIntFlag;
-    }
-
-    //! Constructor for uint64_t value.
-    explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_() {
-        data_.n.u64 = u64;
-        data_.f.flags = kNumberUint64Flag;
-        if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))
-            data_.f.flags |= kInt64Flag;
-        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
-            data_.f.flags |= kUintFlag;
-        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
-            data_.f.flags |= kIntFlag;
-    }
-
-    //! Constructor for double value.
-    explicit GenericValue(double d) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; }
-
-    //! Constructor for float value.
-    explicit GenericValue(float f) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = static_cast<double>(f); data_.f.flags = kNumberDoubleFlag; }
-
-    //! Constructor for constant string (i.e. do not make a copy of string)
-    GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); }
-
-    //! Constructor for constant string (i.e. do not make a copy of string)
-    explicit GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(s); }
-
-    //! Constructor for copy-string (i.e. do make a copy of string)
-    GenericValue(const Ch* s, SizeType length, Allocator& allocator) : data_() { SetStringRaw(StringRef(s, length), allocator); }
-
-    //! Constructor for copy-string (i.e. do make a copy of string)
-    GenericValue(const Ch*s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Constructor for copy-string from a string object (i.e. do make a copy of string)
-    /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-     */
-    GenericValue(const std::basic_string<Ch>& s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); }
-#endif
-
-    //! Constructor for Array.
-    /*!
-        \param a An array obtained by \c GetArray().
-        \note \c Array is always pass-by-value.
-        \note the source array is moved into this value and the sourec array becomes empty.
-    */
-    GenericValue(Array a) RAPIDJSON_NOEXCEPT : data_(a.value_.data_) {
-        a.value_.data_ = Data();
-        a.value_.data_.f.flags = kArrayFlag;
-    }
-
-    //! Constructor for Object.
-    /*!
-        \param o An object obtained by \c GetObject().
-        \note \c Object is always pass-by-value.
-        \note the source object is moved into this value and the sourec object becomes empty.
-    */
-    GenericValue(Object o) RAPIDJSON_NOEXCEPT : data_(o.value_.data_) {
-        o.value_.data_ = Data();
-        o.value_.data_.f.flags = kObjectFlag;
-    }
-
-    //! Destructor.
-    /*! Need to destruct elements of array, members of object, or copy-string.
-    */
-    ~GenericValue() {
-        // With RAPIDJSON_USE_MEMBERSMAP, the maps need to be destroyed to release
-        // their Allocator if it's refcounted (e.g. MemoryPoolAllocator).
-        if (Allocator::kNeedFree || (RAPIDJSON_USE_MEMBERSMAP+0 &&
-                                     internal::IsRefCounted<Allocator>::Value)) {
-            switch(data_.f.flags) {
-            case kArrayFlag:
-                {
-                    GenericValue* e = GetElementsPointer();
-                    for (GenericValue* v = e; v != e + data_.a.size; ++v)
-                        v->~GenericValue();
-                    if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
-                        Allocator::Free(e);
-                    }
-                }
-                break;
-
-            case kObjectFlag:
-                DoFreeMembers();
-                break;
-
-            case kCopyStringFlag:
-                if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
-                    Allocator::Free(const_cast<Ch*>(GetStringPointer()));
-                }
-                break;
-
-            default:
-                break;  // Do nothing for other types.
-            }
-        }
-    }
-
-    //@}
-
-    //!@name Assignment operators
-    //@{
-
-    //! Assignment with move semantics.
-    /*! \param rhs Source of the assignment. It will become a null value after assignment.
-    */
-    GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
-        if (RAPIDJSON_LIKELY(this != &rhs)) {
-            // Can't destroy "this" before assigning "rhs", otherwise "rhs"
-            // could be used after free if it's an sub-Value of "this",
-            // hence the temporary danse.
-            GenericValue temp;
-            temp.RawAssign(rhs);
-            this->~GenericValue();
-            RawAssign(temp);
-        }
-        return *this;
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move assignment in C++11
-    GenericValue& operator=(GenericValue&& rhs) RAPIDJSON_NOEXCEPT {
-        return *this = rhs.Move();
-    }
-#endif
-
-    //! Assignment of constant string reference (no copy)
-    /*! \param str Constant string reference to be assigned
-        \note This overload is needed to avoid clashes with the generic primitive type assignment overload below.
-        \see GenericStringRef, operator=(T)
-    */
-    GenericValue& operator=(StringRefType str) RAPIDJSON_NOEXCEPT {
-        GenericValue s(str);
-        return *this = s;
-    }
-
-    //! Assignment with primitive types.
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
-        \param value The value to be assigned.
-
-        \note The source type \c T explicitly disallows all pointer types,
-            especially (\c const) \ref Ch*.  This helps avoiding implicitly
-            referencing character strings with insufficient lifetime, use
-            \ref SetString(const Ch*, Allocator&) (for copying) or
-            \ref StringRef() (to explicitly mark the pointer as constant) instead.
-            All other pointer types would implicitly convert to \c bool,
-            use \ref SetBool() instead.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer<T>), (GenericValue&))
-    operator=(T value) {
-        GenericValue v(value);
-        return *this = v;
-    }
-
-    //! Deep-copy assignment from Value
-    /*! Assigns a \b copy of the Value to the current Value object
-        \tparam SourceAllocator Allocator type of \c rhs
-        \param rhs Value to copy from (read-only)
-        \param allocator Allocator to use for copying
-        \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer)
-     */
-    template <typename SourceAllocator>
-    GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator, bool copyConstStrings = false) {
-        RAPIDJSON_ASSERT(static_cast<void*>(this) != static_cast<void const*>(&rhs));
-        this->~GenericValue();
-        new (this) GenericValue(rhs, allocator, copyConstStrings);
-        return *this;
-    }
-
-    //! Exchange the contents of this value with those of other.
-    /*!
-        \param other Another value.
-        \note Constant complexity.
-    */
-    GenericValue& Swap(GenericValue& other) RAPIDJSON_NOEXCEPT {
-        GenericValue temp;
-        temp.RawAssign(*this);
-        RawAssign(other);
-        other.RawAssign(temp);
-        return *this;
-    }
-
-    //! free-standing swap function helper
-    /*!
-        Helper function to enable support for common swap implementation pattern based on \c std::swap:
-        \code
-        void swap(MyClass& a, MyClass& b) {
-            using std::swap;
-            swap(a.value, b.value);
-            // ...
-        }
-        \endcode
-        \see Swap()
-     */
-    friend inline void swap(GenericValue& a, GenericValue& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }
-
-    //! Prepare Value for move semantics
-    /*! \return *this */
-    GenericValue& Move() RAPIDJSON_NOEXCEPT { return *this; }
-    //@}
-
-    //!@name Equal-to and not-equal-to operators
-    //@{
-    //! Equal-to operator
-    /*!
-        \note If an object contains duplicated named member, comparing equality with any object is always \c false.
-        \note Complexity is quadratic in Object's member number and linear for the rest (number of all values in the subtree and total lengths of all strings).
-    */
-    template <typename SourceAllocator>
-    bool operator==(const GenericValue<Encoding, SourceAllocator>& rhs) const {
-        typedef GenericValue<Encoding, SourceAllocator> RhsType;
-        if (GetType() != rhs.GetType())
-            return false;
-
-        switch (GetType()) {
-        case kObjectType: // Warning: O(n^2) inner-loop
-            if (data_.o.size != rhs.data_.o.size)
-                return false;           
-            for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
-                typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
-                if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
-                    return false;
-            }
-            return true;
-            
-        case kArrayType:
-            if (data_.a.size != rhs.data_.a.size)
-                return false;
-            for (SizeType i = 0; i < data_.a.size; i++)
-                if ((*this)[i] != rhs[i])
-                    return false;
-            return true;
-
-        case kStringType:
-            return StringEqual(rhs);
-
-        case kNumberType:
-            if (IsDouble() || rhs.IsDouble()) {
-                double a = GetDouble();     // May convert from integer to double.
-                double b = rhs.GetDouble(); // Ditto
-                return a >= b && a <= b;    // Prevent -Wfloat-equal
-            }
-            else
-                return data_.n.u64 == rhs.data_.n.u64;
-
-        default:
-            return true;
-        }
-    }
-
-    //! Equal-to operator with const C-string pointer
-    bool operator==(const Ch* rhs) const { return *this == GenericValue(StringRef(rhs)); }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Equal-to operator with string object
-    /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-     */
-    bool operator==(const std::basic_string<Ch>& rhs) const { return *this == GenericValue(StringRef(rhs)); }
-#endif
-
-    //! Equal-to operator with primitive types
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c true, \c false
-    */
-    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,internal::IsGenericValue<T> >), (bool)) operator==(const T& rhs) const { return *this == GenericValue(rhs); }
-
-    //! Not-equal-to operator
-    /*! \return !(*this == rhs)
-     */
-    template <typename SourceAllocator>
-    bool operator!=(const GenericValue<Encoding, SourceAllocator>& rhs) const { return !(*this == rhs); }
-
-    //! Not-equal-to operator with const C-string pointer
-    bool operator!=(const Ch* rhs) const { return !(*this == rhs); }
-
-    //! Not-equal-to operator with arbitrary types
-    /*! \return !(*this == rhs)
-     */
-    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& rhs) const { return !(*this == rhs); }
-
-#ifndef __cpp_lib_three_way_comparison
-    //! Equal-to operator with arbitrary types (symmetric version)
-    /*! \return (rhs == lhs)
-     */
-    template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator==(const T& lhs, const GenericValue& rhs) { return rhs == lhs; }
-
-    //! Not-Equal-to operator with arbitrary types (symmetric version)
-    /*! \return !(rhs == lhs)
-     */
-    template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& lhs, const GenericValue& rhs) { return !(rhs == lhs); }
-    //@}
-#endif
-
-    //!@name Type
-    //@{
-
-    Type GetType()  const { return static_cast<Type>(data_.f.flags & kTypeMask); }
-    bool IsNull()   const { return data_.f.flags == kNullFlag; }
-    bool IsFalse()  const { return data_.f.flags == kFalseFlag; }
-    bool IsTrue()   const { return data_.f.flags == kTrueFlag; }
-    bool IsBool()   const { return (data_.f.flags & kBoolFlag) != 0; }
-    bool IsObject() const { return data_.f.flags == kObjectFlag; }
-    bool IsArray()  const { return data_.f.flags == kArrayFlag; }
-    bool IsNumber() const { return (data_.f.flags & kNumberFlag) != 0; }
-    bool IsInt()    const { return (data_.f.flags & kIntFlag) != 0; }
-    bool IsUint()   const { return (data_.f.flags & kUintFlag) != 0; }
-    bool IsInt64()  const { return (data_.f.flags & kInt64Flag) != 0; }
-    bool IsUint64() const { return (data_.f.flags & kUint64Flag) != 0; }
-    bool IsDouble() const { return (data_.f.flags & kDoubleFlag) != 0; }
-    bool IsString() const { return (data_.f.flags & kStringFlag) != 0; }
-
-    // Checks whether a number can be losslessly converted to a double.
-    bool IsLosslessDouble() const {
-        if (!IsNumber()) return false;
-        if (IsUint64()) {
-            uint64_t u = GetUint64();
-            volatile double d = static_cast<double>(u);
-            return (d >= 0.0)
-                && (d < static_cast<double>((std::numeric_limits<uint64_t>::max)()))
-                && (u == static_cast<uint64_t>(d));
-        }
-        if (IsInt64()) {
-            int64_t i = GetInt64();
-            volatile double d = static_cast<double>(i);
-            return (d >= static_cast<double>((std::numeric_limits<int64_t>::min)()))
-                && (d < static_cast<double>((std::numeric_limits<int64_t>::max)()))
-                && (i == static_cast<int64_t>(d));
-        }
-        return true; // double, int, uint are always lossless
-    }
-
-    // Checks whether a number is a float (possible lossy).
-    bool IsFloat() const  {
-        if ((data_.f.flags & kDoubleFlag) == 0)
-            return false;
-        double d = GetDouble();
-        return d >= -3.4028234e38 && d <= 3.4028234e38;
-    }
-    // Checks whether a number can be losslessly converted to a float.
-    bool IsLosslessFloat() const {
-        if (!IsNumber()) return false;
-        double a = GetDouble();
-        if (a < static_cast<double>(-(std::numeric_limits<float>::max)())
-                || a > static_cast<double>((std::numeric_limits<float>::max)()))
-            return false;
-        double b = static_cast<double>(static_cast<float>(a));
-        return a >= b && a <= b;    // Prevent -Wfloat-equal
-    }
-
-    //@}
-
-    //!@name Null
-    //@{
-
-    GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; }
-
-    //@}
-
-    //!@name Bool
-    //@{
-
-    bool GetBool() const { RAPIDJSON_ASSERT(IsBool()); return data_.f.flags == kTrueFlag; }
-    //!< Set boolean value
-    /*! \post IsBool() == true */
-    GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; }
-
-    //@}
-
-    //!@name Object
-    //@{
-
-    //! Set this value as an empty object.
-    /*! \post IsObject() == true */
-    GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; }
-
-    //! Get the number of members in the object.
-    SizeType MemberCount() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size; }
-
-    //! Get the capacity of object.
-    SizeType MemberCapacity() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.capacity; }
-
-    //! Check whether the object is empty.
-    bool ObjectEmpty() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; }
-
-    //! Get a value from an object associated with the name.
-    /*! \pre IsObject() == true
-        \tparam T Either \c Ch or \c const \c Ch (template used for disambiguation with \ref operator[](SizeType))
-        \note In version 0.1x, if the member is not found, this function returns a null value. This makes issue 7.
-        Since 0.2, if the name is not correct, it will assert.
-        If user is unsure whether a member exists, user should use HasMember() first.
-        A better approach is to use FindMember().
-        \note Linear time complexity.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(GenericValue&)) operator[](T* name) {
-        GenericValue n(StringRef(name));
-        return (*this)[n];
-    }
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast<GenericValue&>(*this)[name]; }
-
-    //! Get a value from an object associated with the name.
-    /*! \pre IsObject() == true
-        \tparam SourceAllocator Allocator of the \c name value
-
-        \note Compared to \ref operator[](T*), this version is faster because it does not need a StrLen().
-        And it can also handle strings with embedded null characters.
-
-        \note Linear time complexity.
-    */
-    template <typename SourceAllocator>
-    GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) {
-        MemberIterator member = FindMember(name);
-        if (member != MemberEnd())
-            return member->value;
-        else {
-            RAPIDJSON_ASSERT(false);    // see above note
-
-            // This will generate -Wexit-time-destructors in clang
-            // static GenericValue NullValue;
-            // return NullValue;
-
-            // Use static buffer and placement-new to prevent destruction
-            static char buffer[sizeof(GenericValue)];
-            return *new (buffer) GenericValue();
-        }
-    }
-    template <typename SourceAllocator>
-    const GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this)[name]; }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Get a value from an object associated with name (string object).
-    GenericValue& operator[](const std::basic_string<Ch>& name) { return (*this)[GenericValue(StringRef(name))]; }
-    const GenericValue& operator[](const std::basic_string<Ch>& name) const { return (*this)[GenericValue(StringRef(name))]; }
-#endif
-
-    //! Const member iterator
-    /*! \pre IsObject() == true */
-    ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer()); }
-    //! Const \em past-the-end member iterator
-    /*! \pre IsObject() == true */
-    ConstMemberIterator MemberEnd() const   { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer() + data_.o.size); }
-    //! Member iterator
-    /*! \pre IsObject() == true */
-    MemberIterator MemberBegin()            { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer()); }
-    //! \em Past-the-end member iterator
-    /*! \pre IsObject() == true */
-    MemberIterator MemberEnd()              { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer() + data_.o.size); }
-
-    //! Request the object to have enough capacity to store members.
-    /*! \param newCapacity  The capacity that the object at least need to have.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \note Linear time complexity.
-    */
-    GenericValue& MemberReserve(SizeType newCapacity, Allocator &allocator) {
-        RAPIDJSON_ASSERT(IsObject());
-        DoReserveMembers(newCapacity, allocator);
-        return *this;
-    }
-
-    //! Check whether a member exists in the object.
-    /*!
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Whether a member with that name exists.
-        \note It is better to use FindMember() directly if you need the obtain the value as well.
-        \note Linear time complexity.
-    */
-    bool HasMember(const Ch* name) const { return FindMember(name) != MemberEnd(); }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Check whether a member exists in the object with string object.
-    /*!
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Whether a member with that name exists.
-        \note It is better to use FindMember() directly if you need the obtain the value as well.
-        \note Linear time complexity.
-    */
-    bool HasMember(const std::basic_string<Ch>& name) const { return FindMember(name) != MemberEnd(); }
-#endif
-
-    //! Check whether a member exists in the object with GenericValue name.
-    /*!
-        This version is faster because it does not need a StrLen(). It can also handle string with null character.
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Whether a member with that name exists.
-        \note It is better to use FindMember() directly if you need the obtain the value as well.
-        \note Linear time complexity.
-    */
-    template <typename SourceAllocator>
-    bool HasMember(const GenericValue<Encoding, SourceAllocator>& name) const { return FindMember(name) != MemberEnd(); }
-
-    //! Find member by name.
-    /*!
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Iterator to member, if it exists.
-            Otherwise returns \ref MemberEnd().
-
-        \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
-            the requested member doesn't exist. For consistency with e.g.
-            \c std::map, this has been changed to MemberEnd() now.
-        \note Linear time complexity.
-    */
-    MemberIterator FindMember(const Ch* name) {
-        GenericValue n(StringRef(name));
-        return FindMember(n);
-    }
-
-    ConstMemberIterator FindMember(const Ch* name) const { return const_cast<GenericValue&>(*this).FindMember(name); }
-
-    //! Find member by name.
-    /*!
-        This version is faster because it does not need a StrLen(). It can also handle string with null character.
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Iterator to member, if it exists.
-            Otherwise returns \ref MemberEnd().
-
-        \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
-            the requested member doesn't exist. For consistency with e.g.
-            \c std::map, this has been changed to MemberEnd() now.
-        \note Linear time complexity.
-    */
-    template <typename SourceAllocator>
-    MemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) {
-        RAPIDJSON_ASSERT(IsObject());
-        RAPIDJSON_ASSERT(name.IsString());
-        return DoFindMember(name);
-    }
-    template <typename SourceAllocator> ConstMemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this).FindMember(name); }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Find member by string object name.
-    /*!
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Iterator to member, if it exists.
-            Otherwise returns \ref MemberEnd().
-    */
-    MemberIterator FindMember(const std::basic_string<Ch>& name) { return FindMember(GenericValue(StringRef(name))); }
-    ConstMemberIterator FindMember(const std::basic_string<Ch>& name) const { return FindMember(GenericValue(StringRef(name))); }
-#endif
-
-    //! Add a member (name-value pair) to the object.
-    /*! \param name A string value as name of member.
-        \param value Value of any type.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \note The ownership of \c name and \c value will be transferred to this object on success.
-        \pre  IsObject() && name.IsString()
-        \post name.IsNull() && value.IsNull()
-        \note Amortized Constant time complexity.
-    */
-    GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) {
-        RAPIDJSON_ASSERT(IsObject());
-        RAPIDJSON_ASSERT(name.IsString());
-        DoAddMember(name, value, allocator);
-        return *this;
-    }
-
-    //! Add a constant string value as member (name-value pair) to the object.
-    /*! \param name A string value as name of member.
-        \param value constant string reference as value of member.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \pre  IsObject()
-        \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below.
-        \note Amortized Constant time complexity.
-    */
-    GenericValue& AddMember(GenericValue& name, StringRefType value, Allocator& allocator) {
-        GenericValue v(value);
-        return AddMember(name, v, allocator);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Add a string object as member (name-value pair) to the object.
-    /*! \param name A string value as name of member.
-        \param value constant string reference as value of member.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \pre  IsObject()
-        \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below.
-        \note Amortized Constant time complexity.
-    */
-    GenericValue& AddMember(GenericValue& name, std::basic_string<Ch>& value, Allocator& allocator) {
-        GenericValue v(value, allocator);
-        return AddMember(name, v, allocator);
-    }
-#endif
-
-    //! Add any primitive value as member (name-value pair) to the object.
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
-        \param name A string value as name of member.
-        \param value Value of primitive type \c T as value of member
-        \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \pre  IsObject()
-
-        \note The source type \c T explicitly disallows all pointer types,
-            especially (\c const) \ref Ch*.  This helps avoiding implicitly
-            referencing character strings with insufficient lifetime, use
-            \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
-            AddMember(StringRefType, StringRefType, Allocator&).
-            All other pointer types would implicitly convert to \c bool,
-            use an explicit cast instead, if needed.
-        \note Amortized Constant time complexity.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
-    AddMember(GenericValue& name, T value, Allocator& allocator) {
-        GenericValue v(value);
-        return AddMember(name, v, allocator);
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericValue& AddMember(GenericValue&& name, GenericValue&& value, Allocator& allocator) {
-        return AddMember(name, value, allocator);
-    }
-    GenericValue& AddMember(GenericValue&& name, GenericValue& value, Allocator& allocator) {
-        return AddMember(name, value, allocator);
-    }
-    GenericValue& AddMember(GenericValue& name, GenericValue&& value, Allocator& allocator) {
-        return AddMember(name, value, allocator);
-    }
-    GenericValue& AddMember(StringRefType name, GenericValue&& value, Allocator& allocator) {
-        GenericValue n(name);
-        return AddMember(n, value, allocator);
-    }
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-
-    //! Add a member (name-value pair) to the object.
-    /*! \param name A constant string reference as name of member.
-        \param value Value of any type.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \note The ownership of \c value will be transferred to this object on success.
-        \pre  IsObject()
-        \post value.IsNull()
-        \note Amortized Constant time complexity.
-    */
-    GenericValue& AddMember(StringRefType name, GenericValue& value, Allocator& allocator) {
-        GenericValue n(name);
-        return AddMember(n, value, allocator);
-    }
-
-    //! Add a constant string value as member (name-value pair) to the object.
-    /*! \param name A constant string reference as name of member.
-        \param value constant string reference as value of member.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \pre  IsObject()
-        \note This overload is needed to avoid clashes with the generic primitive type AddMember(StringRefType,T,Allocator&) overload below.
-        \note Amortized Constant time complexity.
-    */
-    GenericValue& AddMember(StringRefType name, StringRefType value, Allocator& allocator) {
-        GenericValue v(value);
-        return AddMember(name, v, allocator);
-    }
-
-    //! Add any primitive value as member (name-value pair) to the object.
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
-        \param name A constant string reference as name of member.
-        \param value Value of primitive type \c T as value of member
-        \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \pre  IsObject()
-
-        \note The source type \c T explicitly disallows all pointer types,
-            especially (\c const) \ref Ch*.  This helps avoiding implicitly
-            referencing character strings with insufficient lifetime, use
-            \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
-            AddMember(StringRefType, StringRefType, Allocator&).
-            All other pointer types would implicitly convert to \c bool,
-            use an explicit cast instead, if needed.
-        \note Amortized Constant time complexity.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
-    AddMember(StringRefType name, T value, Allocator& allocator) {
-        GenericValue n(name);
-        return AddMember(n, value, allocator);
-    }
-
-    //! Remove all members in the object.
-    /*! This function do not deallocate memory in the object, i.e. the capacity is unchanged.
-        \note Linear time complexity.
-    */
-    void RemoveAllMembers() {
-        RAPIDJSON_ASSERT(IsObject()); 
-        DoClearMembers();
-    }
-
-    //! Remove a member in object by its name.
-    /*! \param name Name of member to be removed.
-        \return Whether the member existed.
-        \note This function may reorder the object members. Use \ref
-            EraseMember(ConstMemberIterator) if you need to preserve the
-            relative order of the remaining members.
-        \note Linear time complexity.
-    */
-    bool RemoveMember(const Ch* name) {
-        GenericValue n(StringRef(name));
-        return RemoveMember(n);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool RemoveMember(const std::basic_string<Ch>& name) { return RemoveMember(GenericValue(StringRef(name))); }
-#endif
-
-    template <typename SourceAllocator>
-    bool RemoveMember(const GenericValue<Encoding, SourceAllocator>& name) {
-        MemberIterator m = FindMember(name);
-        if (m != MemberEnd()) {
-            RemoveMember(m);
-            return true;
-        }
-        else
-            return false;
-    }
-
-    //! Remove a member in object by iterator.
-    /*! \param m member iterator (obtained by FindMember() or MemberBegin()).
-        \return the new iterator after removal.
-        \note This function may reorder the object members. Use \ref
-            EraseMember(ConstMemberIterator) if you need to preserve the
-            relative order of the remaining members.
-        \note Constant time complexity.
-    */
-    MemberIterator RemoveMember(MemberIterator m) {
-        RAPIDJSON_ASSERT(IsObject());
-        RAPIDJSON_ASSERT(data_.o.size > 0);
-        RAPIDJSON_ASSERT(GetMembersPointer() != 0);
-        RAPIDJSON_ASSERT(m >= MemberBegin() && m < MemberEnd());
-        return DoRemoveMember(m);
-    }
-
-    //! Remove a member from an object by iterator.
-    /*! \param pos iterator to the member to remove
-        \pre IsObject() == true && \ref MemberBegin() <= \c pos < \ref MemberEnd()
-        \return Iterator following the removed element.
-            If the iterator \c pos refers to the last element, the \ref MemberEnd() iterator is returned.
-        \note This function preserves the relative order of the remaining object
-            members. If you do not need this, use the more efficient \ref RemoveMember(MemberIterator).
-        \note Linear time complexity.
-    */
-    MemberIterator EraseMember(ConstMemberIterator pos) {
-        return EraseMember(pos, pos +1);
-    }
-
-    //! Remove members in the range [first, last) from an object.
-    /*! \param first iterator to the first member to remove
-        \param last  iterator following the last member to remove
-        \pre IsObject() == true && \ref MemberBegin() <= \c first <= \c last <= \ref MemberEnd()
-        \return Iterator following the last removed element.
-        \note This function preserves the relative order of the remaining object
-            members.
-        \note Linear time complexity.
-    */
-    MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) {
-        RAPIDJSON_ASSERT(IsObject());
-        RAPIDJSON_ASSERT(data_.o.size > 0);
-        RAPIDJSON_ASSERT(GetMembersPointer() != 0);
-        RAPIDJSON_ASSERT(first >= MemberBegin());
-        RAPIDJSON_ASSERT(first <= last);
-        RAPIDJSON_ASSERT(last <= MemberEnd());
-        return DoEraseMembers(first, last);
-    }
-
-    //! Erase a member in object by its name.
-    /*! \param name Name of member to be removed.
-        \return Whether the member existed.
-        \note Linear time complexity.
-    */
-    bool EraseMember(const Ch* name) {
-        GenericValue n(StringRef(name));
-        return EraseMember(n);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool EraseMember(const std::basic_string<Ch>& name) { return EraseMember(GenericValue(StringRef(name))); }
-#endif
-
-    template <typename SourceAllocator>
-    bool EraseMember(const GenericValue<Encoding, SourceAllocator>& name) {
-        MemberIterator m = FindMember(name);
-        if (m != MemberEnd()) {
-            EraseMember(m);
-            return true;
-        }
-        else
-            return false;
-    }
-
-    Object GetObject() { RAPIDJSON_ASSERT(IsObject()); return Object(*this); }
-    ConstObject GetObject() const { RAPIDJSON_ASSERT(IsObject()); return ConstObject(*this); }
-
-    //@}
-
-    //!@name Array
-    //@{
-
-    //! Set this value as an empty array.
-    /*! \post IsArray == true */
-    GenericValue& SetArray() { this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; }
-
-    //! Get the number of elements in array.
-    SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; }
-
-    //! Get the capacity of array.
-    SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; }
-
-    //! Check whether the array is empty.
-    bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; }
-
-    //! Remove all elements in the array.
-    /*! This function do not deallocate memory in the array, i.e. the capacity is unchanged.
-        \note Linear time complexity.
-    */
-    void Clear() {
-        RAPIDJSON_ASSERT(IsArray()); 
-        GenericValue* e = GetElementsPointer();
-        for (GenericValue* v = e; v != e + data_.a.size; ++v)
-            v->~GenericValue();
-        data_.a.size = 0;
-    }
-
-    //! Get an element from array by index.
-    /*! \pre IsArray() == true
-        \param index Zero-based index of element.
-        \see operator[](T*)
-    */
-    GenericValue& operator[](SizeType index) {
-        RAPIDJSON_ASSERT(IsArray());
-        RAPIDJSON_ASSERT(index < data_.a.size);
-        return GetElementsPointer()[index];
-    }
-    const GenericValue& operator[](SizeType index) const { return const_cast<GenericValue&>(*this)[index]; }
-
-    //! Element iterator
-    /*! \pre IsArray() == true */
-    ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer(); }
-    //! \em Past-the-end element iterator
-    /*! \pre IsArray() == true */
-    ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer() + data_.a.size; }
-    //! Constant element iterator
-    /*! \pre IsArray() == true */
-    ConstValueIterator Begin() const { return const_cast<GenericValue&>(*this).Begin(); }
-    //! Constant \em past-the-end element iterator
-    /*! \pre IsArray() == true */
-    ConstValueIterator End() const { return const_cast<GenericValue&>(*this).End(); }
-
-    //! Request the array to have enough capacity to store elements.
-    /*! \param newCapacity  The capacity that the array at least need to have.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \note Linear time complexity.
-    */
-    GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) {
-        RAPIDJSON_ASSERT(IsArray());
-        if (newCapacity > data_.a.capacity) {
-            SetElementsPointer(reinterpret_cast<GenericValue*>(allocator.Realloc(GetElementsPointer(), data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue))));
-            data_.a.capacity = newCapacity;
-        }
-        return *this;
-    }
-
-    //! Append a GenericValue at the end of the array.
-    /*! \param value        Value to be appended.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \pre IsArray() == true
-        \post value.IsNull() == true
-        \return The value itself for fluent API.
-        \note The ownership of \c value will be transferred to this array on success.
-        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
-        \note Amortized constant time complexity.
-    */
-    GenericValue& PushBack(GenericValue& value, Allocator& allocator) {
-        RAPIDJSON_ASSERT(IsArray());
-        if (data_.a.size >= data_.a.capacity)
-            Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator);
-        GetElementsPointer()[data_.a.size++].RawAssign(value);
-        return *this;
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericValue& PushBack(GenericValue&& value, Allocator& allocator) {
-        return PushBack(value, allocator);
-    }
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-    //! Append a constant string reference at the end of the array.
-    /*! \param value        Constant string reference to be appended.
-        \param allocator    Allocator for reallocating memory. It must be the same one used previously. Commonly use GenericDocument::GetAllocator().
-        \pre IsArray() == true
-        \return The value itself for fluent API.
-        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
-        \note Amortized constant time complexity.
-        \see GenericStringRef
-    */
-    GenericValue& PushBack(StringRefType value, Allocator& allocator) {
-        return (*this).template PushBack<StringRefType>(value, allocator);
-    }
-
-    //! Append a primitive value at the end of the array.
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
-        \param value Value of primitive type T to be appended.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \pre IsArray() == true
-        \return The value itself for fluent API.
-        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
-
-        \note The source type \c T explicitly disallows all pointer types,
-            especially (\c const) \ref Ch*.  This helps avoiding implicitly
-            referencing character strings with insufficient lifetime, use
-            \ref PushBack(GenericValue&, Allocator&) or \ref
-            PushBack(StringRefType, Allocator&).
-            All other pointer types would implicitly convert to \c bool,
-            use an explicit cast instead, if needed.
-        \note Amortized constant time complexity.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
-    PushBack(T value, Allocator& allocator) {
-        GenericValue v(value);
-        return PushBack(v, allocator);
-    }
-
-    //! Remove the last element in the array.
-    /*!
-        \note Constant time complexity.
-    */
-    GenericValue& PopBack() {
-        RAPIDJSON_ASSERT(IsArray());
-        RAPIDJSON_ASSERT(!Empty());
-        GetElementsPointer()[--data_.a.size].~GenericValue();
-        return *this;
-    }
-
-    //! Remove an element of array by iterator.
-    /*!
-        \param pos iterator to the element to remove
-        \pre IsArray() == true && \ref Begin() <= \c pos < \ref End()
-        \return Iterator following the removed element. If the iterator pos refers to the last element, the End() iterator is returned.
-        \note Linear time complexity.
-    */
-    ValueIterator Erase(ConstValueIterator pos) {
-        return Erase(pos, pos + 1);
-    }
-
-    //! Remove elements in the range [first, last) of the array.
-    /*!
-        \param first iterator to the first element to remove
-        \param last  iterator following the last element to remove
-        \pre IsArray() == true && \ref Begin() <= \c first <= \c last <= \ref End()
-        \return Iterator following the last removed element.
-        \note Linear time complexity.
-    */
-    ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) {
-        RAPIDJSON_ASSERT(IsArray());
-        RAPIDJSON_ASSERT(data_.a.size > 0);
-        RAPIDJSON_ASSERT(GetElementsPointer() != 0);
-        RAPIDJSON_ASSERT(first >= Begin());
-        RAPIDJSON_ASSERT(first <= last);
-        RAPIDJSON_ASSERT(last <= End());
-        ValueIterator pos = Begin() + (first - Begin());
-        for (ValueIterator itr = pos; itr != last; ++itr)
-            itr->~GenericValue();
-        std::memmove(static_cast<void*>(pos), last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
-        data_.a.size -= static_cast<SizeType>(last - first);
-        return pos;
-    }
-
-    Array GetArray() { RAPIDJSON_ASSERT(IsArray()); return Array(*this); }
-    ConstArray GetArray() const { RAPIDJSON_ASSERT(IsArray()); return ConstArray(*this); }
-
-    //@}
-
-    //!@name Number
-    //@{
-
-    int GetInt() const          { RAPIDJSON_ASSERT(data_.f.flags & kIntFlag);   return data_.n.i.i;   }
-    unsigned GetUint() const    { RAPIDJSON_ASSERT(data_.f.flags & kUintFlag);  return data_.n.u.u;   }
-    int64_t GetInt64() const    { RAPIDJSON_ASSERT(data_.f.flags & kInt64Flag); return data_.n.i64; }
-    uint64_t GetUint64() const  { RAPIDJSON_ASSERT(data_.f.flags & kUint64Flag); return data_.n.u64; }
-
-    //! Get the value as double type.
-    /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessDouble() to check whether the converison is lossless.
-    */
-    double GetDouble() const {
-        RAPIDJSON_ASSERT(IsNumber());
-        if ((data_.f.flags & kDoubleFlag) != 0)                return data_.n.d;   // exact type, no conversion.
-        if ((data_.f.flags & kIntFlag) != 0)                   return data_.n.i.i; // int -> double
-        if ((data_.f.flags & kUintFlag) != 0)                  return data_.n.u.u; // unsigned -> double
-        if ((data_.f.flags & kInt64Flag) != 0)                 return static_cast<double>(data_.n.i64); // int64_t -> double (may lose precision)
-        RAPIDJSON_ASSERT((data_.f.flags & kUint64Flag) != 0);  return static_cast<double>(data_.n.u64); // uint64_t -> double (may lose precision)
-    }
-
-    //! Get the value as float type.
-    /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessFloat() to check whether the converison is lossless.
-    */
-    float GetFloat() const {
-        return static_cast<float>(GetDouble());
-    }
-
-    GenericValue& SetInt(int i)             { this->~GenericValue(); new (this) GenericValue(i);    return *this; }
-    GenericValue& SetUint(unsigned u)       { this->~GenericValue(); new (this) GenericValue(u);    return *this; }
-    GenericValue& SetInt64(int64_t i64)     { this->~GenericValue(); new (this) GenericValue(i64);  return *this; }
-    GenericValue& SetUint64(uint64_t u64)   { this->~GenericValue(); new (this) GenericValue(u64);  return *this; }
-    GenericValue& SetDouble(double d)       { this->~GenericValue(); new (this) GenericValue(d);    return *this; }
-    GenericValue& SetFloat(float f)         { this->~GenericValue(); new (this) GenericValue(static_cast<double>(f)); return *this; }
-
-    //@}
-
-    //!@name String
-    //@{
-
-    const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return DataString(data_); }
-
-    //! Get the length of string.
-    /*! Since rapidjson permits "\\u0000" in the json string, strlen(v.GetString()) may not equal to v.GetStringLength().
-    */
-    SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return DataStringLength(data_); }
-
-    //! Set this value as a string without copying source string.
-    /*! This version has better performance with supplied length, and also support string containing null character.
-        \param s source string pointer. 
-        \param length The length of source string, excluding the trailing null terminator.
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() == s && GetStringLength() == length
-        \see SetString(StringRefType)
-    */
-    GenericValue& SetString(const Ch* s, SizeType length) { return SetString(StringRef(s, length)); }
-
-    //! Set this value as a string without copying source string.
-    /*! \param s source string reference
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() == s && GetStringLength() == s.length
-    */
-    GenericValue& SetString(StringRefType s) { this->~GenericValue(); SetStringRaw(s); return *this; }
-
-    //! Set this value as a string by copying from source string.
-    /*! This version has better performance with supplied length, and also support string containing null character.
-        \param s source string. 
-        \param length The length of source string, excluding the trailing null terminator.
-        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
-    */
-    GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { return SetString(StringRef(s, length), allocator); }
-
-    //! Set this value as a string by copying from source string.
-    /*! \param s source string. 
-        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
-    */
-    GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(StringRef(s), allocator); }
-
-    //! Set this value as a string by copying from source string.
-    /*! \param s source string reference
-        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() != s.s && strcmp(GetString(),s) == 0 && GetStringLength() == length
-    */
-    GenericValue& SetString(StringRefType s, Allocator& allocator) { this->~GenericValue(); SetStringRaw(s, allocator); return *this; }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Set this value as a string by copying from source string.
-    /*! \param s source string.
-        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() != s.data() && strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size()
-        \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-    */
-    GenericValue& SetString(const std::basic_string<Ch>& s, Allocator& allocator) { return SetString(StringRef(s), allocator); }
-#endif
-
-    //@}
-
-    //!@name Array
-    //@{
-
-    //! Templated version for checking whether this value is type T.
-    /*!
-        \tparam T Either \c bool, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c float, \c const \c char*, \c std::basic_string<Ch>
-    */
-    template <typename T>
-    bool Is() const { return internal::TypeHelper<ValueType, T>::Is(*this); }
-
-    template <typename T>
-    T Get() const { return internal::TypeHelper<ValueType, T>::Get(*this); }
-
-    template <typename T>
-    T Get() { return internal::TypeHelper<ValueType, T>::Get(*this); }
-
-    template<typename T>
-    ValueType& Set(const T& data) { return internal::TypeHelper<ValueType, T>::Set(*this, data); }
-
-    template<typename T>
-    ValueType& Set(const T& data, AllocatorType& allocator) { return internal::TypeHelper<ValueType, T>::Set(*this, data, allocator); }
-
-    //@}
-
-    //! Generate events of this value to a Handler.
-    /*! This function adopts the GoF visitor pattern.
-        Typical usage is to output this JSON value as JSON text via Writer, which is a Handler.
-        It can also be used to deep clone this value via GenericDocument, which is also a Handler.
-        \tparam Handler type of handler.
-        \param handler An object implementing concept Handler.
-    */
-    template <typename Handler>
-    bool Accept(Handler& handler) const {
-        switch(GetType()) {
-        case kNullType:     return handler.Null();
-        case kFalseType:    return handler.Bool(false);
-        case kTrueType:     return handler.Bool(true);
-
-        case kObjectType:
-            if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
-                return false;
-            for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) {
-                RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of name by MemberIterator.
-                if (RAPIDJSON_UNLIKELY(!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.data_.f.flags & kCopyFlag) != 0)))
-                    return false;
-                if (RAPIDJSON_UNLIKELY(!m->value.Accept(handler)))
-                    return false;
-            }
-            return handler.EndObject(data_.o.size);
-
-        case kArrayType:
-            if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
-                return false;
-            for (const GenericValue* v = Begin(); v != End(); ++v)
-                if (RAPIDJSON_UNLIKELY(!v->Accept(handler)))
-                    return false;
-            return handler.EndArray(data_.a.size);
-    
-        case kStringType:
-            return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0);
-    
-        default:
-            RAPIDJSON_ASSERT(GetType() == kNumberType);
-            if (IsDouble())         return handler.Double(data_.n.d);
-            else if (IsInt())       return handler.Int(data_.n.i.i);
-            else if (IsUint())      return handler.Uint(data_.n.u.u);
-            else if (IsInt64())     return handler.Int64(data_.n.i64);
-            else                    return handler.Uint64(data_.n.u64);
-        }
-    }
-
-private:
-    template <typename, typename> friend class GenericValue;
-    template <typename, typename, typename> friend class GenericDocument;
-
-    enum {
-        kBoolFlag       = 0x0008,
-        kNumberFlag     = 0x0010,
-        kIntFlag        = 0x0020,
-        kUintFlag       = 0x0040,
-        kInt64Flag      = 0x0080,
-        kUint64Flag     = 0x0100,
-        kDoubleFlag     = 0x0200,
-        kStringFlag     = 0x0400,
-        kCopyFlag       = 0x0800,
-        kInlineStrFlag  = 0x1000,
-
-        // Initial flags of different types.
-        kNullFlag = kNullType,
-        // These casts are added to suppress the warning on MSVC about bitwise operations between enums of different types.
-        kTrueFlag = static_cast<int>(kTrueType) | static_cast<int>(kBoolFlag),
-        kFalseFlag = static_cast<int>(kFalseType) | static_cast<int>(kBoolFlag),
-        kNumberIntFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag),
-        kNumberUintFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag),
-        kNumberInt64Flag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kInt64Flag),
-        kNumberUint64Flag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kUint64Flag),
-        kNumberDoubleFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kDoubleFlag),
-        kNumberAnyFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag),
-        kConstStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag),
-        kCopyStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag | kCopyFlag),
-        kShortStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag | kCopyFlag | kInlineStrFlag),
-        kObjectFlag = kObjectType,
-        kArrayFlag = kArrayType,
-
-        kTypeMask = 0x07
-    };
-
-    static const SizeType kDefaultArrayCapacity = RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY;
-    static const SizeType kDefaultObjectCapacity = RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY;
-
-    struct Flag {
-#if RAPIDJSON_48BITPOINTER_OPTIMIZATION
-        char payload[sizeof(SizeType) * 2 + 6];     // 2 x SizeType + lower 48-bit pointer
-#elif RAPIDJSON_64BIT
-        char payload[sizeof(SizeType) * 2 + sizeof(void*) + 6]; // 6 padding bytes
-#else
-        char payload[sizeof(SizeType) * 2 + sizeof(void*) + 2]; // 2 padding bytes
-#endif
-        uint16_t flags;
-    };
-
-    struct String {
-        SizeType length;
-        SizeType hashcode;  //!< reserved
-        const Ch* str;
-    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
-
-    // implementation detail: ShortString can represent zero-terminated strings up to MaxSize chars
-    // (excluding the terminating zero) and store a value to determine the length of the contained
-    // string in the last character str[LenPos] by storing "MaxSize - length" there. If the string
-    // to store has the maximal length of MaxSize then str[LenPos] will be 0 and therefore act as
-    // the string terminator as well. For getting the string length back from that value just use
-    // "MaxSize - str[LenPos]".
-    // This allows to store 13-chars strings in 32-bit mode, 21-chars strings in 64-bit mode,
-    // 13-chars strings for RAPIDJSON_48BITPOINTER_OPTIMIZATION=1 inline (for `UTF8`-encoded strings).
-    struct ShortString {
-        enum { MaxChars = sizeof(static_cast<Flag*>(0)->payload) / sizeof(Ch), MaxSize = MaxChars - 1, LenPos = MaxSize };
-        Ch str[MaxChars];
-
-        inline static bool Usable(SizeType len) { return                       (MaxSize >= len); }
-        inline void     SetLength(SizeType len) { str[LenPos] = static_cast<Ch>(MaxSize -  len); }
-        inline SizeType GetLength() const       { return  static_cast<SizeType>(MaxSize -  str[LenPos]); }
-    };  // at most as many bytes as "String" above => 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
-
-    // By using proper binary layout, retrieval of different integer types do not need conversions.
-    union Number {
-#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN
-        struct I {
-            int i;
-            char padding[4];
-        }i;
-        struct U {
-            unsigned u;
-            char padding2[4];
-        }u;
-#else
-        struct I {
-            char padding[4];
-            int i;
-        }i;
-        struct U {
-            char padding2[4];
-            unsigned u;
-        }u;
-#endif
-        int64_t i64;
-        uint64_t u64;
-        double d;
-    };  // 8 bytes
-
-    struct ObjectData {
-        SizeType size;
-        SizeType capacity;
-        Member* members;
-    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
-
-    struct ArrayData {
-        SizeType size;
-        SizeType capacity;
-        GenericValue* elements;
-    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
-
-    union Data {
-        String s;
-        ShortString ss;
-        Number n;
-        ObjectData o;
-        ArrayData a;
-        Flag f;
-    };  // 16 bytes in 32-bit mode, 24 bytes in 64-bit mode, 16 bytes in 64-bit with RAPIDJSON_48BITPOINTER_OPTIMIZATION
-
-    static RAPIDJSON_FORCEINLINE const Ch* DataString(const Data& data) {
-        return (data.f.flags & kInlineStrFlag) ? data.ss.str : RAPIDJSON_GETPOINTER(Ch, data.s.str);
-    }
-    static RAPIDJSON_FORCEINLINE SizeType DataStringLength(const Data& data) {
-        return (data.f.flags & kInlineStrFlag) ? data.ss.GetLength() : data.s.length;
-    }
-
-    RAPIDJSON_FORCEINLINE const Ch* GetStringPointer() const { return RAPIDJSON_GETPOINTER(Ch, data_.s.str); }
-    RAPIDJSON_FORCEINLINE const Ch* SetStringPointer(const Ch* str) { return RAPIDJSON_SETPOINTER(Ch, data_.s.str, str); }
-    RAPIDJSON_FORCEINLINE GenericValue* GetElementsPointer() const { return RAPIDJSON_GETPOINTER(GenericValue, data_.a.elements); }
-    RAPIDJSON_FORCEINLINE GenericValue* SetElementsPointer(GenericValue* elements) { return RAPIDJSON_SETPOINTER(GenericValue, data_.a.elements, elements); }
-    RAPIDJSON_FORCEINLINE Member* GetMembersPointer() const { return RAPIDJSON_GETPOINTER(Member, data_.o.members); }
-    RAPIDJSON_FORCEINLINE Member* SetMembersPointer(Member* members) { return RAPIDJSON_SETPOINTER(Member, data_.o.members, members); }
-
-#if RAPIDJSON_USE_MEMBERSMAP
-
-    struct MapTraits {
-        struct Less {
-            bool operator()(const Data& s1, const Data& s2) const {
-                SizeType n1 = DataStringLength(s1), n2 = DataStringLength(s2);
-                int cmp = std::memcmp(DataString(s1), DataString(s2), sizeof(Ch) * (n1 < n2 ? n1 : n2));
-                return cmp < 0 || (cmp == 0 && n1 < n2);
-            }
-        };
-        typedef std::pair<const Data, SizeType> Pair;
-        typedef std::multimap<Data, SizeType, Less, StdAllocator<Pair, Allocator> > Map;
-        typedef typename Map::iterator Iterator;
-    };
-    typedef typename MapTraits::Map         Map;
-    typedef typename MapTraits::Less        MapLess;
-    typedef typename MapTraits::Pair        MapPair;
-    typedef typename MapTraits::Iterator    MapIterator;
-
-    //
-    // Layout of the members' map/array, re(al)located according to the needed capacity:
-    //
-    //    {Map*}<>{capacity}<>{Member[capacity]}<>{MapIterator[capacity]}
-    //
-    // (where <> stands for the RAPIDJSON_ALIGN-ment, if needed)
-    //
-
-    static RAPIDJSON_FORCEINLINE size_t GetMapLayoutSize(SizeType capacity) {
-        return RAPIDJSON_ALIGN(sizeof(Map*)) +
-               RAPIDJSON_ALIGN(sizeof(SizeType)) +
-               RAPIDJSON_ALIGN(capacity * sizeof(Member)) +
-               capacity * sizeof(MapIterator);
-    }
-
-    static RAPIDJSON_FORCEINLINE SizeType &GetMapCapacity(Map* &map) {
-        return *reinterpret_cast<SizeType*>(reinterpret_cast<uintptr_t>(&map) +
-                                            RAPIDJSON_ALIGN(sizeof(Map*)));
-    }
-
-    static RAPIDJSON_FORCEINLINE Member* GetMapMembers(Map* &map) {
-        return reinterpret_cast<Member*>(reinterpret_cast<uintptr_t>(&map) +
-                                         RAPIDJSON_ALIGN(sizeof(Map*)) +
-                                         RAPIDJSON_ALIGN(sizeof(SizeType)));
-    }
-
-    static RAPIDJSON_FORCEINLINE MapIterator* GetMapIterators(Map* &map) {
-        return reinterpret_cast<MapIterator*>(reinterpret_cast<uintptr_t>(&map) +
-                                              RAPIDJSON_ALIGN(sizeof(Map*)) +
-                                              RAPIDJSON_ALIGN(sizeof(SizeType)) +
-                                              RAPIDJSON_ALIGN(GetMapCapacity(map) * sizeof(Member)));
-    }
-
-    static RAPIDJSON_FORCEINLINE Map* &GetMap(Member* members) {
-        RAPIDJSON_ASSERT(members != 0);
-        return *reinterpret_cast<Map**>(reinterpret_cast<uintptr_t>(members) -
-                                        RAPIDJSON_ALIGN(sizeof(SizeType)) -
-                                        RAPIDJSON_ALIGN(sizeof(Map*)));
-    }
-
-    // Some compilers' debug mechanisms want all iterators to be destroyed, for their accounting..
-    RAPIDJSON_FORCEINLINE MapIterator DropMapIterator(MapIterator& rhs) {
-#if RAPIDJSON_HAS_CXX11
-        MapIterator ret = std::move(rhs);
-#else
-        MapIterator ret = rhs;
-#endif
-        rhs.~MapIterator();
-        return ret;
-    }
-
-    Map* &DoReallocMap(Map** oldMap, SizeType newCapacity, Allocator& allocator) {
-        Map **newMap = static_cast<Map**>(allocator.Malloc(GetMapLayoutSize(newCapacity)));
-        GetMapCapacity(*newMap) = newCapacity;
-        if (!oldMap) {
-            *newMap = new (allocator.Malloc(sizeof(Map))) Map(MapLess(), allocator);
-        }
-        else {
-            *newMap = *oldMap;
-            size_t count = (*oldMap)->size();
-            std::memcpy(static_cast<void*>(GetMapMembers(*newMap)),
-                        static_cast<void*>(GetMapMembers(*oldMap)),
-                        count * sizeof(Member));
-            MapIterator *oldIt = GetMapIterators(*oldMap),
-                        *newIt = GetMapIterators(*newMap);
-            while (count--) {
-                new (&newIt[count]) MapIterator(DropMapIterator(oldIt[count]));
-            }
-            Allocator::Free(oldMap);
-        }
-        return *newMap;
-    }
-
-    RAPIDJSON_FORCEINLINE Member* DoAllocMembers(SizeType capacity, Allocator& allocator) {
-        return GetMapMembers(DoReallocMap(0, capacity, allocator));
-    }
-
-    void DoReserveMembers(SizeType newCapacity, Allocator& allocator) {
-        ObjectData& o = data_.o;
-        if (newCapacity > o.capacity) {
-            Member* oldMembers = GetMembersPointer();
-            Map **oldMap = oldMembers ? &GetMap(oldMembers) : 0,
-                *&newMap = DoReallocMap(oldMap, newCapacity, allocator);
-            RAPIDJSON_SETPOINTER(Member, o.members, GetMapMembers(newMap));
-            o.capacity = newCapacity;
-        }
-    }
-
-    template <typename SourceAllocator>
-    MemberIterator DoFindMember(const GenericValue<Encoding, SourceAllocator>& name) {
-        if (Member* members = GetMembersPointer()) {
-            Map* &map = GetMap(members);
-            MapIterator mit = map->find(reinterpret_cast<const Data&>(name.data_));
-            if (mit != map->end()) {
-                return MemberIterator(&members[mit->second]);
-            }
-        }
-        return MemberEnd();
-    }
-
-    void DoClearMembers() {
-        if (Member* members = GetMembersPointer()) {
-            Map* &map = GetMap(members);
-            MapIterator* mit = GetMapIterators(map);
-            for (SizeType i = 0; i < data_.o.size; i++) {
-                map->erase(DropMapIterator(mit[i]));
-                members[i].~Member();
-            }
-            data_.o.size = 0;
-        }
-    }
-
-    void DoFreeMembers() {
-        if (Member* members = GetMembersPointer()) {
-            GetMap(members)->~Map();
-            for (SizeType i = 0; i < data_.o.size; i++) {
-                members[i].~Member();
-            }
-            if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
-                Map** map = &GetMap(members);
-                Allocator::Free(*map);
-                Allocator::Free(map);
-            }
-        }
-    }
-
-#else // !RAPIDJSON_USE_MEMBERSMAP
-
-    RAPIDJSON_FORCEINLINE Member* DoAllocMembers(SizeType capacity, Allocator& allocator) {
-        return Malloc<Member>(allocator, capacity);
-    }
-
-    void DoReserveMembers(SizeType newCapacity, Allocator& allocator) {
-        ObjectData& o = data_.o;
-        if (newCapacity > o.capacity) {
-            Member* newMembers = Realloc<Member>(allocator, GetMembersPointer(), o.capacity, newCapacity);
-            RAPIDJSON_SETPOINTER(Member, o.members, newMembers);
-            o.capacity = newCapacity;
-        }
-    }
-
-    template <typename SourceAllocator>
-    MemberIterator DoFindMember(const GenericValue<Encoding, SourceAllocator>& name) {
-        MemberIterator member = MemberBegin();
-        for ( ; member != MemberEnd(); ++member)
-            if (name.StringEqual(member->name))
-                break;
-        return member;
-    }
-
-    void DoClearMembers() {
-        for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
-            m->~Member();
-        data_.o.size = 0;
-    }
-
-    void DoFreeMembers() {
-        for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
-            m->~Member();
-        Allocator::Free(GetMembersPointer());
-    }
-
-#endif // !RAPIDJSON_USE_MEMBERSMAP
-
-    void DoAddMember(GenericValue& name, GenericValue& value, Allocator& allocator) {
-        ObjectData& o = data_.o;
-        if (o.size >= o.capacity)
-            DoReserveMembers(o.capacity ? (o.capacity + (o.capacity + 1) / 2) : kDefaultObjectCapacity, allocator);
-        Member* members = GetMembersPointer();
-        Member* m = members + o.size;
-        m->name.RawAssign(name);
-        m->value.RawAssign(value);
-#if RAPIDJSON_USE_MEMBERSMAP
-        Map* &map = GetMap(members);
-        MapIterator* mit = GetMapIterators(map);
-        new (&mit[o.size]) MapIterator(map->insert(MapPair(m->name.data_, o.size)));
-#endif
-        ++o.size;
-    }
-
-    MemberIterator DoRemoveMember(MemberIterator m) {
-        ObjectData& o = data_.o;
-        Member* members = GetMembersPointer();
-#if RAPIDJSON_USE_MEMBERSMAP
-        Map* &map = GetMap(members);
-        MapIterator* mit = GetMapIterators(map);
-        SizeType mpos = static_cast<SizeType>(&*m - members);
-        map->erase(DropMapIterator(mit[mpos]));
-#endif
-        MemberIterator last(members + (o.size - 1));
-        if (o.size > 1 && m != last) {
-#if RAPIDJSON_USE_MEMBERSMAP
-            new (&mit[mpos]) MapIterator(DropMapIterator(mit[&*last - members]));
-            mit[mpos]->second = mpos;
-#endif
-            *m = *last; // Move the last one to this place
-        }
-        else {
-            m->~Member(); // Only one left, just destroy
-        }
-        --o.size;
-        return m;
-    }
-
-    MemberIterator DoEraseMembers(ConstMemberIterator first, ConstMemberIterator last) {
-        ObjectData& o = data_.o;
-        MemberIterator beg = MemberBegin(),
-                       pos = beg + (first - beg),
-                       end = MemberEnd();
-#if RAPIDJSON_USE_MEMBERSMAP
-        Map* &map = GetMap(GetMembersPointer());
-        MapIterator* mit = GetMapIterators(map);
-#endif
-        for (MemberIterator itr = pos; itr != last; ++itr) {
-#if RAPIDJSON_USE_MEMBERSMAP
-            map->erase(DropMapIterator(mit[itr - beg]));
-#endif
-            itr->~Member();
-        }
-#if RAPIDJSON_USE_MEMBERSMAP
-        if (first != last) {
-            // Move remaining members/iterators
-            MemberIterator next = pos + (last - first);
-            for (MemberIterator itr = pos; next != end; ++itr, ++next) {
-                std::memcpy(static_cast<void*>(&*itr), &*next, sizeof(Member));
-                SizeType mpos = static_cast<SizeType>(itr - beg);
-                new (&mit[mpos]) MapIterator(DropMapIterator(mit[next - beg]));
-                mit[mpos]->second = mpos;
-            }
-        }
-#else
-        std::memmove(static_cast<void*>(&*pos), &*last,
-                     static_cast<size_t>(end - last) * sizeof(Member));
-#endif
-        o.size -= static_cast<SizeType>(last - first);
-        return pos;
-    }
-
-    template <typename SourceAllocator>
-    void DoCopyMembers(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator, bool copyConstStrings) {
-        RAPIDJSON_ASSERT(rhs.GetType() == kObjectType);
-
-        data_.f.flags = kObjectFlag;
-        SizeType count = rhs.data_.o.size;
-        Member* lm = DoAllocMembers(count, allocator);
-        const typename GenericValue<Encoding,SourceAllocator>::Member* rm = rhs.GetMembersPointer();
-#if RAPIDJSON_USE_MEMBERSMAP
-        Map* &map = GetMap(lm);
-        MapIterator* mit = GetMapIterators(map);
-#endif
-        for (SizeType i = 0; i < count; i++) {
-            new (&lm[i].name) GenericValue(rm[i].name, allocator, copyConstStrings);
-            new (&lm[i].value) GenericValue(rm[i].value, allocator, copyConstStrings);
-#if RAPIDJSON_USE_MEMBERSMAP
-            new (&mit[i]) MapIterator(map->insert(MapPair(lm[i].name.data_, i)));
-#endif
-        }
-        data_.o.size = data_.o.capacity = count;
-        SetMembersPointer(lm);
-    }
-
-    // Initialize this value as array with initial data, without calling destructor.
-    void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {
-        data_.f.flags = kArrayFlag;
-        if (count) {
-            GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
-            SetElementsPointer(e);
-            std::memcpy(static_cast<void*>(e), values, count * sizeof(GenericValue));
-        }
-        else
-            SetElementsPointer(0);
-        data_.a.size = data_.a.capacity = count;
-    }
-
-    //! Initialize this value as object with initial data, without calling destructor.
-    void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
-        data_.f.flags = kObjectFlag;
-        if (count) {
-            Member* m = DoAllocMembers(count, allocator);
-            SetMembersPointer(m);
-            std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
-#if RAPIDJSON_USE_MEMBERSMAP
-            Map* &map = GetMap(m);
-            MapIterator* mit = GetMapIterators(map);
-            for (SizeType i = 0; i < count; i++) {
-                new (&mit[i]) MapIterator(map->insert(MapPair(m[i].name.data_, i)));
-            }
-#endif
-        }
-        else
-            SetMembersPointer(0);
-        data_.o.size = data_.o.capacity = count;
-    }
-
-    //! Initialize this value as constant string, without calling destructor.
-    void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT {
-        data_.f.flags = kConstStringFlag;
-        SetStringPointer(s);
-        data_.s.length = s.length;
-    }
-
-    //! Initialize this value as copy string with initial data, without calling destructor.
-    void SetStringRaw(StringRefType s, Allocator& allocator) {
-        Ch* str = 0;
-        if (ShortString::Usable(s.length)) {
-            data_.f.flags = kShortStringFlag;
-            data_.ss.SetLength(s.length);
-            str = data_.ss.str;
-        } else {
-            data_.f.flags = kCopyStringFlag;
-            data_.s.length = s.length;
-            str = static_cast<Ch *>(allocator.Malloc((s.length + 1) * sizeof(Ch)));
-            SetStringPointer(str);
-        }
-        std::memcpy(str, s, s.length * sizeof(Ch));
-        str[s.length] = '\0';
-    }
-
-    //! Assignment without calling destructor
-    void RawAssign(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
-        data_ = rhs.data_;
-        // data_.f.flags = rhs.data_.f.flags;
-        rhs.data_.f.flags = kNullFlag;
-    }
-
-    template <typename SourceAllocator>
-    bool StringEqual(const GenericValue<Encoding, SourceAllocator>& rhs) const {
-        RAPIDJSON_ASSERT(IsString());
-        RAPIDJSON_ASSERT(rhs.IsString());
-
-        const SizeType len1 = GetStringLength();
-        const SizeType len2 = rhs.GetStringLength();
-        if(len1 != len2) { return false; }
-
-        const Ch* const str1 = GetString();
-        const Ch* const str2 = rhs.GetString();
-        if(str1 == str2) { return true; } // fast path for constant string
-
-        return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0);
-    }
-
-    Data data_;
-};
-
-//! GenericValue with UTF8 encoding
-typedef GenericValue<UTF8<> > Value;
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericDocument 
-
-//! A document for parsing JSON text as DOM.
-/*!
-    \note implements Handler concept
-    \tparam Encoding Encoding for both parsing and string storage.
-    \tparam Allocator Allocator for allocating memory for the DOM
-    \tparam StackAllocator Allocator for allocating memory for stack during parsing.
-    \warning Although GenericDocument inherits from GenericValue, the API does \b not provide any virtual functions, especially no virtual destructor.  To avoid memory leaks, do not \c delete a GenericDocument object via a pointer to a GenericValue.
-*/
-template <typename Encoding, typename Allocator = RAPIDJSON_DEFAULT_ALLOCATOR, typename StackAllocator = RAPIDJSON_DEFAULT_STACK_ALLOCATOR >
-class GenericDocument : public GenericValue<Encoding, Allocator> {
-public:
-    typedef typename Encoding::Ch Ch;                       //!< Character type derived from Encoding.
-    typedef GenericValue<Encoding, Allocator> ValueType;    //!< Value type of the document.
-    typedef Allocator AllocatorType;                        //!< Allocator type from template parameter.
-
-    //! Constructor
-    /*! Creates an empty document of specified type.
-        \param type             Mandatory type of object to create.
-        \param allocator        Optional allocator for allocating memory.
-        \param stackCapacity    Optional initial capacity of stack in bytes.
-        \param stackAllocator   Optional allocator for allocating memory for stack.
-    */
-    explicit GenericDocument(Type type, Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
-        GenericValue<Encoding, Allocator>(type),  allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
-    {
-        if (!allocator_)
-            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-    }
-
-    //! Constructor
-    /*! Creates an empty document which type is Null. 
-        \param allocator        Optional allocator for allocating memory.
-        \param stackCapacity    Optional initial capacity of stack in bytes.
-        \param stackAllocator   Optional allocator for allocating memory for stack.
-    */
-    GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) : 
-        allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
-    {
-        if (!allocator_)
-            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move constructor in C++11
-    GenericDocument(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT
-        : ValueType(std::forward<ValueType>(rhs)), // explicit cast to avoid prohibited move from Document
-          allocator_(rhs.allocator_),
-          ownAllocator_(rhs.ownAllocator_),
-          stack_(std::move(rhs.stack_)),
-          parseResult_(rhs.parseResult_)
-    {
-        rhs.allocator_ = 0;
-        rhs.ownAllocator_ = 0;
-        rhs.parseResult_ = ParseResult();
-    }
-#endif
-
-    ~GenericDocument() {
-        // Clear the ::ValueType before ownAllocator is destroyed, ~ValueType()
-        // runs last and may access its elements or members which would be freed
-        // with an allocator like MemoryPoolAllocator (CrtAllocator does not
-        // free its data when destroyed, but MemoryPoolAllocator does).
-        if (ownAllocator_) {
-            ValueType::SetNull();
-        }
-        Destroy();
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move assignment in C++11
-    GenericDocument& operator=(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT
-    {
-        // The cast to ValueType is necessary here, because otherwise it would
-        // attempt to call GenericValue's templated assignment operator.
-        ValueType::operator=(std::forward<ValueType>(rhs));
-
-        // Calling the destructor here would prematurely call stack_'s destructor
-        Destroy();
-
-        allocator_ = rhs.allocator_;
-        ownAllocator_ = rhs.ownAllocator_;
-        stack_ = std::move(rhs.stack_);
-        parseResult_ = rhs.parseResult_;
-
-        rhs.allocator_ = 0;
-        rhs.ownAllocator_ = 0;
-        rhs.parseResult_ = ParseResult();
-
-        return *this;
-    }
-#endif
-
-    //! Exchange the contents of this document with those of another.
-    /*!
-        \param rhs Another document.
-        \note Constant complexity.
-        \see GenericValue::Swap
-    */
-    GenericDocument& Swap(GenericDocument& rhs) RAPIDJSON_NOEXCEPT {
-        ValueType::Swap(rhs);
-        stack_.Swap(rhs.stack_);
-        internal::Swap(allocator_, rhs.allocator_);
-        internal::Swap(ownAllocator_, rhs.ownAllocator_);
-        internal::Swap(parseResult_, rhs.parseResult_);
-        return *this;
-    }
-
-    // Allow Swap with ValueType.
-    // Refer to Effective C++ 3rd Edition/Item 33: Avoid hiding inherited names.
-    using ValueType::Swap;
-
-    //! free-standing swap function helper
-    /*!
-        Helper function to enable support for common swap implementation pattern based on \c std::swap:
-        \code
-        void swap(MyClass& a, MyClass& b) {
-            using std::swap;
-            swap(a.doc, b.doc);
-            // ...
-        }
-        \endcode
-        \see Swap()
-     */
-    friend inline void swap(GenericDocument& a, GenericDocument& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }
-
-    //! Populate this document by a generator which produces SAX events.
-    /*! \tparam Generator A functor with <tt>bool f(Handler)</tt> prototype.
-        \param g Generator functor which sends SAX events to the parameter.
-        \return The document itself for fluent API.
-    */
-    template <typename Generator>
-    GenericDocument& Populate(Generator& g) {
-        ClearStackOnExit scope(*this);
-        if (g(*this)) {
-            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
-            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
-        }
-        return *this;
-    }
-
-    //!@name Parse from stream
-    //!@{
-
-    //! Parse JSON text from an input stream (with Encoding conversion)
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \tparam SourceEncoding Encoding of input stream
-        \tparam InputStream Type of input stream, implementing Stream concept
-        \param is Input stream to be parsed.
-        \return The document itself for fluent API.
-    */
-    template <unsigned parseFlags, typename SourceEncoding, typename InputStream>
-    GenericDocument& ParseStream(InputStream& is) {
-        GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
-            stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
-        ClearStackOnExit scope(*this);
-        parseResult_ = reader.template Parse<parseFlags>(is, *this);
-        if (parseResult_) {
-            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
-            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
-        }
-        return *this;
-    }
-
-    //! Parse JSON text from an input stream
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \tparam InputStream Type of input stream, implementing Stream concept
-        \param is Input stream to be parsed.
-        \return The document itself for fluent API.
-    */
-    template <unsigned parseFlags, typename InputStream>
-    GenericDocument& ParseStream(InputStream& is) {
-        return ParseStream<parseFlags, Encoding, InputStream>(is);
-    }
-
-    //! Parse JSON text from an input stream (with \ref kParseDefaultFlags)
-    /*! \tparam InputStream Type of input stream, implementing Stream concept
-        \param is Input stream to be parsed.
-        \return The document itself for fluent API.
-    */
-    template <typename InputStream>
-    GenericDocument& ParseStream(InputStream& is) {
-        return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is);
-    }
-    //!@}
-
-    //!@name Parse in-place from mutable string
-    //!@{
-
-    //! Parse JSON text from a mutable string
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \param str Mutable zero-terminated string to be parsed.
-        \return The document itself for fluent API.
-    */
-    template <unsigned parseFlags>
-    GenericDocument& ParseInsitu(Ch* str) {
-        GenericInsituStringStream<Encoding> s(str);
-        return ParseStream<parseFlags | kParseInsituFlag>(s);
-    }
-
-    //! Parse JSON text from a mutable string (with \ref kParseDefaultFlags)
-    /*! \param str Mutable zero-terminated string to be parsed.
-        \return The document itself for fluent API.
-    */
-    GenericDocument& ParseInsitu(Ch* str) {
-        return ParseInsitu<kParseDefaultFlags>(str);
-    }
-    //!@}
-
-    //!@name Parse from read-only string
-    //!@{
-
-    //! Parse JSON text from a read-only string (with Encoding conversion)
-    /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag).
-        \tparam SourceEncoding Transcoding from input Encoding
-        \param str Read-only zero-terminated string to be parsed.
-    */
-    template <unsigned parseFlags, typename SourceEncoding>
-    GenericDocument& Parse(const typename SourceEncoding::Ch* str) {
-        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
-        GenericStringStream<SourceEncoding> s(str);
-        return ParseStream<parseFlags, SourceEncoding>(s);
-    }
-
-    //! Parse JSON text from a read-only string
-    /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag).
-        \param str Read-only zero-terminated string to be parsed.
-    */
-    template <unsigned parseFlags>
-    GenericDocument& Parse(const Ch* str) {
-        return Parse<parseFlags, Encoding>(str);
-    }
-
-    //! Parse JSON text from a read-only string (with \ref kParseDefaultFlags)
-    /*! \param str Read-only zero-terminated string to be parsed.
-    */
-    GenericDocument& Parse(const Ch* str) {
-        return Parse<kParseDefaultFlags>(str);
-    }
-
-    template <unsigned parseFlags, typename SourceEncoding>
-    GenericDocument& Parse(const typename SourceEncoding::Ch* str, size_t length) {
-        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
-        MemoryStream ms(reinterpret_cast<const char*>(str), length * sizeof(typename SourceEncoding::Ch));
-        EncodedInputStream<SourceEncoding, MemoryStream> is(ms);
-        ParseStream<parseFlags, SourceEncoding>(is);
-        return *this;
-    }
-
-    template <unsigned parseFlags>
-    GenericDocument& Parse(const Ch* str, size_t length) {
-        return Parse<parseFlags, Encoding>(str, length);
-    }
-    
-    GenericDocument& Parse(const Ch* str, size_t length) {
-        return Parse<kParseDefaultFlags>(str, length);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    template <unsigned parseFlags, typename SourceEncoding>
-    GenericDocument& Parse(const std::basic_string<typename SourceEncoding::Ch>& str) {
-        // c_str() is constant complexity according to standard. Should be faster than Parse(const char*, size_t)
-        return Parse<parseFlags, SourceEncoding>(str.c_str());
-    }
-
-    template <unsigned parseFlags>
-    GenericDocument& Parse(const std::basic_string<Ch>& str) {
-        return Parse<parseFlags, Encoding>(str.c_str());
-    }
-
-    GenericDocument& Parse(const std::basic_string<Ch>& str) {
-        return Parse<kParseDefaultFlags>(str);
-    }
-#endif // RAPIDJSON_HAS_STDSTRING    
-
-    //!@}
-
-    //!@name Handling parse errors
-    //!@{
-
-    //! Whether a parse error has occurred in the last parsing.
-    bool HasParseError() const { return parseResult_.IsError(); }
-
-    //! Get the \ref ParseErrorCode of last parsing.
-    ParseErrorCode GetParseError() const { return parseResult_.Code(); }
-
-    //! Get the position of last parsing error in input, 0 otherwise.
-    size_t GetErrorOffset() const { return parseResult_.Offset(); }
-
-    //! Implicit conversion to get the last parse result
-#ifndef __clang // -Wdocumentation
-    /*! \return \ref ParseResult of the last parse operation
-
-        \code
-          Document doc;
-          ParseResult ok = doc.Parse(json);
-          if (!ok)
-            printf( "JSON parse error: %s (%u)\n", GetParseError_En(ok.Code()), ok.Offset());
-        \endcode
-     */
-#endif
-    operator ParseResult() const { return parseResult_; }
-    //!@}
-
-    //! Get the allocator of this document.
-    Allocator& GetAllocator() {
-        RAPIDJSON_ASSERT(allocator_);
-        return *allocator_;
-    }
-
-    //! Get the capacity of stack in bytes.
-    size_t GetStackCapacity() const { return stack_.GetCapacity(); }
-
-private:
-    // clear stack on any exit from ParseStream, e.g. due to exception
-    struct ClearStackOnExit {
-        explicit ClearStackOnExit(GenericDocument& d) : d_(d) {}
-        ~ClearStackOnExit() { d_.ClearStack(); }
-    private:
-        ClearStackOnExit(const ClearStackOnExit&);
-        ClearStackOnExit& operator=(const ClearStackOnExit&);
-        GenericDocument& d_;
-    };
-
-    // callers of the following private Handler functions
-    // template <typename,typename,typename> friend class GenericReader; // for parsing
-    template <typename, typename> friend class GenericValue; // for deep copying
-
-public:
-    // Implementation of Handler
-    bool Null() { new (stack_.template Push<ValueType>()) ValueType(); return true; }
-    bool Bool(bool b) { new (stack_.template Push<ValueType>()) ValueType(b); return true; }
-    bool Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
-    bool Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
-    bool Int64(int64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
-    bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
-    bool Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); return true; }
-
-    bool RawNumber(const Ch* str, SizeType length, bool copy) { 
-        if (copy) 
-            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
-        else
-            new (stack_.template Push<ValueType>()) ValueType(str, length);
-        return true;
-    }
-
-    bool String(const Ch* str, SizeType length, bool copy) { 
-        if (copy) 
-            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
-        else
-            new (stack_.template Push<ValueType>()) ValueType(str, length);
-        return true;
-    }
-
-    bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); return true; }
-    
-    bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); }
-
-    bool EndObject(SizeType memberCount) {
-        typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
-        stack_.template Top<ValueType>()->SetObjectRaw(members, memberCount, GetAllocator());
-        return true;
-    }
-
-    bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); return true; }
-    
-    bool EndArray(SizeType elementCount) {
-        ValueType* elements = stack_.template Pop<ValueType>(elementCount);
-        stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator());
-        return true;
-    }
-
-private:
-    //! Prohibit copying
-    GenericDocument(const GenericDocument&);
-    //! Prohibit assignment
-    GenericDocument& operator=(const GenericDocument&);
-
-    void ClearStack() {
-        if (Allocator::kNeedFree)
-            while (stack_.GetSize() > 0)    // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects)
-                (stack_.template Pop<ValueType>(1))->~ValueType();
-        else
-            stack_.Clear();
-        stack_.ShrinkToFit();
-    }
-
-    void Destroy() {
-        RAPIDJSON_DELETE(ownAllocator_);
-    }
-
-    static const size_t kDefaultStackCapacity = 1024;
-    Allocator* allocator_;
-    Allocator* ownAllocator_;
-    internal::Stack<StackAllocator> stack_;
-    ParseResult parseResult_;
-};
-
-//! GenericDocument with UTF8 encoding
-typedef GenericDocument<UTF8<> > Document;
-
-
-//! Helper class for accessing Value of array type.
-/*!
-    Instance of this helper class is obtained by \c GenericValue::GetArray().
-    In addition to all APIs for array type, it provides range-based for loop if \c RAPIDJSON_HAS_CXX11_RANGE_FOR=1.
-*/
-template <bool Const, typename ValueT>
-class GenericArray {
-public:
-    typedef GenericArray<true, ValueT> ConstArray;
-    typedef GenericArray<false, ValueT> Array;
-    typedef ValueT PlainType;
-    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
-    typedef ValueType* ValueIterator;  // This may be const or non-const iterator
-    typedef const ValueT* ConstValueIterator;
-    typedef typename ValueType::AllocatorType AllocatorType;
-    typedef typename ValueType::StringRefType StringRefType;
-
-    template <typename, typename>
-    friend class GenericValue;
-
-    GenericArray(const GenericArray& rhs) : value_(rhs.value_) {}
-    GenericArray& operator=(const GenericArray& rhs) { value_ = rhs.value_; return *this; }
-    ~GenericArray() {}
-
-    operator ValueType&() const { return value_; }
-    SizeType Size() const { return value_.Size(); }
-    SizeType Capacity() const { return value_.Capacity(); }
-    bool Empty() const { return value_.Empty(); }
-    void Clear() const { value_.Clear(); }
-    ValueType& operator[](SizeType index) const {  return value_[index]; }
-    ValueIterator Begin() const { return value_.Begin(); }
-    ValueIterator End() const { return value_.End(); }
-    GenericArray Reserve(SizeType newCapacity, AllocatorType &allocator) const { value_.Reserve(newCapacity, allocator); return *this; }
-    GenericArray PushBack(ValueType& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericArray PushBack(ValueType&& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericArray PushBack(StringRefType value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
-    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (const GenericArray&)) PushBack(T value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
-    GenericArray PopBack() const { value_.PopBack(); return *this; }
-    ValueIterator Erase(ConstValueIterator pos) const { return value_.Erase(pos); }
-    ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) const { return value_.Erase(first, last); }
-
-#if RAPIDJSON_HAS_CXX11_RANGE_FOR
-    ValueIterator begin() const { return value_.Begin(); }
-    ValueIterator end() const { return value_.End(); }
-#endif
-
-private:
-    GenericArray();
-    GenericArray(ValueType& value) : value_(value) {}
-    ValueType& value_;
-};
-
-//! Helper class for accessing Value of object type.
-/*!
-    Instance of this helper class is obtained by \c GenericValue::GetObject().
-    In addition to all APIs for array type, it provides range-based for loop if \c RAPIDJSON_HAS_CXX11_RANGE_FOR=1.
-*/
-template <bool Const, typename ValueT>
-class GenericObject {
-public:
-    typedef GenericObject<true, ValueT> ConstObject;
-    typedef GenericObject<false, ValueT> Object;
-    typedef ValueT PlainType;
-    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
-    typedef GenericMemberIterator<Const, typename ValueT::EncodingType, typename ValueT::AllocatorType> MemberIterator;  // This may be const or non-const iterator
-    typedef GenericMemberIterator<true, typename ValueT::EncodingType, typename ValueT::AllocatorType> ConstMemberIterator;
-    typedef typename ValueType::AllocatorType AllocatorType;
-    typedef typename ValueType::StringRefType StringRefType;
-    typedef typename ValueType::EncodingType EncodingType;
-    typedef typename ValueType::Ch Ch;
-
-    template <typename, typename>
-    friend class GenericValue;
-
-    GenericObject(const GenericObject& rhs) : value_(rhs.value_) {}
-    GenericObject& operator=(const GenericObject& rhs) { value_ = rhs.value_; return *this; }
-    ~GenericObject() {}
-
-    operator ValueType&() const { return value_; }
-    SizeType MemberCount() const { return value_.MemberCount(); }
-    SizeType MemberCapacity() const { return value_.MemberCapacity(); }
-    bool ObjectEmpty() const { return value_.ObjectEmpty(); }
-    template <typename T> ValueType& operator[](T* name) const { return value_[name]; }
-    template <typename SourceAllocator> ValueType& operator[](const GenericValue<EncodingType, SourceAllocator>& name) const { return value_[name]; }
-#if RAPIDJSON_HAS_STDSTRING
-    ValueType& operator[](const std::basic_string<Ch>& name) const { return value_[name]; }
-#endif
-    MemberIterator MemberBegin() const { return value_.MemberBegin(); }
-    MemberIterator MemberEnd() const { return value_.MemberEnd(); }
-    GenericObject MemberReserve(SizeType newCapacity, AllocatorType &allocator) const { value_.MemberReserve(newCapacity, allocator); return *this; }
-    bool HasMember(const Ch* name) const { return value_.HasMember(name); }
-#if RAPIDJSON_HAS_STDSTRING
-    bool HasMember(const std::basic_string<Ch>& name) const { return value_.HasMember(name); }
-#endif
-    template <typename SourceAllocator> bool HasMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.HasMember(name); }
-    MemberIterator FindMember(const Ch* name) const { return value_.FindMember(name); }
-    template <typename SourceAllocator> MemberIterator FindMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.FindMember(name); }
-#if RAPIDJSON_HAS_STDSTRING
-    MemberIterator FindMember(const std::basic_string<Ch>& name) const { return value_.FindMember(name); }
-#endif
-    GenericObject AddMember(ValueType& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-    GenericObject AddMember(ValueType& name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-#if RAPIDJSON_HAS_STDSTRING
-    GenericObject AddMember(ValueType& name, std::basic_string<Ch>& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-#endif
-    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&)) AddMember(ValueType& name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericObject AddMember(ValueType&& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-    GenericObject AddMember(ValueType&& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-    GenericObject AddMember(ValueType& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-    GenericObject AddMember(StringRefType name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericObject AddMember(StringRefType name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-    GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericObject)) AddMember(StringRefType name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
-    void RemoveAllMembers() { value_.RemoveAllMembers(); }
-    bool RemoveMember(const Ch* name) const { return value_.RemoveMember(name); }
-#if RAPIDJSON_HAS_STDSTRING
-    bool RemoveMember(const std::basic_string<Ch>& name) const { return value_.RemoveMember(name); }
-#endif
-    template <typename SourceAllocator> bool RemoveMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.RemoveMember(name); }
-    MemberIterator RemoveMember(MemberIterator m) const { return value_.RemoveMember(m); }
-    MemberIterator EraseMember(ConstMemberIterator pos) const { return value_.EraseMember(pos); }
-    MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) const { return value_.EraseMember(first, last); }
-    bool EraseMember(const Ch* name) const { return value_.EraseMember(name); }
-#if RAPIDJSON_HAS_STDSTRING
-    bool EraseMember(const std::basic_string<Ch>& name) const { return EraseMember(ValueType(StringRef(name))); }
-#endif
-    template <typename SourceAllocator> bool EraseMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.EraseMember(name); }
-
-#if RAPIDJSON_HAS_CXX11_RANGE_FOR
-    MemberIterator begin() const { return value_.MemberBegin(); }
-    MemberIterator end() const { return value_.MemberEnd(); }
-#endif
-
-private:
-    GenericObject();
-    GenericObject(ValueType& value) : value_(value) {}
-    ValueType& value_;
-};
-
-RAPIDJSON_NAMESPACE_END
-RAPIDJSON_DIAG_POP
-
-#endif // RAPIDJSON_DOCUMENT_H_
diff --git a/thirdparty/rapidjson/encodedstream.h b/thirdparty/rapidjson/encodedstream.h
deleted file mode 100644
index cf046b8..0000000
--- a/thirdparty/rapidjson/encodedstream.h
+++ /dev/null
@@ -1,299 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ENCODEDSTREAM_H_
-#define RAPIDJSON_ENCODEDSTREAM_H_
-
-#include "stream.h"
-#include "memorystream.h"
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Input byte stream wrapper with a statically bound encoding.
-/*!
-    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
-    \tparam InputByteStream Type of input byte stream. For example, FileReadStream.
-*/
-template <typename Encoding, typename InputByteStream>
-class EncodedInputStream {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-public:
-    typedef typename Encoding::Ch Ch;
-
-    EncodedInputStream(InputByteStream& is) : is_(is) { 
-        current_ = Encoding::TakeBOM(is_);
-    }
-
-    Ch Peek() const { return current_; }
-    Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
-    size_t Tell() const { return is_.Tell(); }
-
-    // Not implemented
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); } 
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    EncodedInputStream(const EncodedInputStream&);
-    EncodedInputStream& operator=(const EncodedInputStream&);
-
-    InputByteStream& is_;
-    Ch current_;
-};
-
-//! Specialized for UTF8 MemoryStream.
-template <>
-class EncodedInputStream<UTF8<>, MemoryStream> {
-public:
-    typedef UTF8<>::Ch Ch;
-
-    EncodedInputStream(MemoryStream& is) : is_(is) {
-        if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
-        if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
-        if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
-    }
-    Ch Peek() const { return is_.Peek(); }
-    Ch Take() { return is_.Take(); }
-    size_t Tell() const { return is_.Tell(); }
-
-    // Not implemented
-    void Put(Ch) {}
-    void Flush() {} 
-    Ch* PutBegin() { return 0; }
-    size_t PutEnd(Ch*) { return 0; }
-
-    MemoryStream& is_;
-
-private:
-    EncodedInputStream(const EncodedInputStream&);
-    EncodedInputStream& operator=(const EncodedInputStream&);
-};
-
-//! Output byte stream wrapper with statically bound encoding.
-/*!
-    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
-    \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
-*/
-template <typename Encoding, typename OutputByteStream>
-class EncodedOutputStream {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-public:
-    typedef typename Encoding::Ch Ch;
-
-    EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) { 
-        if (putBOM)
-            Encoding::PutBOM(os_);
-    }
-
-    void Put(Ch c) { Encoding::Put(os_, c);  }
-    void Flush() { os_.Flush(); }
-
-    // Not implemented
-    Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
-    Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
-    size_t Tell() const { RAPIDJSON_ASSERT(false);  return 0; }
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    EncodedOutputStream(const EncodedOutputStream&);
-    EncodedOutputStream& operator=(const EncodedOutputStream&);
-
-    OutputByteStream& os_;
-};
-
-#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
-
-//! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
-/*!
-    \tparam CharType Type of character for reading.
-    \tparam InputByteStream type of input byte stream to be wrapped.
-*/
-template <typename CharType, typename InputByteStream>
-class AutoUTFInputStream {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-public:
-    typedef CharType Ch;
-
-    //! Constructor.
-    /*!
-        \param is input stream to be wrapped.
-        \param type UTF encoding type if it is not detected from the stream.
-    */
-    AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
-        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);        
-        DetectType();
-        static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
-        takeFunc_ = f[type_];
-        current_ = takeFunc_(*is_);
-    }
-
-    UTFType GetType() const { return type_; }
-    bool HasBOM() const { return hasBOM_; }
-
-    Ch Peek() const { return current_; }
-    Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
-    size_t Tell() const { return is_->Tell(); }
-
-    // Not implemented
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); } 
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    AutoUTFInputStream(const AutoUTFInputStream&);
-    AutoUTFInputStream& operator=(const AutoUTFInputStream&);
-
-    // Detect encoding type with BOM or RFC 4627
-    void DetectType() {
-        // BOM (Byte Order Mark):
-        // 00 00 FE FF  UTF-32BE
-        // FF FE 00 00  UTF-32LE
-        // FE FF        UTF-16BE
-        // FF FE        UTF-16LE
-        // EF BB BF     UTF-8
-
-        const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());
-        if (!c)
-            return;
-
-        unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
-        hasBOM_ = false;
-        if (bom == 0xFFFE0000)                  { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
-        else if (bom == 0x0000FEFF)             { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
-        else if ((bom & 0xFFFF) == 0xFFFE)      { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take();                           }
-        else if ((bom & 0xFFFF) == 0xFEFF)      { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take();                           }
-        else if ((bom & 0xFFFFFF) == 0xBFBBEF)  { type_ = kUTF8;    hasBOM_ = true; is_->Take(); is_->Take(); is_->Take();              }
-
-        // RFC 4627: Section 3
-        // "Since the first two characters of a JSON text will always be ASCII
-        // characters [RFC0020], it is possible to determine whether an octet
-        // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
-        // at the pattern of nulls in the first four octets."
-        // 00 00 00 xx  UTF-32BE
-        // 00 xx 00 xx  UTF-16BE
-        // xx 00 00 00  UTF-32LE
-        // xx 00 xx 00  UTF-16LE
-        // xx xx xx xx  UTF-8
-
-        if (!hasBOM_) {
-            int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
-            switch (pattern) {
-            case 0x08: type_ = kUTF32BE; break;
-            case 0x0A: type_ = kUTF16BE; break;
-            case 0x01: type_ = kUTF32LE; break;
-            case 0x05: type_ = kUTF16LE; break;
-            case 0x0F: type_ = kUTF8;    break;
-            default: break; // Use type defined by user.
-            }
-        }
-
-        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
-        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
-        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
-    }
-
-    typedef Ch (*TakeFunc)(InputByteStream& is);
-    InputByteStream* is_;
-    UTFType type_;
-    Ch current_;
-    TakeFunc takeFunc_;
-    bool hasBOM_;
-};
-
-//! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
-/*!
-    \tparam CharType Type of character for writing.
-    \tparam OutputByteStream type of output byte stream to be wrapped.
-*/
-template <typename CharType, typename OutputByteStream>
-class AutoUTFOutputStream {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-public:
-    typedef CharType Ch;
-
-    //! Constructor.
-    /*!
-        \param os output stream to be wrapped.
-        \param type UTF encoding type.
-        \param putBOM Whether to write BOM at the beginning of the stream.
-    */
-    AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
-        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
-
-        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
-        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
-        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
-
-        static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
-        putFunc_ = f[type_];
-
-        if (putBOM)
-            PutBOM();
-    }
-
-    UTFType GetType() const { return type_; }
-
-    void Put(Ch c) { putFunc_(*os_, c); }
-    void Flush() { os_->Flush(); } 
-
-    // Not implemented
-    Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
-    Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
-    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    AutoUTFOutputStream(const AutoUTFOutputStream&);
-    AutoUTFOutputStream& operator=(const AutoUTFOutputStream&);
-
-    void PutBOM() { 
-        typedef void (*PutBOMFunc)(OutputByteStream&);
-        static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
-        f[type_](*os_);
-    }
-
-    typedef void (*PutFunc)(OutputByteStream&, Ch);
-
-    OutputByteStream* os_;
-    UTFType type_;
-    PutFunc putFunc_;
-};
-
-#undef RAPIDJSON_ENCODINGS_FUNC
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/thirdparty/rapidjson/encodings.h b/thirdparty/rapidjson/encodings.h
deleted file mode 100644
index 50ad18b..0000000
--- a/thirdparty/rapidjson/encodings.h
+++ /dev/null
@@ -1,716 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ENCODINGS_H_
-#define RAPIDJSON_ENCODINGS_H_
-
-#include "rapidjson.h"
-
-#if defined(_MSC_VER) && !defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-#elif defined(__GNUC__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-RAPIDJSON_DIAG_OFF(overflow)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Encoding
-
-/*! \class rapidjson::Encoding
-    \brief Concept for encoding of Unicode characters.
-
-\code
-concept Encoding {
-    typename Ch;    //! Type of character. A "character" is actually a code unit in unicode's definition.
-
-    enum { supportUnicode = 1 }; // or 0 if not supporting unicode
-
-    //! \brief Encode a Unicode codepoint to an output stream.
-    //! \param os Output stream.
-    //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively.
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint);
-
-    //! \brief Decode a Unicode codepoint from an input stream.
-    //! \param is Input stream.
-    //! \param codepoint Output of the unicode codepoint.
-    //! \return true if a valid codepoint can be decoded from the stream.
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint);
-
-    //! \brief Validate one Unicode codepoint from an encoded stream.
-    //! \param is Input stream to obtain codepoint.
-    //! \param os Output for copying one codepoint.
-    //! \return true if it is valid.
-    //! \note This function just validating and copying the codepoint without actually decode it.
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os);
-
-    // The following functions are deal with byte streams.
-
-    //! Take a character from input byte stream, skip BOM if exist.
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is);
-
-    //! Take a character from input byte stream.
-    template <typename InputByteStream>
-    static Ch Take(InputByteStream& is);
-
-    //! Put BOM to output byte stream.
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os);
-
-    //! Put a character to output byte stream.
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, Ch c);
-};
-\endcode
-*/
-
-///////////////////////////////////////////////////////////////////////////////
-// UTF8
-
-//! UTF-8 encoding.
-/*! http://en.wikipedia.org/wiki/UTF-8
-    http://tools.ietf.org/html/rfc3629
-    \tparam CharType Code unit for storing 8-bit UTF-8 data. Default is char.
-    \note implements Encoding concept
-*/
-template<typename CharType = char>
-struct UTF8 {
-    typedef CharType Ch;
-
-    enum { supportUnicode = 1 };
-
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint) {
-        if (codepoint <= 0x7F) 
-            os.Put(static_cast<Ch>(codepoint & 0xFF));
-        else if (codepoint <= 0x7FF) {
-            os.Put(static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
-            os.Put(static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
-        }
-        else if (codepoint <= 0xFFFF) {
-            os.Put(static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
-            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-        }
-        else {
-            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-            os.Put(static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
-            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
-            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-        }
-    }
-
-    template<typename OutputStream>
-    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
-        if (codepoint <= 0x7F) 
-            PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
-        else if (codepoint <= 0x7FF) {
-            PutUnsafe(os, static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
-            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
-        }
-        else if (codepoint <= 0xFFFF) {
-            PutUnsafe(os, static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
-            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-            PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-        }
-        else {
-            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-            PutUnsafe(os, static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
-            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
-            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-            PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-        }
-    }
-
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint) {
-#define RAPIDJSON_COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
-#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
-        typename InputStream::Ch c = is.Take();
-        if (!(c & 0x80)) {
-            *codepoint = static_cast<unsigned char>(c);
-            return true;
-        }
-
-        unsigned char type = GetRange(static_cast<unsigned char>(c));
-        if (type >= 32) {
-            *codepoint = 0;
-        } else {
-            *codepoint = (0xFFu >> type) & static_cast<unsigned char>(c);
-        }
-        bool result = true;
-        switch (type) {
-        case 2: RAPIDJSON_TAIL(); return result;
-        case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
-        case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result;
-        case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
-        case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
-        case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result;
-        case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
-        default: return false;
-        }
-#undef RAPIDJSON_COPY
-#undef RAPIDJSON_TRANS
-#undef RAPIDJSON_TAIL
-    }
-
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os) {
-#define RAPIDJSON_COPY() os.Put(c = is.Take())
-#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
-        Ch c;
-        RAPIDJSON_COPY();
-        if (!(c & 0x80))
-            return true;
-
-        bool result = true;
-        switch (GetRange(static_cast<unsigned char>(c))) {
-        case 2: RAPIDJSON_TAIL(); return result;
-        case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
-        case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result;
-        case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
-        case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
-        case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result;
-        case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
-        default: return false;
-        }
-#undef RAPIDJSON_COPY
-#undef RAPIDJSON_TRANS
-#undef RAPIDJSON_TAIL
-    }
-
-    static unsigned char GetRange(unsigned char c) {
-        // Referring to DFA of http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-        // With new mapping 1 -> 0x10, 7 -> 0x20, 9 -> 0x40, such that AND operation can test multiple types.
-        static const unsigned char type[] = {
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-            0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
-            0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
-            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
-            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
-            8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-            10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
-        };
-        return type[c];
-    }
-
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        typename InputByteStream::Ch c = Take(is);
-        if (static_cast<unsigned char>(c) != 0xEFu) return c;
-        c = is.Take();
-        if (static_cast<unsigned char>(c) != 0xBBu) return c;
-        c = is.Take();
-        if (static_cast<unsigned char>(c) != 0xBFu) return c;
-        c = is.Take();
-        return c;
-    }
-
-    template <typename InputByteStream>
-    static Ch Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        return static_cast<Ch>(is.Take());
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xEFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xBBu));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xBFu));
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, Ch c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(c));
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// UTF16
-
-//! UTF-16 encoding.
-/*! http://en.wikipedia.org/wiki/UTF-16
-    http://tools.ietf.org/html/rfc2781
-    \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead.
-    \note implements Encoding concept
-
-    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
-    For streaming, use UTF16LE and UTF16BE, which handle endianness.
-*/
-template<typename CharType = wchar_t>
-struct UTF16 {
-    typedef CharType Ch;
-    RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 2);
-
-    enum { supportUnicode = 1 };
-
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
-        if (codepoint <= 0xFFFF) {
-            RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
-            os.Put(static_cast<typename OutputStream::Ch>(codepoint));
-        }
-        else {
-            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-            unsigned v = codepoint - 0x10000;
-            os.Put(static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
-            os.Put(static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
-        }
-    }
-
-
-    template<typename OutputStream>
-    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
-        if (codepoint <= 0xFFFF) {
-            RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
-            PutUnsafe(os, static_cast<typename OutputStream::Ch>(codepoint));
-        }
-        else {
-            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-            unsigned v = codepoint - 0x10000;
-            PutUnsafe(os, static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
-            PutUnsafe(os, static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
-        }
-    }
-
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
-        typename InputStream::Ch c = is.Take();
-        if (c < 0xD800 || c > 0xDFFF) {
-            *codepoint = static_cast<unsigned>(c);
-            return true;
-        }
-        else if (c <= 0xDBFF) {
-            *codepoint = (static_cast<unsigned>(c) & 0x3FF) << 10;
-            c = is.Take();
-            *codepoint |= (static_cast<unsigned>(c) & 0x3FF);
-            *codepoint += 0x10000;
-            return c >= 0xDC00 && c <= 0xDFFF;
-        }
-        return false;
-    }
-
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
-        typename InputStream::Ch c;
-        os.Put(static_cast<typename OutputStream::Ch>(c = is.Take()));
-        if (c < 0xD800 || c > 0xDFFF)
-            return true;
-        else if (c <= 0xDBFF) {
-            os.Put(c = is.Take());
-            return c >= 0xDC00 && c <= 0xDFFF;
-        }
-        return false;
-    }
-};
-
-//! UTF-16 little endian encoding.
-template<typename CharType = wchar_t>
-struct UTF16LE : UTF16<CharType> {
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = Take(is);
-        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
-    }
-
-    template <typename InputByteStream>
-    static CharType Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        unsigned c = static_cast<uint8_t>(is.Take());
-        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
-        return static_cast<CharType>(c);
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, CharType c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
-    }
-};
-
-//! UTF-16 big endian encoding.
-template<typename CharType = wchar_t>
-struct UTF16BE : UTF16<CharType> {
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = Take(is);
-        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
-    }
-
-    template <typename InputByteStream>
-    static CharType Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
-        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
-        return static_cast<CharType>(c);
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, CharType c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// UTF32
-
-//! UTF-32 encoding. 
-/*! http://en.wikipedia.org/wiki/UTF-32
-    \tparam CharType Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead.
-    \note implements Encoding concept
-
-    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
-    For streaming, use UTF32LE and UTF32BE, which handle endianness.
-*/
-template<typename CharType = unsigned>
-struct UTF32 {
-    typedef CharType Ch;
-    RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 4);
-
-    enum { supportUnicode = 1 };
-
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
-        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-        os.Put(codepoint);
-    }
-
-    template<typename OutputStream>
-    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
-        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-        PutUnsafe(os, codepoint);
-    }
-
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
-        Ch c = is.Take();
-        *codepoint = c;
-        return c <= 0x10FFFF;
-    }
-
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
-        Ch c;
-        os.Put(c = is.Take());
-        return c <= 0x10FFFF;
-    }
-};
-
-//! UTF-32 little endian enocoding.
-template<typename CharType = unsigned>
-struct UTF32LE : UTF32<CharType> {
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = Take(is);
-        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c;
-    }
-
-    template <typename InputByteStream>
-    static CharType Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        unsigned c = static_cast<uint8_t>(is.Take());
-        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
-        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
-        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
-        return static_cast<CharType>(c);
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, CharType c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
-    }
-};
-
-//! UTF-32 big endian encoding.
-template<typename CharType = unsigned>
-struct UTF32BE : UTF32<CharType> {
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = Take(is);
-        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c; 
-    }
-
-    template <typename InputByteStream>
-    static CharType Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
-        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
-        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
-        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
-        return static_cast<CharType>(c);
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
-        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, CharType c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
-        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// ASCII
-
-//! ASCII encoding.
-/*! http://en.wikipedia.org/wiki/ASCII
-    \tparam CharType Code unit for storing 7-bit ASCII data. Default is char.
-    \note implements Encoding concept
-*/
-template<typename CharType = char>
-struct ASCII {
-    typedef CharType Ch;
-
-    enum { supportUnicode = 0 };
-
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint) {
-        RAPIDJSON_ASSERT(codepoint <= 0x7F);
-        os.Put(static_cast<Ch>(codepoint & 0xFF));
-    }
-
-    template<typename OutputStream>
-    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
-        RAPIDJSON_ASSERT(codepoint <= 0x7F);
-        PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
-    }
-
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint) {
-        uint8_t c = static_cast<uint8_t>(is.Take());
-        *codepoint = c;
-        return c <= 0X7F;
-    }
-
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os) {
-        uint8_t c = static_cast<uint8_t>(is.Take());
-        os.Put(static_cast<typename OutputStream::Ch>(c));
-        return c <= 0x7F;
-    }
-
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        uint8_t c = static_cast<uint8_t>(Take(is));
-        return static_cast<Ch>(c);
-    }
-
-    template <typename InputByteStream>
-    static Ch Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        return static_cast<Ch>(is.Take());
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        (void)os;
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, Ch c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(c));
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// AutoUTF
-
-//! Runtime-specified UTF encoding type of a stream.
-enum UTFType {
-    kUTF8 = 0,      //!< UTF-8.
-    kUTF16LE = 1,   //!< UTF-16 little endian.
-    kUTF16BE = 2,   //!< UTF-16 big endian.
-    kUTF32LE = 3,   //!< UTF-32 little endian.
-    kUTF32BE = 4    //!< UTF-32 big endian.
-};
-
-//! Dynamically select encoding according to stream's runtime-specified UTF encoding type.
-/*! \note This class can be used with AutoUTFInputtStream and AutoUTFOutputStream, which provides GetType().
-*/
-template<typename CharType>
-struct AutoUTF {
-    typedef CharType Ch;
-
-    enum { supportUnicode = 1 };
-
-#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
-
-    template<typename OutputStream>
-    static RAPIDJSON_FORCEINLINE void Encode(OutputStream& os, unsigned codepoint) {
-        typedef void (*EncodeFunc)(OutputStream&, unsigned);
-        static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Encode) };
-        (*f[os.GetType()])(os, codepoint);
-    }
-
-    template<typename OutputStream>
-    static RAPIDJSON_FORCEINLINE void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
-        typedef void (*EncodeFunc)(OutputStream&, unsigned);
-        static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(EncodeUnsafe) };
-        (*f[os.GetType()])(os, codepoint);
-    }
-
-    template <typename InputStream>
-    static RAPIDJSON_FORCEINLINE bool Decode(InputStream& is, unsigned* codepoint) {
-        typedef bool (*DecodeFunc)(InputStream&, unsigned*);
-        static const DecodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Decode) };
-        return (*f[is.GetType()])(is, codepoint);
-    }
-
-    template <typename InputStream, typename OutputStream>
-    static RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) {
-        typedef bool (*ValidateFunc)(InputStream&, OutputStream&);
-        static const ValidateFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Validate) };
-        return (*f[is.GetType()])(is, os);
-    }
-
-#undef RAPIDJSON_ENCODINGS_FUNC
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Transcoder
-
-//! Encoding conversion.
-template<typename SourceEncoding, typename TargetEncoding>
-struct Transcoder {
-    //! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream.
-    template<typename InputStream, typename OutputStream>
-    static RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) {
-        unsigned codepoint;
-        if (!SourceEncoding::Decode(is, &codepoint))
-            return false;
-        TargetEncoding::Encode(os, codepoint);
-        return true;
-    }
-
-    template<typename InputStream, typename OutputStream>
-    static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
-        unsigned codepoint;
-        if (!SourceEncoding::Decode(is, &codepoint))
-            return false;
-        TargetEncoding::EncodeUnsafe(os, codepoint);
-        return true;
-    }
-
-    //! Validate one Unicode codepoint from an encoded stream.
-    template<typename InputStream, typename OutputStream>
-    static RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) {
-        return Transcode(is, os);   // Since source/target encoding is different, must transcode.
-    }
-};
-
-// Forward declaration.
-template<typename Stream>
-inline void PutUnsafe(Stream& stream, typename Stream::Ch c);
-
-//! Specialization of Transcoder with same source and target encoding.
-template<typename Encoding>
-struct Transcoder<Encoding, Encoding> {
-    template<typename InputStream, typename OutputStream>
-    static RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) {
-        os.Put(is.Take());  // Just copy one code unit. This semantic is different from primary template class.
-        return true;
-    }
-    
-    template<typename InputStream, typename OutputStream>
-    static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
-        PutUnsafe(os, is.Take());  // Just copy one code unit. This semantic is different from primary template class.
-        return true;
-    }
-    
-    template<typename InputStream, typename OutputStream>
-    static RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) {
-        return Encoding::Validate(is, os);  // source/target encoding are the same
-    }
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__GNUC__) || (defined(_MSC_VER) && !defined(__clang__))
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/thirdparty/rapidjson/error/en.h b/thirdparty/rapidjson/error/en.h
deleted file mode 100644
index 5d2e57b..0000000
--- a/thirdparty/rapidjson/error/en.h
+++ /dev/null
@@ -1,122 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ERROR_EN_H_
-#define RAPIDJSON_ERROR_EN_H_
-
-#include "error.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(switch-enum)
-RAPIDJSON_DIAG_OFF(covered-switch-default)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Maps error code of parsing into error message.
-/*!
-    \ingroup RAPIDJSON_ERRORS
-    \param parseErrorCode Error code obtained in parsing.
-    \return the error message.
-    \note User can make a copy of this function for localization.
-        Using switch-case is safer for future modification of error codes.
-*/
-inline const RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErrorCode) {
-    switch (parseErrorCode) {
-        case kParseErrorNone:                           return RAPIDJSON_ERROR_STRING("No error.");
-
-        case kParseErrorDocumentEmpty:                  return RAPIDJSON_ERROR_STRING("The document is empty.");
-        case kParseErrorDocumentRootNotSingular:        return RAPIDJSON_ERROR_STRING("The document root must not be followed by other values.");
-    
-        case kParseErrorValueInvalid:                   return RAPIDJSON_ERROR_STRING("Invalid value.");
-    
-        case kParseErrorObjectMissName:                 return RAPIDJSON_ERROR_STRING("Missing a name for object member.");
-        case kParseErrorObjectMissColon:                return RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member.");
-        case kParseErrorObjectMissCommaOrCurlyBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member.");
-    
-        case kParseErrorArrayMissCommaOrSquareBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element.");
-
-        case kParseErrorStringUnicodeEscapeInvalidHex:  return RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string.");
-        case kParseErrorStringUnicodeSurrogateInvalid:  return RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid.");
-        case kParseErrorStringEscapeInvalid:            return RAPIDJSON_ERROR_STRING("Invalid escape character in string.");
-        case kParseErrorStringMissQuotationMark:        return RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string.");
-        case kParseErrorStringInvalidEncoding:          return RAPIDJSON_ERROR_STRING("Invalid encoding in string.");
-
-        case kParseErrorNumberTooBig:                   return RAPIDJSON_ERROR_STRING("Number too big to be stored in double.");
-        case kParseErrorNumberMissFraction:             return RAPIDJSON_ERROR_STRING("Miss fraction part in number.");
-        case kParseErrorNumberMissExponent:             return RAPIDJSON_ERROR_STRING("Miss exponent in number.");
-
-        case kParseErrorTermination:                    return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
-        case kParseErrorUnspecificSyntaxError:          return RAPIDJSON_ERROR_STRING("Unspecific syntax error.");
-
-        default:                                        return RAPIDJSON_ERROR_STRING("Unknown error.");
-    }
-}
-
-//! Maps error code of validation into error message.
-/*!
-    \ingroup RAPIDJSON_ERRORS
-    \param validateErrorCode Error code obtained from validator.
-    \return the error message.
-    \note User can make a copy of this function for localization.
-        Using switch-case is safer for future modification of error codes.
-*/
-inline const RAPIDJSON_ERROR_CHARTYPE* GetValidateError_En(ValidateErrorCode validateErrorCode) {
-    switch (validateErrorCode) {
-        case kValidateErrors:                           return RAPIDJSON_ERROR_STRING("One or more validation errors have occurred");
-        case kValidateErrorNone:                        return RAPIDJSON_ERROR_STRING("No error.");
-
-        case kValidateErrorMultipleOf:                  return RAPIDJSON_ERROR_STRING("Number '%actual' is not a multiple of the 'multipleOf' value '%expected'.");
-        case kValidateErrorMaximum:                     return RAPIDJSON_ERROR_STRING("Number '%actual' is greater than the 'maximum' value '%expected'.");
-        case kValidateErrorExclusiveMaximum:            return RAPIDJSON_ERROR_STRING("Number '%actual' is greater than or equal to the 'exclusiveMaximum' value '%expected'.");
-        case kValidateErrorMinimum:                     return RAPIDJSON_ERROR_STRING("Number '%actual' is less than the 'minimum' value '%expected'.");
-        case kValidateErrorExclusiveMinimum:            return RAPIDJSON_ERROR_STRING("Number '%actual' is less than or equal to the 'exclusiveMinimum' value '%expected'.");
-
-        case kValidateErrorMaxLength:                   return RAPIDJSON_ERROR_STRING("String '%actual' is longer than the 'maxLength' value '%expected'.");
-        case kValidateErrorMinLength:                   return RAPIDJSON_ERROR_STRING("String '%actual' is shorter than the 'minLength' value '%expected'.");
-        case kValidateErrorPattern:                     return RAPIDJSON_ERROR_STRING("String '%actual' does not match the 'pattern' regular expression.");
-
-        case kValidateErrorMaxItems:                    return RAPIDJSON_ERROR_STRING("Array of length '%actual' is longer than the 'maxItems' value '%expected'.");
-        case kValidateErrorMinItems:                    return RAPIDJSON_ERROR_STRING("Array of length '%actual' is shorter than the 'minItems' value '%expected'.");
-        case kValidateErrorUniqueItems:                 return RAPIDJSON_ERROR_STRING("Array has duplicate items at indices '%duplicates' but 'uniqueItems' is true.");
-        case kValidateErrorAdditionalItems:             return RAPIDJSON_ERROR_STRING("Array has an additional item at index '%disallowed' that is not allowed by the schema.");
-
-        case kValidateErrorMaxProperties:               return RAPIDJSON_ERROR_STRING("Object has '%actual' members which is more than 'maxProperties' value '%expected'.");
-        case kValidateErrorMinProperties:               return RAPIDJSON_ERROR_STRING("Object has '%actual' members which is less than 'minProperties' value '%expected'.");
-        case kValidateErrorRequired:                    return RAPIDJSON_ERROR_STRING("Object is missing the following members required by the schema: '%missing'.");
-        case kValidateErrorAdditionalProperties:        return RAPIDJSON_ERROR_STRING("Object has an additional member '%disallowed' that is not allowed by the schema.");
-        case kValidateErrorPatternProperties:           return RAPIDJSON_ERROR_STRING("Object has 'patternProperties' that are not allowed by the schema.");
-        case kValidateErrorDependencies:                return RAPIDJSON_ERROR_STRING("Object has missing property or schema dependencies, refer to following errors.");
-
-        case kValidateErrorEnum:                        return RAPIDJSON_ERROR_STRING("Property has a value that is not one of its allowed enumerated values.");
-        case kValidateErrorType:                        return RAPIDJSON_ERROR_STRING("Property has a type '%actual' that is not in the following list: '%expected'.");
-
-        case kValidateErrorOneOf:                       return RAPIDJSON_ERROR_STRING("Property did not match any of the sub-schemas specified by 'oneOf', refer to following errors.");
-        case kValidateErrorOneOfMatch:                  return RAPIDJSON_ERROR_STRING("Property matched more than one of the sub-schemas specified by 'oneOf'.");
-        case kValidateErrorAllOf:                       return RAPIDJSON_ERROR_STRING("Property did not match all of the sub-schemas specified by 'allOf', refer to following errors.");
-        case kValidateErrorAnyOf:                       return RAPIDJSON_ERROR_STRING("Property did not match any of the sub-schemas specified by 'anyOf', refer to following errors.");
-        case kValidateErrorNot:                         return RAPIDJSON_ERROR_STRING("Property matched the sub-schema specified by 'not'.");
-
-        default:                                        return RAPIDJSON_ERROR_STRING("Unknown error.");
-    }
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_ERROR_EN_H_
diff --git a/thirdparty/rapidjson/error/error.h b/thirdparty/rapidjson/error/error.h
deleted file mode 100644
index 6270da1..0000000
--- a/thirdparty/rapidjson/error/error.h
+++ /dev/null
@@ -1,216 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ERROR_ERROR_H_
-#define RAPIDJSON_ERROR_ERROR_H_
-
-#include "../rapidjson.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-/*! \file error.h */
-
-/*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ERROR_CHARTYPE
-
-//! Character type of error messages.
-/*! \ingroup RAPIDJSON_ERRORS
-    The default character type is \c char.
-    On Windows, user can define this macro as \c TCHAR for supporting both
-    unicode/non-unicode settings.
-*/
-#ifndef RAPIDJSON_ERROR_CHARTYPE
-#define RAPIDJSON_ERROR_CHARTYPE char
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ERROR_STRING
-
-//! Macro for converting string literial to \ref RAPIDJSON_ERROR_CHARTYPE[].
-/*! \ingroup RAPIDJSON_ERRORS
-    By default this conversion macro does nothing.
-    On Windows, user can define this macro as \c _T(x) for supporting both
-    unicode/non-unicode settings.
-*/
-#ifndef RAPIDJSON_ERROR_STRING
-#define RAPIDJSON_ERROR_STRING(x) x
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// ParseErrorCode
-
-//! Error code of parsing.
-/*! \ingroup RAPIDJSON_ERRORS
-    \see GenericReader::Parse, GenericReader::GetParseErrorCode
-*/
-enum ParseErrorCode {
-    kParseErrorNone = 0,                        //!< No error.
-
-    kParseErrorDocumentEmpty,                   //!< The document is empty.
-    kParseErrorDocumentRootNotSingular,         //!< The document root must not follow by other values.
-
-    kParseErrorValueInvalid,                    //!< Invalid value.
-
-    kParseErrorObjectMissName,                  //!< Missing a name for object member.
-    kParseErrorObjectMissColon,                 //!< Missing a colon after a name of object member.
-    kParseErrorObjectMissCommaOrCurlyBracket,   //!< Missing a comma or '}' after an object member.
-
-    kParseErrorArrayMissCommaOrSquareBracket,   //!< Missing a comma or ']' after an array element.
-
-    kParseErrorStringUnicodeEscapeInvalidHex,   //!< Incorrect hex digit after \\u escape in string.
-    kParseErrorStringUnicodeSurrogateInvalid,   //!< The surrogate pair in string is invalid.
-    kParseErrorStringEscapeInvalid,             //!< Invalid escape character in string.
-    kParseErrorStringMissQuotationMark,         //!< Missing a closing quotation mark in string.
-    kParseErrorStringInvalidEncoding,           //!< Invalid encoding in string.
-
-    kParseErrorNumberTooBig,                    //!< Number too big to be stored in double.
-    kParseErrorNumberMissFraction,              //!< Miss fraction part in number.
-    kParseErrorNumberMissExponent,              //!< Miss exponent in number.
-
-    kParseErrorTermination,                     //!< Parsing was terminated.
-    kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
-};
-
-//! Result of parsing (wraps ParseErrorCode)
-/*!
-    \ingroup RAPIDJSON_ERRORS
-    \code
-        Document doc;
-        ParseResult ok = doc.Parse("[42]");
-        if (!ok) {
-            fprintf(stderr, "JSON parse error: %s (%u)",
-                    GetParseError_En(ok.Code()), ok.Offset());
-            exit(EXIT_FAILURE);
-        }
-    \endcode
-    \see GenericReader::Parse, GenericDocument::Parse
-*/
-struct ParseResult {
-    //!! Unspecified boolean type
-    typedef bool (ParseResult::*BooleanType)() const;
-public:
-    //! Default constructor, no error.
-    ParseResult() : code_(kParseErrorNone), offset_(0) {}
-    //! Constructor to set an error.
-    ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}
-
-    //! Get the error code.
-    ParseErrorCode Code() const { return code_; }
-    //! Get the error offset, if \ref IsError(), 0 otherwise.
-    size_t Offset() const { return offset_; }
-
-    //! Explicit conversion to \c bool, returns \c true, iff !\ref IsError().
-    operator BooleanType() const { return !IsError() ? &ParseResult::IsError : NULL; }
-    //! Whether the result is an error.
-    bool IsError() const { return code_ != kParseErrorNone; }
-
-    bool operator==(const ParseResult& that) const { return code_ == that.code_; }
-    bool operator==(ParseErrorCode code) const { return code_ == code; }
-    friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; }
-
-    bool operator!=(const ParseResult& that) const { return !(*this == that); }
-    bool operator!=(ParseErrorCode code) const { return !(*this == code); }
-    friend bool operator!=(ParseErrorCode code, const ParseResult & err) { return err != code; }
-
-    //! Reset error code.
-    void Clear() { Set(kParseErrorNone); }
-    //! Update error code and offset.
-    void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; }
-
-private:
-    ParseErrorCode code_;
-    size_t offset_;
-};
-
-//! Function pointer type of GetParseError().
-/*! \ingroup RAPIDJSON_ERRORS
-
-    This is the prototype for \c GetParseError_X(), where \c X is a locale.
-    User can dynamically change locale in runtime, e.g.:
-\code
-    GetParseErrorFunc GetParseError = GetParseError_En; // or whatever
-    const RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode());
-\endcode
-*/
-typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode);
-
-///////////////////////////////////////////////////////////////////////////////
-// ValidateErrorCode
-
-//! Error codes when validating.
-/*! \ingroup RAPIDJSON_ERRORS
-    \see GenericSchemaValidator
-*/
-enum ValidateErrorCode {
-    kValidateErrors    = -1,                   //!< Top level error code when kValidateContinueOnErrorsFlag set.
-    kValidateErrorNone = 0,                    //!< No error.
-
-    kValidateErrorMultipleOf,                  //!< Number is not a multiple of the 'multipleOf' value.
-    kValidateErrorMaximum,                     //!< Number is greater than the 'maximum' value.
-    kValidateErrorExclusiveMaximum,            //!< Number is greater than or equal to the 'maximum' value.
-    kValidateErrorMinimum,                     //!< Number is less than the 'minimum' value.
-    kValidateErrorExclusiveMinimum,            //!< Number is less than or equal to the 'minimum' value.
-
-    kValidateErrorMaxLength,                   //!< String is longer than the 'maxLength' value.
-    kValidateErrorMinLength,                   //!< String is longer than the 'maxLength' value.
-    kValidateErrorPattern,                     //!< String does not match the 'pattern' regular expression.
-
-    kValidateErrorMaxItems,                    //!< Array is longer than the 'maxItems' value.
-    kValidateErrorMinItems,                    //!< Array is shorter than the 'minItems' value.
-    kValidateErrorUniqueItems,                 //!< Array has duplicate items but 'uniqueItems' is true.
-    kValidateErrorAdditionalItems,             //!< Array has additional items that are not allowed by the schema.
-
-    kValidateErrorMaxProperties,               //!< Object has more members than 'maxProperties' value.
-    kValidateErrorMinProperties,               //!< Object has less members than 'minProperties' value.
-    kValidateErrorRequired,                    //!< Object is missing one or more members required by the schema.
-    kValidateErrorAdditionalProperties,        //!< Object has additional members that are not allowed by the schema.
-    kValidateErrorPatternProperties,           //!< See other errors.
-    kValidateErrorDependencies,                //!< Object has missing property or schema dependencies.
-
-    kValidateErrorEnum,                        //!< Property has a value that is not one of its allowed enumerated values
-    kValidateErrorType,                        //!< Property has a type that is not allowed by the schema..
-
-    kValidateErrorOneOf,                       //!< Property did not match any of the sub-schemas specified by 'oneOf'.
-    kValidateErrorOneOfMatch,                  //!< Property matched more than one of the sub-schemas specified by 'oneOf'.
-    kValidateErrorAllOf,                       //!< Property did not match all of the sub-schemas specified by 'allOf'.
-    kValidateErrorAnyOf,                       //!< Property did not match any of the sub-schemas specified by 'anyOf'.
-    kValidateErrorNot                          //!< Property matched the sub-schema specified by 'not'.
-};
-
-//! Function pointer type of GetValidateError().
-/*! \ingroup RAPIDJSON_ERRORS
-
-    This is the prototype for \c GetValidateError_X(), where \c X is a locale.
-    User can dynamically change locale in runtime, e.g.:
-\code
-    GetValidateErrorFunc GetValidateError = GetValidateError_En; // or whatever
-    const RAPIDJSON_ERROR_CHARTYPE* s = GetValidateError(validator.GetInvalidSchemaCode());
-\endcode
-*/
-typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetValidateErrorFunc)(ValidateErrorCode);
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_ERROR_ERROR_H_
diff --git a/thirdparty/rapidjson/filereadstream.h b/thirdparty/rapidjson/filereadstream.h
deleted file mode 100644
index f8bb43c..0000000
--- a/thirdparty/rapidjson/filereadstream.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_FILEREADSTREAM_H_
-#define RAPIDJSON_FILEREADSTREAM_H_
-
-#include "stream.h"
-#include <cstdio>
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-RAPIDJSON_DIAG_OFF(unreachable-code)
-RAPIDJSON_DIAG_OFF(missing-noreturn)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! File byte stream for input using fread().
-/*!
-    \note implements Stream concept
-*/
-class FileReadStream {
-public:
-    typedef char Ch;    //!< Character type (byte).
-
-    //! Constructor.
-    /*!
-        \param fp File pointer opened for read.
-        \param buffer user-supplied buffer.
-        \param bufferSize size of buffer in bytes. Must >=4 bytes.
-    */
-    FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
-        RAPIDJSON_ASSERT(fp_ != 0);
-        RAPIDJSON_ASSERT(bufferSize >= 4);
-        Read();
-    }
-
-    Ch Peek() const { return *current_; }
-    Ch Take() { Ch c = *current_; Read(); return c; }
-    size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
-
-    // Not implemented
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); } 
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-    // For encoding detection only.
-    const Ch* Peek4() const {
-        return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
-    }
-
-private:
-    void Read() {
-        if (current_ < bufferLast_)
-            ++current_;
-        else if (!eof_) {
-            count_ += readCount_;
-            readCount_ = std::fread(buffer_, 1, bufferSize_, fp_);
-            bufferLast_ = buffer_ + readCount_ - 1;
-            current_ = buffer_;
-
-            if (readCount_ < bufferSize_) {
-                buffer_[readCount_] = '\0';
-                ++bufferLast_;
-                eof_ = true;
-            }
-        }
-    }
-
-    std::FILE* fp_;
-    Ch *buffer_;
-    size_t bufferSize_;
-    Ch *bufferLast_;
-    Ch *current_;
-    size_t readCount_;
-    size_t count_;  //!< Number of characters read
-    bool eof_;
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/thirdparty/rapidjson/filewritestream.h b/thirdparty/rapidjson/filewritestream.h
deleted file mode 100644
index 5d89588..0000000
--- a/thirdparty/rapidjson/filewritestream.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_FILEWRITESTREAM_H_
-#define RAPIDJSON_FILEWRITESTREAM_H_
-
-#include "stream.h"
-#include <cstdio>
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(unreachable-code)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Wrapper of C file stream for output using fwrite().
-/*!
-    \note implements Stream concept
-*/
-class FileWriteStream {
-public:
-    typedef char Ch;    //!< Character type. Only support char.
-
-    FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { 
-        RAPIDJSON_ASSERT(fp_ != 0);
-    }
-
-    void Put(char c) { 
-        if (current_ >= bufferEnd_)
-            Flush();
-
-        *current_++ = c;
-    }
-
-    void PutN(char c, size_t n) {
-        size_t avail = static_cast<size_t>(bufferEnd_ - current_);
-        while (n > avail) {
-            std::memset(current_, c, avail);
-            current_ += avail;
-            Flush();
-            n -= avail;
-            avail = static_cast<size_t>(bufferEnd_ - current_);
-        }
-
-        if (n > 0) {
-            std::memset(current_, c, n);
-            current_ += n;
-        }
-    }
-
-    void Flush() {
-        if (current_ != buffer_) {
-            size_t result = std::fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
-            if (result < static_cast<size_t>(current_ - buffer_)) {
-                // failure deliberately ignored at this time
-                // added to avoid warn_unused_result build errors
-            }
-            current_ = buffer_;
-        }
-    }
-
-    // Not implemented
-    char Peek() const { RAPIDJSON_ASSERT(false); return 0; }
-    char Take() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
-    char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    FileWriteStream(const FileWriteStream&);
-    FileWriteStream& operator=(const FileWriteStream&);
-
-    std::FILE* fp_;
-    char *buffer_;
-    char *bufferEnd_;
-    char *current_;
-};
-
-//! Implement specialized version of PutN() with memset() for better performance.
-template<>
-inline void PutN(FileWriteStream& stream, char c, size_t n) {
-    stream.PutN(c, n);
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/thirdparty/rapidjson/fwd.h b/thirdparty/rapidjson/fwd.h
deleted file mode 100644
index d62f77f..0000000
--- a/thirdparty/rapidjson/fwd.h
+++ /dev/null
@@ -1,151 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_FWD_H_
-#define RAPIDJSON_FWD_H_
-
-#include "rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-// encodings.h
-
-template<typename CharType> struct UTF8;
-template<typename CharType> struct UTF16;
-template<typename CharType> struct UTF16BE;
-template<typename CharType> struct UTF16LE;
-template<typename CharType> struct UTF32;
-template<typename CharType> struct UTF32BE;
-template<typename CharType> struct UTF32LE;
-template<typename CharType> struct ASCII;
-template<typename CharType> struct AutoUTF;
-
-template<typename SourceEncoding, typename TargetEncoding>
-struct Transcoder;
-
-// allocators.h
-
-class CrtAllocator;
-
-template <typename BaseAllocator>
-class MemoryPoolAllocator;
-
-// stream.h
-
-template <typename Encoding>
-struct GenericStringStream;
-
-typedef GenericStringStream<UTF8<char> > StringStream;
-
-template <typename Encoding>
-struct GenericInsituStringStream;
-
-typedef GenericInsituStringStream<UTF8<char> > InsituStringStream;
-
-// stringbuffer.h
-
-template <typename Encoding, typename Allocator>
-class GenericStringBuffer;
-
-typedef GenericStringBuffer<UTF8<char>, CrtAllocator> StringBuffer;
-
-// filereadstream.h
-
-class FileReadStream;
-
-// filewritestream.h
-
-class FileWriteStream;
-
-// memorybuffer.h
-
-template <typename Allocator>
-struct GenericMemoryBuffer;
-
-typedef GenericMemoryBuffer<CrtAllocator> MemoryBuffer;
-
-// memorystream.h
-
-struct MemoryStream;
-
-// reader.h
-
-template<typename Encoding, typename Derived>
-struct BaseReaderHandler;
-
-template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator>
-class GenericReader;
-
-typedef GenericReader<UTF8<char>, UTF8<char>, CrtAllocator> Reader;
-
-// writer.h
-
-template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
-class Writer;
-
-// prettywriter.h
-
-template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
-class PrettyWriter;
-
-// document.h
-
-template <typename Encoding, typename Allocator> 
-class GenericMember;
-
-template <bool Const, typename Encoding, typename Allocator>
-class GenericMemberIterator;
-
-template<typename CharType>
-struct GenericStringRef;
-
-template <typename Encoding, typename Allocator> 
-class GenericValue;
-
-typedef GenericValue<UTF8<char>, MemoryPoolAllocator<CrtAllocator> > Value;
-
-template <typename Encoding, typename Allocator, typename StackAllocator>
-class GenericDocument;
-
-typedef GenericDocument<UTF8<char>, MemoryPoolAllocator<CrtAllocator>, CrtAllocator> Document;
-
-// pointer.h
-
-template <typename ValueType, typename Allocator>
-class GenericPointer;
-
-typedef GenericPointer<Value, CrtAllocator> Pointer;
-
-// schema.h
-
-template <typename SchemaDocumentType>
-class IGenericRemoteSchemaDocumentProvider;
-
-template <typename ValueT, typename Allocator>
-class GenericSchemaDocument;
-
-typedef GenericSchemaDocument<Value, CrtAllocator> SchemaDocument;
-typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
-
-template <
-    typename SchemaDocumentType,
-    typename OutputHandler,
-    typename StateAllocator>
-class GenericSchemaValidator;
-
-typedef GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<char>, void>, CrtAllocator> SchemaValidator;
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_RAPIDJSONFWD_H_
diff --git a/thirdparty/rapidjson/internal/biginteger.h b/thirdparty/rapidjson/internal/biginteger.h
deleted file mode 100644
index 1245578..0000000
--- a/thirdparty/rapidjson/internal/biginteger.h
+++ /dev/null
@@ -1,290 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_BIGINTEGER_H_
-#define RAPIDJSON_BIGINTEGER_H_
-
-#include "../rapidjson.h"
-
-#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && defined(_M_AMD64)
-#include <intrin.h> // for _umul128
-#pragma intrinsic(_umul128)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-class BigInteger {
-public:
-    typedef uint64_t Type;
-
-    BigInteger(const BigInteger& rhs) : count_(rhs.count_) {
-        std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
-    }
-
-    explicit BigInteger(uint64_t u) : count_(1) {
-        digits_[0] = u;
-    }
-
-    BigInteger(const char* decimals, size_t length) : count_(1) {
-        RAPIDJSON_ASSERT(length > 0);
-        digits_[0] = 0;
-        size_t i = 0;
-        const size_t kMaxDigitPerIteration = 19;  // 2^64 = 18446744073709551616 > 10^19
-        while (length >= kMaxDigitPerIteration) {
-            AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration);
-            length -= kMaxDigitPerIteration;
-            i += kMaxDigitPerIteration;
-        }
-
-        if (length > 0)
-            AppendDecimal64(decimals + i, decimals + i + length);
-    }
-    
-    BigInteger& operator=(const BigInteger &rhs)
-    {
-        if (this != &rhs) {
-            count_ = rhs.count_;
-            std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
-        }
-        return *this;
-    }
-    
-    BigInteger& operator=(uint64_t u) {
-        digits_[0] = u;            
-        count_ = 1;
-        return *this;
-    }
-
-    BigInteger& operator+=(uint64_t u) {
-        Type backup = digits_[0];
-        digits_[0] += u;
-        for (size_t i = 0; i < count_ - 1; i++) {
-            if (digits_[i] >= backup)
-                return *this; // no carry
-            backup = digits_[i + 1];
-            digits_[i + 1] += 1;
-        }
-
-        // Last carry
-        if (digits_[count_ - 1] < backup)
-            PushBack(1);
-
-        return *this;
-    }
-
-    BigInteger& operator*=(uint64_t u) {
-        if (u == 0) return *this = 0;
-        if (u == 1) return *this;
-        if (*this == 1) return *this = u;
-
-        uint64_t k = 0;
-        for (size_t i = 0; i < count_; i++) {
-            uint64_t hi;
-            digits_[i] = MulAdd64(digits_[i], u, k, &hi);
-            k = hi;
-        }
-        
-        if (k > 0)
-            PushBack(k);
-
-        return *this;
-    }
-
-    BigInteger& operator*=(uint32_t u) {
-        if (u == 0) return *this = 0;
-        if (u == 1) return *this;
-        if (*this == 1) return *this = u;
-
-        uint64_t k = 0;
-        for (size_t i = 0; i < count_; i++) {
-            const uint64_t c = digits_[i] >> 32;
-            const uint64_t d = digits_[i] & 0xFFFFFFFF;
-            const uint64_t uc = u * c;
-            const uint64_t ud = u * d;
-            const uint64_t p0 = ud + k;
-            const uint64_t p1 = uc + (p0 >> 32);
-            digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32);
-            k = p1 >> 32;
-        }
-        
-        if (k > 0)
-            PushBack(k);
-
-        return *this;
-    }
-
-    BigInteger& operator<<=(size_t shift) {
-        if (IsZero() || shift == 0) return *this;
-
-        size_t offset = shift / kTypeBit;
-        size_t interShift = shift % kTypeBit;
-        RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
-
-        if (interShift == 0) {
-            std::memmove(digits_ + offset, digits_, count_ * sizeof(Type));
-            count_ += offset;
-        }
-        else {
-            digits_[count_] = 0;
-            for (size_t i = count_; i > 0; i--)
-                digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift));
-            digits_[offset] = digits_[0] << interShift;
-            count_ += offset;
-            if (digits_[count_])
-                count_++;
-        }
-
-        std::memset(digits_, 0, offset * sizeof(Type));
-
-        return *this;
-    }
-
-    bool operator==(const BigInteger& rhs) const {
-        return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
-    }
-
-    bool operator==(const Type rhs) const {
-        return count_ == 1 && digits_[0] == rhs;
-    }
-
-    BigInteger& MultiplyPow5(unsigned exp) {
-        static const uint32_t kPow5[12] = {
-            5,
-            5 * 5,
-            5 * 5 * 5,
-            5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
-        };
-        if (exp == 0) return *this;
-        for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
-        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
-        if (exp > 0)                 *this *= kPow5[exp - 1];
-        return *this;
-    }
-
-    // Compute absolute difference of this and rhs.
-    // Assume this != rhs
-    bool Difference(const BigInteger& rhs, BigInteger* out) const {
-        int cmp = Compare(rhs);
-        RAPIDJSON_ASSERT(cmp != 0);
-        const BigInteger *a, *b;  // Makes a > b
-        bool ret;
-        if (cmp < 0) { a = &rhs; b = this; ret = true; }
-        else         { a = this; b = &rhs; ret = false; }
-
-        Type borrow = 0;
-        for (size_t i = 0; i < a->count_; i++) {
-            Type d = a->digits_[i] - borrow;
-            if (i < b->count_)
-                d -= b->digits_[i];
-            borrow = (d > a->digits_[i]) ? 1 : 0;
-            out->digits_[i] = d;
-            if (d != 0)
-                out->count_ = i + 1;
-        }
-
-        return ret;
-    }
-
-    int Compare(const BigInteger& rhs) const {
-        if (count_ != rhs.count_)
-            return count_ < rhs.count_ ? -1 : 1;
-
-        for (size_t i = count_; i-- > 0;)
-            if (digits_[i] != rhs.digits_[i])
-                return digits_[i] < rhs.digits_[i] ? -1 : 1;
-
-        return 0;
-    }
-
-    size_t GetCount() const { return count_; }
-    Type GetDigit(size_t index) const { RAPIDJSON_ASSERT(index < count_); return digits_[index]; }
-    bool IsZero() const { return count_ == 1 && digits_[0] == 0; }
-
-private:
-    void AppendDecimal64(const char* begin, const char* end) {
-        uint64_t u = ParseUint64(begin, end);
-        if (IsZero())
-            *this = u;
-        else {
-            unsigned exp = static_cast<unsigned>(end - begin);
-            (MultiplyPow5(exp) <<= exp) += u;   // *this = *this * 10^exp + u
-        }
-    }
-
-    void PushBack(Type digit) {
-        RAPIDJSON_ASSERT(count_ < kCapacity);
-        digits_[count_++] = digit;
-    }
-
-    static uint64_t ParseUint64(const char* begin, const char* end) {
-        uint64_t r = 0;
-        for (const char* p = begin; p != end; ++p) {
-            RAPIDJSON_ASSERT(*p >= '0' && *p <= '9');
-            r = r * 10u + static_cast<unsigned>(*p - '0');
-        }
-        return r;
-    }
-
-    // Assume a * b + k < 2^128
-    static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t* outHigh) {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        uint64_t low = _umul128(a, b, outHigh) + k;
-        if (low < k)
-            (*outHigh)++;
-        return low;
-#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-        __extension__ typedef unsigned __int128 uint128;
-        uint128 p = static_cast<uint128>(a) * static_cast<uint128>(b);
-        p += k;
-        *outHigh = static_cast<uint64_t>(p >> 64);
-        return static_cast<uint64_t>(p);
-#else
-        const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32;
-        uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1;
-        x1 += (x0 >> 32); // can't give carry
-        x1 += x2;
-        if (x1 < x2)
-            x3 += (static_cast<uint64_t>(1) << 32);
-        uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF);
-        uint64_t hi = x3 + (x1 >> 32);
-
-        lo += k;
-        if (lo < k)
-            hi++;
-        *outHigh = hi;
-        return lo;
-#endif
-    }
-
-    static const size_t kBitCount = 3328;  // 64bit * 54 > 10^1000
-    static const size_t kCapacity = kBitCount / sizeof(Type);
-    static const size_t kTypeBit = sizeof(Type) * 8;
-
-    Type digits_[kCapacity];
-    size_t count_;
-};
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_BIGINTEGER_H_
diff --git a/thirdparty/rapidjson/internal/clzll.h b/thirdparty/rapidjson/internal/clzll.h
deleted file mode 100644
index 8fc5118..0000000
--- a/thirdparty/rapidjson/internal/clzll.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_CLZLL_H_
-#define RAPIDJSON_CLZLL_H_
-
-#include "../rapidjson.h"
-
-#if defined(_MSC_VER) && !defined(UNDER_CE)
-#include <intrin.h>
-#if defined(_WIN64)
-#pragma intrinsic(_BitScanReverse64)
-#else
-#pragma intrinsic(_BitScanReverse)
-#endif
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-inline uint32_t clzll(uint64_t x) {
-    // Passing 0 to __builtin_clzll is UB in GCC and results in an
-    // infinite loop in the software implementation.
-    RAPIDJSON_ASSERT(x != 0);
-
-#if defined(_MSC_VER) && !defined(UNDER_CE)
-    unsigned long r = 0;
-#if defined(_WIN64)
-    _BitScanReverse64(&r, x);
-#else
-    // Scan the high 32 bits.
-    if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
-        return 63 - (r + 32);
-
-    // Scan the low 32 bits.
-    _BitScanReverse(&r, static_cast<uint32_t>(x & 0xFFFFFFFF));
-#endif // _WIN64
-
-    return 63 - r;
-#elif (defined(__GNUC__) && __GNUC__ >= 4) || RAPIDJSON_HAS_BUILTIN(__builtin_clzll)
-    // __builtin_clzll wrapper
-    return static_cast<uint32_t>(__builtin_clzll(x));
-#else
-    // naive version
-    uint32_t r = 0;
-    while (!(x & (static_cast<uint64_t>(1) << 63))) {
-        x <<= 1;
-        ++r;
-    }
-
-    return r;
-#endif // _MSC_VER
-}
-
-#define RAPIDJSON_CLZLL RAPIDJSON_NAMESPACE::internal::clzll
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_CLZLL_H_
diff --git a/thirdparty/rapidjson/internal/diyfp.h b/thirdparty/rapidjson/internal/diyfp.h
deleted file mode 100644
index a40797e..0000000
--- a/thirdparty/rapidjson/internal/diyfp.h
+++ /dev/null
@@ -1,257 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
-// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
-// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
-
-#ifndef RAPIDJSON_DIYFP_H_
-#define RAPIDJSON_DIYFP_H_
-
-#include "../rapidjson.h"
-#include "clzll.h"
-#include <limits>
-
-#if defined(_MSC_VER) && defined(_M_AMD64) && !defined(__INTEL_COMPILER)
-#include <intrin.h>
-#pragma intrinsic(_umul128)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-struct DiyFp {
-    DiyFp() : f(), e() {}
-
-    DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {}
-
-    explicit DiyFp(double d) {
-        union {
-            double d;
-            uint64_t u64;
-        } u = { d };
-
-        int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
-        uint64_t significand = (u.u64 & kDpSignificandMask);
-        if (biased_e != 0) {
-            f = significand + kDpHiddenBit;
-            e = biased_e - kDpExponentBias;
-        }
-        else {
-            f = significand;
-            e = kDpMinExponent + 1;
-        }
-    }
-
-    DiyFp operator-(const DiyFp& rhs) const {
-        return DiyFp(f - rhs.f, e);
-    }
-
-    DiyFp operator*(const DiyFp& rhs) const {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        uint64_t h;
-        uint64_t l = _umul128(f, rhs.f, &h);
-        if (l & (uint64_t(1) << 63)) // rounding
-            h++;
-        return DiyFp(h, e + rhs.e + 64);
-#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-        __extension__ typedef unsigned __int128 uint128;
-        uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
-        uint64_t h = static_cast<uint64_t>(p >> 64);
-        uint64_t l = static_cast<uint64_t>(p);
-        if (l & (uint64_t(1) << 63)) // rounding
-            h++;
-        return DiyFp(h, e + rhs.e + 64);
-#else
-        const uint64_t M32 = 0xFFFFFFFF;
-        const uint64_t a = f >> 32;
-        const uint64_t b = f & M32;
-        const uint64_t c = rhs.f >> 32;
-        const uint64_t d = rhs.f & M32;
-        const uint64_t ac = a * c;
-        const uint64_t bc = b * c;
-        const uint64_t ad = a * d;
-        const uint64_t bd = b * d;
-        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
-        tmp += 1U << 31;  /// mult_round
-        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
-#endif
-    }
-
-    DiyFp Normalize() const {
-        int s = static_cast<int>(clzll(f));
-        return DiyFp(f << s, e - s);
-    }
-
-    DiyFp NormalizeBoundary() const {
-        DiyFp res = *this;
-        while (!(res.f & (kDpHiddenBit << 1))) {
-            res.f <<= 1;
-            res.e--;
-        }
-        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
-        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
-        return res;
-    }
-
-    void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
-        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
-        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
-        mi.f <<= mi.e - pl.e;
-        mi.e = pl.e;
-        *plus = pl;
-        *minus = mi;
-    }
-
-    double ToDouble() const {
-        union {
-            double d;
-            uint64_t u64;
-        }u;
-        RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask);
-        if (e < kDpDenormalExponent) {
-            // Underflow.
-            return 0.0;
-        }
-        if (e >= kDpMaxExponent) {
-            // Overflow.
-            return std::numeric_limits<double>::infinity();
-        }
-        const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
-            static_cast<uint64_t>(e + kDpExponentBias);
-        u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
-        return u.d;
-    }
-
-    static const int kDiySignificandSize = 64;
-    static const int kDpSignificandSize = 52;
-    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
-    static const int kDpMaxExponent = 0x7FF - kDpExponentBias;
-    static const int kDpMinExponent = -kDpExponentBias;
-    static const int kDpDenormalExponent = -kDpExponentBias + 1;
-    static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
-    static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
-    static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
-
-    uint64_t f;
-    int e;
-};
-
-inline DiyFp GetCachedPowerByIndex(size_t index) {
-    // 10^-348, 10^-340, ..., 10^340
-    static const uint64_t kCachedPowers_F[] = {
-        RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
-        RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
-        RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
-        RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
-        RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
-        RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
-        RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
-        RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
-        RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
-        RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
-        RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
-        RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
-        RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
-        RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
-        RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
-        RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
-        RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
-        RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
-        RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
-        RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
-        RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
-        RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
-        RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
-        RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
-        RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
-        RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
-        RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
-        RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
-        RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
-        RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
-        RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
-        RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
-        RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
-        RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
-        RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
-        RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
-        RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
-        RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
-        RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
-        RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
-        RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
-        RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
-        RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
-        RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
-    };
-    static const int16_t kCachedPowers_E[] = {
-        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
-        -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
-        -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
-        -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
-        -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
-        109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
-        375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
-        641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
-        907,   933,   960,   986,  1013,  1039,  1066
-    };
-    RAPIDJSON_ASSERT(index < 87);
-    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
-}
-
-inline DiyFp GetCachedPower(int e, int* K) {
-
-    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
-    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
-    int k = static_cast<int>(dk);
-    if (dk - k > 0.0)
-        k++;
-
-    unsigned index = static_cast<unsigned>((k >> 3) + 1);
-    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table
-
-    return GetCachedPowerByIndex(index);
-}
-
-inline DiyFp GetCachedPower10(int exp, int *outExp) {
-    RAPIDJSON_ASSERT(exp >= -348);
-    unsigned index = static_cast<unsigned>(exp + 348) / 8u;
-    *outExp = -348 + static_cast<int>(index) * 8;
-    return GetCachedPowerByIndex(index);
-}
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_DIYFP_H_
diff --git a/thirdparty/rapidjson/internal/dtoa.h b/thirdparty/rapidjson/internal/dtoa.h
deleted file mode 100644
index 621402f..0000000
--- a/thirdparty/rapidjson/internal/dtoa.h
+++ /dev/null
@@ -1,245 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
-// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
-// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
-
-#ifndef RAPIDJSON_DTOA_
-#define RAPIDJSON_DTOA_
-
-#include "itoa.h" // GetDigitsLut()
-#include "diyfp.h"
-#include "ieee754.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-RAPIDJSON_DIAG_OFF(array-bounds) // some gcc versions generate wrong warnings https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124
-#endif
-
-inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
-    while (rest < wp_w && delta - rest >= ten_kappa &&
-           (rest + ten_kappa < wp_w ||  /// closer
-            wp_w - rest > rest + ten_kappa - wp_w)) {
-        buffer[len - 1]--;
-        rest += ten_kappa;
-    }
-}
-
-inline int CountDecimalDigit32(uint32_t n) {
-    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
-    if (n < 10) return 1;
-    if (n < 100) return 2;
-    if (n < 1000) return 3;
-    if (n < 10000) return 4;
-    if (n < 100000) return 5;
-    if (n < 1000000) return 6;
-    if (n < 10000000) return 7;
-    if (n < 100000000) return 8;
-    // Will not reach 10 digits in DigitGen()
-    //if (n < 1000000000) return 9;
-    //return 10;
-    return 9;
-}
-
-inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) {
-    static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
-    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
-    const DiyFp wp_w = Mp - W;
-    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
-    uint64_t p2 = Mp.f & (one.f - 1);
-    int kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
-    *len = 0;
-
-    while (kappa > 0) {
-        uint32_t d = 0;
-        switch (kappa) {
-            case  9: d = p1 /  100000000; p1 %=  100000000; break;
-            case  8: d = p1 /   10000000; p1 %=   10000000; break;
-            case  7: d = p1 /    1000000; p1 %=    1000000; break;
-            case  6: d = p1 /     100000; p1 %=     100000; break;
-            case  5: d = p1 /      10000; p1 %=      10000; break;
-            case  4: d = p1 /       1000; p1 %=       1000; break;
-            case  3: d = p1 /        100; p1 %=        100; break;
-            case  2: d = p1 /         10; p1 %=         10; break;
-            case  1: d = p1;              p1 =           0; break;
-            default:;
-        }
-        if (d || *len)
-            buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
-        kappa--;
-        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
-        if (tmp <= delta) {
-            *K += kappa;
-            GrisuRound(buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
-            return;
-        }
-    }
-
-    // kappa = 0
-    for (;;) {
-        p2 *= 10;
-        delta *= 10;
-        char d = static_cast<char>(p2 >> -one.e);
-        if (d || *len)
-            buffer[(*len)++] = static_cast<char>('0' + d);
-        p2 &= one.f - 1;
-        kappa--;
-        if (p2 < delta) {
-            *K += kappa;
-            int index = -kappa;
-            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[index] : 0));
-            return;
-        }
-    }
-}
-
-inline void Grisu2(double value, char* buffer, int* length, int* K) {
-    const DiyFp v(value);
-    DiyFp w_m, w_p;
-    v.NormalizedBoundaries(&w_m, &w_p);
-
-    const DiyFp c_mk = GetCachedPower(w_p.e, K);
-    const DiyFp W = v.Normalize() * c_mk;
-    DiyFp Wp = w_p * c_mk;
-    DiyFp Wm = w_m * c_mk;
-    Wm.f++;
-    Wp.f--;
-    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
-}
-
-inline char* WriteExponent(int K, char* buffer) {
-    if (K < 0) {
-        *buffer++ = '-';
-        K = -K;
-    }
-
-    if (K >= 100) {
-        *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
-        K %= 100;
-        const char* d = GetDigitsLut() + K * 2;
-        *buffer++ = d[0];
-        *buffer++ = d[1];
-    }
-    else if (K >= 10) {
-        const char* d = GetDigitsLut() + K * 2;
-        *buffer++ = d[0];
-        *buffer++ = d[1];
-    }
-    else
-        *buffer++ = static_cast<char>('0' + static_cast<char>(K));
-
-    return buffer;
-}
-
-inline char* Prettify(char* buffer, int length, int k, int maxDecimalPlaces) {
-    const int kk = length + k;  // 10^(kk-1) <= v < 10^kk
-
-    if (0 <= k && kk <= 21) {
-        // 1234e7 -> 12340000000
-        for (int i = length; i < kk; i++)
-            buffer[i] = '0';
-        buffer[kk] = '.';
-        buffer[kk + 1] = '0';
-        return &buffer[kk + 2];
-    }
-    else if (0 < kk && kk <= 21) {
-        // 1234e-2 -> 12.34
-        std::memmove(&buffer[kk + 1], &buffer[kk], static_cast<size_t>(length - kk));
-        buffer[kk] = '.';
-        if (0 > k + maxDecimalPlaces) {
-            // When maxDecimalPlaces = 2, 1.2345 -> 1.23, 1.102 -> 1.1
-            // Remove extra trailing zeros (at least one) after truncation.
-            for (int i = kk + maxDecimalPlaces; i > kk + 1; i--)
-                if (buffer[i] != '0')
-                    return &buffer[i + 1];
-            return &buffer[kk + 2]; // Reserve one zero
-        }
-        else
-            return &buffer[length + 1];
-    }
-    else if (-6 < kk && kk <= 0) {
-        // 1234e-6 -> 0.001234
-        const int offset = 2 - kk;
-        std::memmove(&buffer[offset], &buffer[0], static_cast<size_t>(length));
-        buffer[0] = '0';
-        buffer[1] = '.';
-        for (int i = 2; i < offset; i++)
-            buffer[i] = '0';
-        if (length - kk > maxDecimalPlaces) {
-            // When maxDecimalPlaces = 2, 0.123 -> 0.12, 0.102 -> 0.1
-            // Remove extra trailing zeros (at least one) after truncation.
-            for (int i = maxDecimalPlaces + 1; i > 2; i--)
-                if (buffer[i] != '0')
-                    return &buffer[i + 1];
-            return &buffer[3]; // Reserve one zero
-        }
-        else
-            return &buffer[length + offset];
-    }
-    else if (kk < -maxDecimalPlaces) {
-        // Truncate to zero
-        buffer[0] = '0';
-        buffer[1] = '.';
-        buffer[2] = '0';
-        return &buffer[3];
-    }
-    else if (length == 1) {
-        // 1e30
-        buffer[1] = 'e';
-        return WriteExponent(kk - 1, &buffer[2]);
-    }
-    else {
-        // 1234e30 -> 1.234e33
-        std::memmove(&buffer[2], &buffer[1], static_cast<size_t>(length - 1));
-        buffer[1] = '.';
-        buffer[length + 1] = 'e';
-        return WriteExponent(kk - 1, &buffer[0 + length + 2]);
-    }
-}
-
-inline char* dtoa(double value, char* buffer, int maxDecimalPlaces = 324) {
-    RAPIDJSON_ASSERT(maxDecimalPlaces >= 1);
-    Double d(value);
-    if (d.IsZero()) {
-        if (d.Sign())
-            *buffer++ = '-';     // -0.0, Issue #289
-        buffer[0] = '0';
-        buffer[1] = '.';
-        buffer[2] = '0';
-        return &buffer[3];
-    }
-    else {
-        if (value < 0) {
-            *buffer++ = '-';
-            value = -value;
-        }
-        int length, K;
-        Grisu2(value, buffer, &length, &K);
-        return Prettify(buffer, length, K, maxDecimalPlaces);
-    }
-}
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_DTOA_
diff --git a/thirdparty/rapidjson/internal/ieee754.h b/thirdparty/rapidjson/internal/ieee754.h
deleted file mode 100644
index 68c9e96..0000000
--- a/thirdparty/rapidjson/internal/ieee754.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_IEEE754_
-#define RAPIDJSON_IEEE754_
-
-#include "../rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-class Double {
-public:
-    Double() {}
-    Double(double d) : d_(d) {}
-    Double(uint64_t u) : u_(u) {}
-
-    double Value() const { return d_; }
-    uint64_t Uint64Value() const { return u_; }
-
-    double NextPositiveDouble() const {
-        RAPIDJSON_ASSERT(!Sign());
-        return Double(u_ + 1).Value();
-    }
-
-    bool Sign() const { return (u_ & kSignMask) != 0; }
-    uint64_t Significand() const { return u_ & kSignificandMask; }
-    int Exponent() const { return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); }
-
-    bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; }
-    bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; }
-    bool IsNanOrInf() const { return (u_ & kExponentMask) == kExponentMask; }
-    bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; }
-    bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; }
-
-    uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
-    int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
-    uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; }
-
-    static int EffectiveSignificandSize(int order) {
-        if (order >= -1021)
-            return 53;
-        else if (order <= -1074)
-            return 0;
-        else
-            return order + 1074;
-    }
-
-private:
-    static const int kSignificandSize = 52;
-    static const int kExponentBias = 0x3FF;
-    static const int kDenormalExponent = 1 - kExponentBias;
-    static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
-    static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
-    static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
-    static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
-
-    union {
-        double d_;
-        uint64_t u_;
-    };
-};
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_IEEE754_
diff --git a/thirdparty/rapidjson/internal/itoa.h b/thirdparty/rapidjson/internal/itoa.h
deleted file mode 100644
index 9fe8c93..0000000
--- a/thirdparty/rapidjson/internal/itoa.h
+++ /dev/null
@@ -1,308 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ITOA_
-#define RAPIDJSON_ITOA_
-
-#include "../rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-inline const char* GetDigitsLut() {
-    static const char cDigitsLut[200] = {
-        '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
-        '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
-        '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
-        '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
-        '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
-        '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
-        '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
-        '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
-        '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
-        '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
-    };
-    return cDigitsLut;
-}
-
-inline char* u32toa(uint32_t value, char* buffer) {
-    RAPIDJSON_ASSERT(buffer != 0);
-
-    const char* cDigitsLut = GetDigitsLut();
-
-    if (value < 10000) {
-        const uint32_t d1 = (value / 100) << 1;
-        const uint32_t d2 = (value % 100) << 1;
-
-        if (value >= 1000)
-            *buffer++ = cDigitsLut[d1];
-        if (value >= 100)
-            *buffer++ = cDigitsLut[d1 + 1];
-        if (value >= 10)
-            *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-    }
-    else if (value < 100000000) {
-        // value = bbbbcccc
-        const uint32_t b = value / 10000;
-        const uint32_t c = value % 10000;
-
-        const uint32_t d1 = (b / 100) << 1;
-        const uint32_t d2 = (b % 100) << 1;
-
-        const uint32_t d3 = (c / 100) << 1;
-        const uint32_t d4 = (c % 100) << 1;
-
-        if (value >= 10000000)
-            *buffer++ = cDigitsLut[d1];
-        if (value >= 1000000)
-            *buffer++ = cDigitsLut[d1 + 1];
-        if (value >= 100000)
-            *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-
-        *buffer++ = cDigitsLut[d3];
-        *buffer++ = cDigitsLut[d3 + 1];
-        *buffer++ = cDigitsLut[d4];
-        *buffer++ = cDigitsLut[d4 + 1];
-    }
-    else {
-        // value = aabbbbcccc in decimal
-
-        const uint32_t a = value / 100000000; // 1 to 42
-        value %= 100000000;
-
-        if (a >= 10) {
-            const unsigned i = a << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-        }
-        else
-            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
-
-        const uint32_t b = value / 10000; // 0 to 9999
-        const uint32_t c = value % 10000; // 0 to 9999
-
-        const uint32_t d1 = (b / 100) << 1;
-        const uint32_t d2 = (b % 100) << 1;
-
-        const uint32_t d3 = (c / 100) << 1;
-        const uint32_t d4 = (c % 100) << 1;
-
-        *buffer++ = cDigitsLut[d1];
-        *buffer++ = cDigitsLut[d1 + 1];
-        *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-        *buffer++ = cDigitsLut[d3];
-        *buffer++ = cDigitsLut[d3 + 1];
-        *buffer++ = cDigitsLut[d4];
-        *buffer++ = cDigitsLut[d4 + 1];
-    }
-    return buffer;
-}
-
-inline char* i32toa(int32_t value, char* buffer) {
-    RAPIDJSON_ASSERT(buffer != 0);
-    uint32_t u = static_cast<uint32_t>(value);
-    if (value < 0) {
-        *buffer++ = '-';
-        u = ~u + 1;
-    }
-
-    return u32toa(u, buffer);
-}
-
-inline char* u64toa(uint64_t value, char* buffer) {
-    RAPIDJSON_ASSERT(buffer != 0);
-    const char* cDigitsLut = GetDigitsLut();
-    const uint64_t  kTen8 = 100000000;
-    const uint64_t  kTen9 = kTen8 * 10;
-    const uint64_t kTen10 = kTen8 * 100;
-    const uint64_t kTen11 = kTen8 * 1000;
-    const uint64_t kTen12 = kTen8 * 10000;
-    const uint64_t kTen13 = kTen8 * 100000;
-    const uint64_t kTen14 = kTen8 * 1000000;
-    const uint64_t kTen15 = kTen8 * 10000000;
-    const uint64_t kTen16 = kTen8 * kTen8;
-
-    if (value < kTen8) {
-        uint32_t v = static_cast<uint32_t>(value);
-        if (v < 10000) {
-            const uint32_t d1 = (v / 100) << 1;
-            const uint32_t d2 = (v % 100) << 1;
-
-            if (v >= 1000)
-                *buffer++ = cDigitsLut[d1];
-            if (v >= 100)
-                *buffer++ = cDigitsLut[d1 + 1];
-            if (v >= 10)
-                *buffer++ = cDigitsLut[d2];
-            *buffer++ = cDigitsLut[d2 + 1];
-        }
-        else {
-            // value = bbbbcccc
-            const uint32_t b = v / 10000;
-            const uint32_t c = v % 10000;
-
-            const uint32_t d1 = (b / 100) << 1;
-            const uint32_t d2 = (b % 100) << 1;
-
-            const uint32_t d3 = (c / 100) << 1;
-            const uint32_t d4 = (c % 100) << 1;
-
-            if (value >= 10000000)
-                *buffer++ = cDigitsLut[d1];
-            if (value >= 1000000)
-                *buffer++ = cDigitsLut[d1 + 1];
-            if (value >= 100000)
-                *buffer++ = cDigitsLut[d2];
-            *buffer++ = cDigitsLut[d2 + 1];
-
-            *buffer++ = cDigitsLut[d3];
-            *buffer++ = cDigitsLut[d3 + 1];
-            *buffer++ = cDigitsLut[d4];
-            *buffer++ = cDigitsLut[d4 + 1];
-        }
-    }
-    else if (value < kTen16) {
-        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
-        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-
-        const uint32_t b0 = v0 / 10000;
-        const uint32_t c0 = v0 % 10000;
-
-        const uint32_t d1 = (b0 / 100) << 1;
-        const uint32_t d2 = (b0 % 100) << 1;
-
-        const uint32_t d3 = (c0 / 100) << 1;
-        const uint32_t d4 = (c0 % 100) << 1;
-
-        const uint32_t b1 = v1 / 10000;
-        const uint32_t c1 = v1 % 10000;
-
-        const uint32_t d5 = (b1 / 100) << 1;
-        const uint32_t d6 = (b1 % 100) << 1;
-
-        const uint32_t d7 = (c1 / 100) << 1;
-        const uint32_t d8 = (c1 % 100) << 1;
-
-        if (value >= kTen15)
-            *buffer++ = cDigitsLut[d1];
-        if (value >= kTen14)
-            *buffer++ = cDigitsLut[d1 + 1];
-        if (value >= kTen13)
-            *buffer++ = cDigitsLut[d2];
-        if (value >= kTen12)
-            *buffer++ = cDigitsLut[d2 + 1];
-        if (value >= kTen11)
-            *buffer++ = cDigitsLut[d3];
-        if (value >= kTen10)
-            *buffer++ = cDigitsLut[d3 + 1];
-        if (value >= kTen9)
-            *buffer++ = cDigitsLut[d4];
-
-        *buffer++ = cDigitsLut[d4 + 1];
-        *buffer++ = cDigitsLut[d5];
-        *buffer++ = cDigitsLut[d5 + 1];
-        *buffer++ = cDigitsLut[d6];
-        *buffer++ = cDigitsLut[d6 + 1];
-        *buffer++ = cDigitsLut[d7];
-        *buffer++ = cDigitsLut[d7 + 1];
-        *buffer++ = cDigitsLut[d8];
-        *buffer++ = cDigitsLut[d8 + 1];
-    }
-    else {
-        const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
-        value %= kTen16;
-
-        if (a < 10)
-            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
-        else if (a < 100) {
-            const uint32_t i = a << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-        }
-        else if (a < 1000) {
-            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
-
-            const uint32_t i = (a % 100) << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-        }
-        else {
-            const uint32_t i = (a / 100) << 1;
-            const uint32_t j = (a % 100) << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-            *buffer++ = cDigitsLut[j];
-            *buffer++ = cDigitsLut[j + 1];
-        }
-
-        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
-        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-
-        const uint32_t b0 = v0 / 10000;
-        const uint32_t c0 = v0 % 10000;
-
-        const uint32_t d1 = (b0 / 100) << 1;
-        const uint32_t d2 = (b0 % 100) << 1;
-
-        const uint32_t d3 = (c0 / 100) << 1;
-        const uint32_t d4 = (c0 % 100) << 1;
-
-        const uint32_t b1 = v1 / 10000;
-        const uint32_t c1 = v1 % 10000;
-
-        const uint32_t d5 = (b1 / 100) << 1;
-        const uint32_t d6 = (b1 % 100) << 1;
-
-        const uint32_t d7 = (c1 / 100) << 1;
-        const uint32_t d8 = (c1 % 100) << 1;
-
-        *buffer++ = cDigitsLut[d1];
-        *buffer++ = cDigitsLut[d1 + 1];
-        *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-        *buffer++ = cDigitsLut[d3];
-        *buffer++ = cDigitsLut[d3 + 1];
-        *buffer++ = cDigitsLut[d4];
-        *buffer++ = cDigitsLut[d4 + 1];
-        *buffer++ = cDigitsLut[d5];
-        *buffer++ = cDigitsLut[d5 + 1];
-        *buffer++ = cDigitsLut[d6];
-        *buffer++ = cDigitsLut[d6 + 1];
-        *buffer++ = cDigitsLut[d7];
-        *buffer++ = cDigitsLut[d7 + 1];
-        *buffer++ = cDigitsLut[d8];
-        *buffer++ = cDigitsLut[d8 + 1];
-    }
-
-    return buffer;
-}
-
-inline char* i64toa(int64_t value, char* buffer) {
-    RAPIDJSON_ASSERT(buffer != 0);
-    uint64_t u = static_cast<uint64_t>(value);
-    if (value < 0) {
-        *buffer++ = '-';
-        u = ~u + 1;
-    }
-
-    return u64toa(u, buffer);
-}
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ITOA_
diff --git a/thirdparty/rapidjson/internal/meta.h b/thirdparty/rapidjson/internal/meta.h
deleted file mode 100644
index 27092dc..0000000
--- a/thirdparty/rapidjson/internal/meta.h
+++ /dev/null
@@ -1,186 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_META_H_
-#define RAPIDJSON_INTERNAL_META_H_
-
-#include "../rapidjson.h"
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#if defined(_MSC_VER) && !defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(6334)
-#endif
-
-#if RAPIDJSON_HAS_CXX11_TYPETRAITS
-#include <type_traits>
-#endif
-
-//@cond RAPIDJSON_INTERNAL
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
-template <typename T> struct Void { typedef void Type; };
-
-///////////////////////////////////////////////////////////////////////////////
-// BoolType, TrueType, FalseType
-//
-template <bool Cond> struct BoolType {
-    static const bool Value = Cond;
-    typedef BoolType Type;
-};
-typedef BoolType<true> TrueType;
-typedef BoolType<false> FalseType;
-
-
-///////////////////////////////////////////////////////////////////////////////
-// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
-//
-
-template <bool C> struct SelectIfImpl { template <typename T1, typename T2> struct Apply { typedef T1 Type; }; };
-template <> struct SelectIfImpl<false> { template <typename T1, typename T2> struct Apply { typedef T2 Type; }; };
-template <bool C, typename T1, typename T2> struct SelectIfCond : SelectIfImpl<C>::template Apply<T1,T2> {};
-template <typename C, typename T1, typename T2> struct SelectIf : SelectIfCond<C::Value, T1, T2> {};
-
-template <bool Cond1, bool Cond2> struct AndExprCond : FalseType {};
-template <> struct AndExprCond<true, true> : TrueType {};
-template <bool Cond1, bool Cond2> struct OrExprCond : TrueType {};
-template <> struct OrExprCond<false, false> : FalseType {};
-
-template <typename C> struct BoolExpr : SelectIf<C,TrueType,FalseType>::Type {};
-template <typename C> struct NotExpr  : SelectIf<C,FalseType,TrueType>::Type {};
-template <typename C1, typename C2> struct AndExpr : AndExprCond<C1::Value, C2::Value>::Type {};
-template <typename C1, typename C2> struct OrExpr  : OrExprCond<C1::Value, C2::Value>::Type {};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// AddConst, MaybeAddConst, RemoveConst
-template <typename T> struct AddConst { typedef const T Type; };
-template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
-template <typename T> struct RemoveConst { typedef T Type; };
-template <typename T> struct RemoveConst<const T> { typedef T Type; };
-
-
-///////////////////////////////////////////////////////////////////////////////
-// IsSame, IsConst, IsMoreConst, IsPointer
-//
-template <typename T, typename U> struct IsSame : FalseType {};
-template <typename T> struct IsSame<T, T> : TrueType {};
-
-template <typename T> struct IsConst : FalseType {};
-template <typename T> struct IsConst<const T> : TrueType {};
-
-template <typename CT, typename T>
-struct IsMoreConst
-    : AndExpr<IsSame<typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>,
-              BoolType<IsConst<CT>::Value >= IsConst<T>::Value> >::Type {};
-
-template <typename T> struct IsPointer : FalseType {};
-template <typename T> struct IsPointer<T*> : TrueType {};
-
-///////////////////////////////////////////////////////////////////////////////
-// IsBaseOf
-//
-#if RAPIDJSON_HAS_CXX11_TYPETRAITS
-
-template <typename B, typename D> struct IsBaseOf
-    : BoolType< ::std::is_base_of<B,D>::value> {};
-
-#else // simplified version adopted from Boost
-
-template<typename B, typename D> struct IsBaseOfImpl {
-    RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0);
-    RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0);
-
-    typedef char (&Yes)[1];
-    typedef char (&No) [2];
-
-    template <typename T>
-    static Yes Check(const D*, T);
-    static No  Check(const B*, int);
-
-    struct Host {
-        operator const B*() const;
-        operator const D*();
-    };
-
-    enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) };
-};
-
-template <typename B, typename D> struct IsBaseOf
-    : OrExpr<IsSame<B, D>, BoolExpr<IsBaseOfImpl<B, D> > >::Type {};
-
-#endif // RAPIDJSON_HAS_CXX11_TYPETRAITS
-
-
-//////////////////////////////////////////////////////////////////////////
-// EnableIf / DisableIf
-//
-template <bool Condition, typename T = void> struct EnableIfCond  { typedef T Type; };
-template <typename T> struct EnableIfCond<false, T> { /* empty */ };
-
-template <bool Condition, typename T = void> struct DisableIfCond { typedef T Type; };
-template <typename T> struct DisableIfCond<true, T> { /* empty */ };
-
-template <typename Condition, typename T = void>
-struct EnableIf : EnableIfCond<Condition::Value, T> {};
-
-template <typename Condition, typename T = void>
-struct DisableIf : DisableIfCond<Condition::Value, T> {};
-
-// SFINAE helpers
-struct SfinaeTag {};
-template <typename T> struct RemoveSfinaeTag;
-template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type; };
-
-#define RAPIDJSON_REMOVEFPTR_(type) \
-    typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \
-        < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type
-
-#define RAPIDJSON_ENABLEIF(cond) \
-    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
-        <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
-
-#define RAPIDJSON_DISABLEIF(cond) \
-    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
-        <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
-
-#define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \
-    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
-        <RAPIDJSON_REMOVEFPTR_(cond), \
-         RAPIDJSON_REMOVEFPTR_(returntype)>::Type
-
-#define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \
-    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
-        <RAPIDJSON_REMOVEFPTR_(cond), \
-         RAPIDJSON_REMOVEFPTR_(returntype)>::Type
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-//@endcond
-
-#if defined(_MSC_VER) && !defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_INTERNAL_META_H_
diff --git a/thirdparty/rapidjson/internal/pow10.h b/thirdparty/rapidjson/internal/pow10.h
deleted file mode 100644
index eae1a43..0000000
--- a/thirdparty/rapidjson/internal/pow10.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_POW10_
-#define RAPIDJSON_POW10_
-
-#include "../rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-//! Computes integer powers of 10 in double (10.0^n).
-/*! This function uses lookup table for fast and accurate results.
-    \param n non-negative exponent. Must <= 308.
-    \return 10.0^n
-*/
-inline double Pow10(int n) {
-    static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
-        1e+0,  
-        1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 
-        1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
-        1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
-        1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
-        1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
-        1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
-        1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
-        1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
-        1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
-        1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
-        1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
-        1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
-        1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
-        1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
-        1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
-        1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
-    };
-    RAPIDJSON_ASSERT(n >= 0 && n <= 308);
-    return e[n];
-}
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_POW10_
diff --git a/thirdparty/rapidjson/internal/regex.h b/thirdparty/rapidjson/internal/regex.h
deleted file mode 100644
index 6446c40..0000000
--- a/thirdparty/rapidjson/internal/regex.h
+++ /dev/null
@@ -1,739 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_REGEX_H_
-#define RAPIDJSON_INTERNAL_REGEX_H_
-
-#include "../allocators.h"
-#include "../stream.h"
-#include "stack.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-RAPIDJSON_DIAG_OFF(switch-enum)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#ifndef RAPIDJSON_REGEX_VERBOSE
-#define RAPIDJSON_REGEX_VERBOSE 0
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-///////////////////////////////////////////////////////////////////////////////
-// DecodedStream
-
-template <typename SourceStream, typename Encoding>
-class DecodedStream {
-public:
-    DecodedStream(SourceStream& ss) : ss_(ss), codepoint_() { Decode(); }
-    unsigned Peek() { return codepoint_; }
-    unsigned Take() {
-        unsigned c = codepoint_;
-        if (c) // No further decoding when '\0'
-            Decode();
-        return c;
-    }
-
-private:
-    void Decode() {
-        if (!Encoding::Decode(ss_, &codepoint_))
-            codepoint_ = 0;
-    }
-
-    SourceStream& ss_;
-    unsigned codepoint_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericRegex
-
-static const SizeType kRegexInvalidState = ~SizeType(0);  //!< Represents an invalid index in GenericRegex::State::out, out1
-static const SizeType kRegexInvalidRange = ~SizeType(0);
-
-template <typename Encoding, typename Allocator>
-class GenericRegexSearch;
-
-//! Regular expression engine with subset of ECMAscript grammar.
-/*!
-    Supported regular expression syntax:
-    - \c ab     Concatenation
-    - \c a|b    Alternation
-    - \c a?     Zero or one
-    - \c a*     Zero or more
-    - \c a+     One or more
-    - \c a{3}   Exactly 3 times
-    - \c a{3,}  At least 3 times
-    - \c a{3,5} 3 to 5 times
-    - \c (ab)   Grouping
-    - \c ^a     At the beginning
-    - \c a$     At the end
-    - \c .      Any character
-    - \c [abc]  Character classes
-    - \c [a-c]  Character class range
-    - \c [a-z0-9_] Character class combination
-    - \c [^abc] Negated character classes
-    - \c [^a-c] Negated character class range
-    - \c [\b]   Backspace (U+0008)
-    - \c \\| \\\\ ...  Escape characters
-    - \c \\f Form feed (U+000C)
-    - \c \\n Line feed (U+000A)
-    - \c \\r Carriage return (U+000D)
-    - \c \\t Tab (U+0009)
-    - \c \\v Vertical tab (U+000B)
-
-    \note This is a Thompson NFA engine, implemented with reference to 
-        Cox, Russ. "Regular Expression Matching Can Be Simple And Fast (but is slow in Java, Perl, PHP, Python, Ruby,...).", 
-        https://swtch.com/~rsc/regexp/regexp1.html 
-*/
-template <typename Encoding, typename Allocator = CrtAllocator>
-class GenericRegex {
-public:
-    typedef Encoding EncodingType;
-    typedef typename Encoding::Ch Ch;
-    template <typename, typename> friend class GenericRegexSearch;
-
-    GenericRegex(const Ch* source, Allocator* allocator = 0) : 
-        ownAllocator_(allocator ? 0 : RAPIDJSON_NEW(Allocator)()), allocator_(allocator ? allocator : ownAllocator_), 
-        states_(allocator_, 256), ranges_(allocator_, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(), 
-        anchorBegin_(), anchorEnd_()
-    {
-        GenericStringStream<Encoding> ss(source);
-        DecodedStream<GenericStringStream<Encoding>, Encoding> ds(ss);
-        Parse(ds);
-    }
-
-    ~GenericRegex()
-    {
-        RAPIDJSON_DELETE(ownAllocator_);
-    }
-
-    bool IsValid() const {
-        return root_ != kRegexInvalidState;
-    }
-
-private:
-    enum Operator {
-        kZeroOrOne,
-        kZeroOrMore,
-        kOneOrMore,
-        kConcatenation,
-        kAlternation,
-        kLeftParenthesis
-    };
-
-    static const unsigned kAnyCharacterClass = 0xFFFFFFFF;   //!< For '.'
-    static const unsigned kRangeCharacterClass = 0xFFFFFFFE;
-    static const unsigned kRangeNegationFlag = 0x80000000;
-
-    struct Range {
-        unsigned start; // 
-        unsigned end;
-        SizeType next;
-    };
-
-    struct State {
-        SizeType out;     //!< Equals to kInvalid for matching state
-        SizeType out1;    //!< Equals to non-kInvalid for split
-        SizeType rangeStart;
-        unsigned codepoint;
-    };
-
-    struct Frag {
-        Frag(SizeType s, SizeType o, SizeType m) : start(s), out(o), minIndex(m) {}
-        SizeType start;
-        SizeType out; //!< link-list of all output states
-        SizeType minIndex;
-    };
-
-    State& GetState(SizeType index) {
-        RAPIDJSON_ASSERT(index < stateCount_);
-        return states_.template Bottom<State>()[index];
-    }
-
-    const State& GetState(SizeType index) const {
-        RAPIDJSON_ASSERT(index < stateCount_);
-        return states_.template Bottom<State>()[index];
-    }
-
-    Range& GetRange(SizeType index) {
-        RAPIDJSON_ASSERT(index < rangeCount_);
-        return ranges_.template Bottom<Range>()[index];
-    }
-
-    const Range& GetRange(SizeType index) const {
-        RAPIDJSON_ASSERT(index < rangeCount_);
-        return ranges_.template Bottom<Range>()[index];
-    }
-
-    template <typename InputStream>
-    void Parse(DecodedStream<InputStream, Encoding>& ds) {
-        Stack<Allocator> operandStack(allocator_, 256);    // Frag
-        Stack<Allocator> operatorStack(allocator_, 256);   // Operator
-        Stack<Allocator> atomCountStack(allocator_, 256);  // unsigned (Atom per parenthesis)
-
-        *atomCountStack.template Push<unsigned>() = 0;
-
-        unsigned codepoint;
-        while (ds.Peek() != 0) {
-            switch (codepoint = ds.Take()) {
-                case '^':
-                    anchorBegin_ = true;
-                    break;
-
-                case '$':
-                    anchorEnd_ = true;
-                    break;
-
-                case '|':
-                    while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() < kAlternation)
-                        if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
-                            return;
-                    *operatorStack.template Push<Operator>() = kAlternation;
-                    *atomCountStack.template Top<unsigned>() = 0;
-                    break;
-
-                case '(':
-                    *operatorStack.template Push<Operator>() = kLeftParenthesis;
-                    *atomCountStack.template Push<unsigned>() = 0;
-                    break;
-
-                case ')':
-                    while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() != kLeftParenthesis)
-                        if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
-                            return;
-                    if (operatorStack.Empty())
-                        return;
-                    operatorStack.template Pop<Operator>(1);
-                    atomCountStack.template Pop<unsigned>(1);
-                    ImplicitConcatenation(atomCountStack, operatorStack);
-                    break;
-
-                case '?':
-                    if (!Eval(operandStack, kZeroOrOne))
-                        return;
-                    break;
-
-                case '*':
-                    if (!Eval(operandStack, kZeroOrMore))
-                        return;
-                    break;
-
-                case '+':
-                    if (!Eval(operandStack, kOneOrMore))
-                        return;
-                    break;
-
-                case '{':
-                    {
-                        unsigned n, m;
-                        if (!ParseUnsigned(ds, &n))
-                            return;
-
-                        if (ds.Peek() == ',') {
-                            ds.Take();
-                            if (ds.Peek() == '}')
-                                m = kInfinityQuantifier;
-                            else if (!ParseUnsigned(ds, &m) || m < n)
-                                return;
-                        }
-                        else
-                            m = n;
-
-                        if (!EvalQuantifier(operandStack, n, m) || ds.Peek() != '}')
-                            return;
-                        ds.Take();
-                    }
-                    break;
-
-                case '.':
-                    PushOperand(operandStack, kAnyCharacterClass);
-                    ImplicitConcatenation(atomCountStack, operatorStack);
-                    break;
-
-                case '[':
-                    {
-                        SizeType range;
-                        if (!ParseRange(ds, &range))
-                            return;
-                        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, kRangeCharacterClass);
-                        GetState(s).rangeStart = range;
-                        *operandStack.template Push<Frag>() = Frag(s, s, s);
-                    }
-                    ImplicitConcatenation(atomCountStack, operatorStack);
-                    break;
-
-                case '\\': // Escape character
-                    if (!CharacterEscape(ds, &codepoint))
-                        return; // Unsupported escape character
-                    // fall through to default
-                    RAPIDJSON_DELIBERATE_FALLTHROUGH;
-
-                default: // Pattern character
-                    PushOperand(operandStack, codepoint);
-                    ImplicitConcatenation(atomCountStack, operatorStack);
-            }
-        }
-
-        while (!operatorStack.Empty())
-            if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
-                return;
-
-        // Link the operand to matching state.
-        if (operandStack.GetSize() == sizeof(Frag)) {
-            Frag* e = operandStack.template Pop<Frag>(1);
-            Patch(e->out, NewState(kRegexInvalidState, kRegexInvalidState, 0));
-            root_ = e->start;
-
-#if RAPIDJSON_REGEX_VERBOSE
-            printf("root: %d\n", root_);
-            for (SizeType i = 0; i < stateCount_ ; i++) {
-                State& s = GetState(i);
-                printf("[%2d] out: %2d out1: %2d c: '%c'\n", i, s.out, s.out1, (char)s.codepoint);
-            }
-            printf("\n");
-#endif
-        }
-    }
-
-    SizeType NewState(SizeType out, SizeType out1, unsigned codepoint) {
-        State* s = states_.template Push<State>();
-        s->out = out;
-        s->out1 = out1;
-        s->codepoint = codepoint;
-        s->rangeStart = kRegexInvalidRange;
-        return stateCount_++;
-    }
-
-    void PushOperand(Stack<Allocator>& operandStack, unsigned codepoint) {
-        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, codepoint);
-        *operandStack.template Push<Frag>() = Frag(s, s, s);
-    }
-
-    void ImplicitConcatenation(Stack<Allocator>& atomCountStack, Stack<Allocator>& operatorStack) {
-        if (*atomCountStack.template Top<unsigned>())
-            *operatorStack.template Push<Operator>() = kConcatenation;
-        (*atomCountStack.template Top<unsigned>())++;
-    }
-
-    SizeType Append(SizeType l1, SizeType l2) {
-        SizeType old = l1;
-        while (GetState(l1).out != kRegexInvalidState)
-            l1 = GetState(l1).out;
-        GetState(l1).out = l2;
-        return old;
-    }
-
-    void Patch(SizeType l, SizeType s) {
-        for (SizeType next; l != kRegexInvalidState; l = next) {
-            next = GetState(l).out;
-            GetState(l).out = s;
-        }
-    }
-
-    bool Eval(Stack<Allocator>& operandStack, Operator op) {
-        switch (op) {
-            case kConcatenation:
-                RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag) * 2);
-                {
-                    Frag e2 = *operandStack.template Pop<Frag>(1);
-                    Frag e1 = *operandStack.template Pop<Frag>(1);
-                    Patch(e1.out, e2.start);
-                    *operandStack.template Push<Frag>() = Frag(e1.start, e2.out, Min(e1.minIndex, e2.minIndex));
-                }
-                return true;
-
-            case kAlternation:
-                if (operandStack.GetSize() >= sizeof(Frag) * 2) {
-                    Frag e2 = *operandStack.template Pop<Frag>(1);
-                    Frag e1 = *operandStack.template Pop<Frag>(1);
-                    SizeType s = NewState(e1.start, e2.start, 0);
-                    *operandStack.template Push<Frag>() = Frag(s, Append(e1.out, e2.out), Min(e1.minIndex, e2.minIndex));
-                    return true;
-                }
-                return false;
-
-            case kZeroOrOne:
-                if (operandStack.GetSize() >= sizeof(Frag)) {
-                    Frag e = *operandStack.template Pop<Frag>(1);
-                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
-                    *operandStack.template Push<Frag>() = Frag(s, Append(e.out, s), e.minIndex);
-                    return true;
-                }
-                return false;
-
-            case kZeroOrMore:
-                if (operandStack.GetSize() >= sizeof(Frag)) {
-                    Frag e = *operandStack.template Pop<Frag>(1);
-                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
-                    Patch(e.out, s);
-                    *operandStack.template Push<Frag>() = Frag(s, s, e.minIndex);
-                    return true;
-                }
-                return false;
-
-            case kOneOrMore:
-                if (operandStack.GetSize() >= sizeof(Frag)) {
-                    Frag e = *operandStack.template Pop<Frag>(1);
-                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
-                    Patch(e.out, s);
-                    *operandStack.template Push<Frag>() = Frag(e.start, s, e.minIndex);
-                    return true;
-                }
-                return false;
-
-            default: 
-                // syntax error (e.g. unclosed kLeftParenthesis)
-                return false;
-        }
-    }
-
-    bool EvalQuantifier(Stack<Allocator>& operandStack, unsigned n, unsigned m) {
-        RAPIDJSON_ASSERT(n <= m);
-        RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag));
-
-        if (n == 0) {
-            if (m == 0)                             // a{0} not support
-                return false;
-            else if (m == kInfinityQuantifier)
-                Eval(operandStack, kZeroOrMore);    // a{0,} -> a*
-            else {
-                Eval(operandStack, kZeroOrOne);         // a{0,5} -> a?
-                for (unsigned i = 0; i < m - 1; i++)
-                    CloneTopOperand(operandStack);      // a{0,5} -> a? a? a? a? a?
-                for (unsigned i = 0; i < m - 1; i++)
-                    Eval(operandStack, kConcatenation); // a{0,5} -> a?a?a?a?a?
-            }
-            return true;
-        }
-
-        for (unsigned i = 0; i < n - 1; i++)        // a{3} -> a a a
-            CloneTopOperand(operandStack);
-
-        if (m == kInfinityQuantifier)
-            Eval(operandStack, kOneOrMore);         // a{3,} -> a a a+
-        else if (m > n) {
-            CloneTopOperand(operandStack);          // a{3,5} -> a a a a
-            Eval(operandStack, kZeroOrOne);         // a{3,5} -> a a a a?
-            for (unsigned i = n; i < m - 1; i++)
-                CloneTopOperand(operandStack);      // a{3,5} -> a a a a? a?
-            for (unsigned i = n; i < m; i++)
-                Eval(operandStack, kConcatenation); // a{3,5} -> a a aa?a?
-        }
-
-        for (unsigned i = 0; i < n - 1; i++)
-            Eval(operandStack, kConcatenation);     // a{3} -> aaa, a{3,} -> aaa+, a{3.5} -> aaaa?a?
-
-        return true;
-    }
-
-    static SizeType Min(SizeType a, SizeType b) { return a < b ? a : b; }
-
-    void CloneTopOperand(Stack<Allocator>& operandStack) {
-        const Frag src = *operandStack.template Top<Frag>(); // Copy constructor to prevent invalidation
-        SizeType count = stateCount_ - src.minIndex; // Assumes top operand contains states in [src->minIndex, stateCount_)
-        State* s = states_.template Push<State>(count);
-        memcpy(s, &GetState(src.minIndex), count * sizeof(State));
-        for (SizeType j = 0; j < count; j++) {
-            if (s[j].out != kRegexInvalidState)
-                s[j].out += count;
-            if (s[j].out1 != kRegexInvalidState)
-                s[j].out1 += count;
-        }
-        *operandStack.template Push<Frag>() = Frag(src.start + count, src.out + count, src.minIndex + count);
-        stateCount_ += count;
-    }
-
-    template <typename InputStream>
-    bool ParseUnsigned(DecodedStream<InputStream, Encoding>& ds, unsigned* u) {
-        unsigned r = 0;
-        if (ds.Peek() < '0' || ds.Peek() > '9')
-            return false;
-        while (ds.Peek() >= '0' && ds.Peek() <= '9') {
-            if (r >= 429496729 && ds.Peek() > '5') // 2^32 - 1 = 4294967295
-                return false; // overflow
-            r = r * 10 + (ds.Take() - '0');
-        }
-        *u = r;
-        return true;
-    }
-
-    template <typename InputStream>
-    bool ParseRange(DecodedStream<InputStream, Encoding>& ds, SizeType* range) {
-        bool isBegin = true;
-        bool negate = false;
-        int step = 0;
-        SizeType start = kRegexInvalidRange;
-        SizeType current = kRegexInvalidRange;
-        unsigned codepoint;
-        while ((codepoint = ds.Take()) != 0) {
-            if (isBegin) {
-                isBegin = false;
-                if (codepoint == '^') {
-                    negate = true;
-                    continue;
-                }
-            }
-
-            switch (codepoint) {
-            case ']':
-                if (start == kRegexInvalidRange)
-                    return false;   // Error: nothing inside []
-                if (step == 2) { // Add trailing '-'
-                    SizeType r = NewRange('-');
-                    RAPIDJSON_ASSERT(current != kRegexInvalidRange);
-                    GetRange(current).next = r;
-                }
-                if (negate)
-                    GetRange(start).start |= kRangeNegationFlag;
-                *range = start;
-                return true;
-
-            case '\\':
-                if (ds.Peek() == 'b') {
-                    ds.Take();
-                    codepoint = 0x0008; // Escape backspace character
-                }
-                else if (!CharacterEscape(ds, &codepoint))
-                    return false;
-                // fall through to default
-                RAPIDJSON_DELIBERATE_FALLTHROUGH;
-
-            default:
-                switch (step) {
-                case 1:
-                    if (codepoint == '-') {
-                        step++;
-                        break;
-                    }
-                    // fall through to step 0 for other characters
-                    RAPIDJSON_DELIBERATE_FALLTHROUGH;
-
-                case 0:
-                    {
-                        SizeType r = NewRange(codepoint);
-                        if (current != kRegexInvalidRange)
-                            GetRange(current).next = r;
-                        if (start == kRegexInvalidRange)
-                            start = r;
-                        current = r;
-                    }
-                    step = 1;
-                    break;
-
-                default:
-                    RAPIDJSON_ASSERT(step == 2);
-                    GetRange(current).end = codepoint;
-                    step = 0;
-                }
-            }
-        }
-        return false;
-    }
-    
-    SizeType NewRange(unsigned codepoint) {
-        Range* r = ranges_.template Push<Range>();
-        r->start = r->end = codepoint;
-        r->next = kRegexInvalidRange;
-        return rangeCount_++;
-    }
-
-    template <typename InputStream>
-    bool CharacterEscape(DecodedStream<InputStream, Encoding>& ds, unsigned* escapedCodepoint) {
-        unsigned codepoint;
-        switch (codepoint = ds.Take()) {
-            case '^':
-            case '$':
-            case '|':
-            case '(':
-            case ')':
-            case '?':
-            case '*':
-            case '+':
-            case '.':
-            case '[':
-            case ']':
-            case '{':
-            case '}':
-            case '\\':
-                *escapedCodepoint = codepoint; return true;
-            case 'f': *escapedCodepoint = 0x000C; return true;
-            case 'n': *escapedCodepoint = 0x000A; return true;
-            case 'r': *escapedCodepoint = 0x000D; return true;
-            case 't': *escapedCodepoint = 0x0009; return true;
-            case 'v': *escapedCodepoint = 0x000B; return true;
-            default:
-                return false; // Unsupported escape character
-        }
-    }
-
-    Allocator* ownAllocator_;
-    Allocator* allocator_;
-    Stack<Allocator> states_;
-    Stack<Allocator> ranges_;
-    SizeType root_;
-    SizeType stateCount_;
-    SizeType rangeCount_;
-
-    static const unsigned kInfinityQuantifier = ~0u;
-
-    // For SearchWithAnchoring()
-    bool anchorBegin_;
-    bool anchorEnd_;
-};
-
-template <typename RegexType, typename Allocator = CrtAllocator>
-class GenericRegexSearch {
-public:
-    typedef typename RegexType::EncodingType Encoding;
-    typedef typename Encoding::Ch Ch;
-
-    GenericRegexSearch(const RegexType& regex, Allocator* allocator = 0) : 
-        regex_(regex), allocator_(allocator), ownAllocator_(0),
-        state0_(allocator, 0), state1_(allocator, 0), stateSet_()
-    {
-        RAPIDJSON_ASSERT(regex_.IsValid());
-        if (!allocator_)
-            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-        stateSet_ = static_cast<unsigned*>(allocator_->Malloc(GetStateSetSize()));
-        state0_.template Reserve<SizeType>(regex_.stateCount_);
-        state1_.template Reserve<SizeType>(regex_.stateCount_);
-    }
-
-    ~GenericRegexSearch() {
-        Allocator::Free(stateSet_);
-        RAPIDJSON_DELETE(ownAllocator_);
-    }
-
-    template <typename InputStream>
-    bool Match(InputStream& is) {
-        return SearchWithAnchoring(is, true, true);
-    }
-
-    bool Match(const Ch* s) {
-        GenericStringStream<Encoding> is(s);
-        return Match(is);
-    }
-
-    template <typename InputStream>
-    bool Search(InputStream& is) {
-        return SearchWithAnchoring(is, regex_.anchorBegin_, regex_.anchorEnd_);
-    }
-
-    bool Search(const Ch* s) {
-        GenericStringStream<Encoding> is(s);
-        return Search(is);
-    }
-
-private:
-    typedef typename RegexType::State State;
-    typedef typename RegexType::Range Range;
-
-    template <typename InputStream>
-    bool SearchWithAnchoring(InputStream& is, bool anchorBegin, bool anchorEnd) {
-        DecodedStream<InputStream, Encoding> ds(is);
-
-        state0_.Clear();
-        Stack<Allocator> *current = &state0_, *next = &state1_;
-        const size_t stateSetSize = GetStateSetSize();
-        std::memset(stateSet_, 0, stateSetSize);
-
-        bool matched = AddState(*current, regex_.root_);
-        unsigned codepoint;
-        while (!current->Empty() && (codepoint = ds.Take()) != 0) {
-            std::memset(stateSet_, 0, stateSetSize);
-            next->Clear();
-            matched = false;
-            for (const SizeType* s = current->template Bottom<SizeType>(); s != current->template End<SizeType>(); ++s) {
-                const State& sr = regex_.GetState(*s);
-                if (sr.codepoint == codepoint ||
-                    sr.codepoint == RegexType::kAnyCharacterClass || 
-                    (sr.codepoint == RegexType::kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))
-                {
-                    matched = AddState(*next, sr.out) || matched;
-                    if (!anchorEnd && matched)
-                        return true;
-                }
-                if (!anchorBegin)
-                    AddState(*next, regex_.root_);
-            }
-            internal::Swap(current, next);
-        }
-
-        return matched;
-    }
-
-    size_t GetStateSetSize() const {
-        return (regex_.stateCount_ + 31) / 32 * 4;
-    }
-
-    // Return whether the added states is a match state
-    bool AddState(Stack<Allocator>& l, SizeType index) {
-        RAPIDJSON_ASSERT(index != kRegexInvalidState);
-
-        const State& s = regex_.GetState(index);
-        if (s.out1 != kRegexInvalidState) { // Split
-            bool matched = AddState(l, s.out);
-            return AddState(l, s.out1) || matched;
-        }
-        else if (!(stateSet_[index >> 5] & (1u << (index & 31)))) {
-            stateSet_[index >> 5] |= (1u << (index & 31));
-            *l.template PushUnsafe<SizeType>() = index;
-        }
-        return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation.
-    }
-
-    bool MatchRange(SizeType rangeIndex, unsigned codepoint) const {
-        bool yes = (regex_.GetRange(rangeIndex).start & RegexType::kRangeNegationFlag) == 0;
-        while (rangeIndex != kRegexInvalidRange) {
-            const Range& r = regex_.GetRange(rangeIndex);
-            if (codepoint >= (r.start & ~RegexType::kRangeNegationFlag) && codepoint <= r.end)
-                return yes;
-            rangeIndex = r.next;
-        }
-        return !yes;
-    }
-
-    const RegexType& regex_;
-    Allocator* allocator_;
-    Allocator* ownAllocator_;
-    Stack<Allocator> state0_;
-    Stack<Allocator> state1_;
-    uint32_t* stateSet_;
-};
-
-typedef GenericRegex<UTF8<> > Regex;
-typedef GenericRegexSearch<Regex> RegexSearch;
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#if defined(__clang__) || defined(_MSC_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_INTERNAL_REGEX_H_
diff --git a/thirdparty/rapidjson/internal/stack.h b/thirdparty/rapidjson/internal/stack.h
deleted file mode 100644
index 73abd70..0000000
--- a/thirdparty/rapidjson/internal/stack.h
+++ /dev/null
@@ -1,232 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_STACK_H_
-#define RAPIDJSON_INTERNAL_STACK_H_
-
-#include "../allocators.h"
-#include "swap.h"
-#include <cstddef>
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-///////////////////////////////////////////////////////////////////////////////
-// Stack
-
-//! A type-unsafe stack for storing different types of data.
-/*! \tparam Allocator Allocator for allocating stack memory.
-*/
-template <typename Allocator>
-class Stack {
-public:
-    // Optimization note: Do not allocate memory for stack_ in constructor.
-    // Do it lazily when first Push() -> Expand() -> Resize().
-    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    Stack(Stack&& rhs)
-        : allocator_(rhs.allocator_),
-          ownAllocator_(rhs.ownAllocator_),
-          stack_(rhs.stack_),
-          stackTop_(rhs.stackTop_),
-          stackEnd_(rhs.stackEnd_),
-          initialCapacity_(rhs.initialCapacity_)
-    {
-        rhs.allocator_ = 0;
-        rhs.ownAllocator_ = 0;
-        rhs.stack_ = 0;
-        rhs.stackTop_ = 0;
-        rhs.stackEnd_ = 0;
-        rhs.initialCapacity_ = 0;
-    }
-#endif
-
-    ~Stack() {
-        Destroy();
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    Stack& operator=(Stack&& rhs) {
-        if (&rhs != this)
-        {
-            Destroy();
-
-            allocator_ = rhs.allocator_;
-            ownAllocator_ = rhs.ownAllocator_;
-            stack_ = rhs.stack_;
-            stackTop_ = rhs.stackTop_;
-            stackEnd_ = rhs.stackEnd_;
-            initialCapacity_ = rhs.initialCapacity_;
-
-            rhs.allocator_ = 0;
-            rhs.ownAllocator_ = 0;
-            rhs.stack_ = 0;
-            rhs.stackTop_ = 0;
-            rhs.stackEnd_ = 0;
-            rhs.initialCapacity_ = 0;
-        }
-        return *this;
-    }
-#endif
-
-    void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT {
-        internal::Swap(allocator_, rhs.allocator_);
-        internal::Swap(ownAllocator_, rhs.ownAllocator_);
-        internal::Swap(stack_, rhs.stack_);
-        internal::Swap(stackTop_, rhs.stackTop_);
-        internal::Swap(stackEnd_, rhs.stackEnd_);
-        internal::Swap(initialCapacity_, rhs.initialCapacity_);
-    }
-
-    void Clear() { stackTop_ = stack_; }
-
-    void ShrinkToFit() { 
-        if (Empty()) {
-            // If the stack is empty, completely deallocate the memory.
-            Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
-            stack_ = 0;
-            stackTop_ = 0;
-            stackEnd_ = 0;
-        }
-        else
-            Resize(GetSize());
-    }
-
-    // Optimization note: try to minimize the size of this function for force inline.
-    // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
-    template<typename T>
-    RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
-         // Expand the stack if needed
-        if (RAPIDJSON_UNLIKELY(static_cast<std::ptrdiff_t>(sizeof(T) * count) > (stackEnd_ - stackTop_)))
-            Expand<T>(count);
-    }
-
-    template<typename T>
-    RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
-        Reserve<T>(count);
-        return PushUnsafe<T>(count);
-    }
-
-    template<typename T>
-    RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
-        RAPIDJSON_ASSERT(stackTop_);
-        RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
-        T* ret = reinterpret_cast<T*>(stackTop_);
-        stackTop_ += sizeof(T) * count;
-        return ret;
-    }
-
-    template<typename T>
-    T* Pop(size_t count) {
-        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
-        stackTop_ -= count * sizeof(T);
-        return reinterpret_cast<T*>(stackTop_);
-    }
-
-    template<typename T>
-    T* Top() { 
-        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
-        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
-    }
-
-    template<typename T>
-    const T* Top() const {
-        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
-        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
-    }
-
-    template<typename T>
-    T* End() { return reinterpret_cast<T*>(stackTop_); }
-
-    template<typename T>
-    const T* End() const { return reinterpret_cast<T*>(stackTop_); }
-
-    template<typename T>
-    T* Bottom() { return reinterpret_cast<T*>(stack_); }
-
-    template<typename T>
-    const T* Bottom() const { return reinterpret_cast<T*>(stack_); }
-
-    bool HasAllocator() const {
-        return allocator_ != 0;
-    }
-
-    Allocator& GetAllocator() {
-        RAPIDJSON_ASSERT(allocator_);
-        return *allocator_;
-    }
-
-    bool Empty() const { return stackTop_ == stack_; }
-    size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }
-    size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }
-
-private:
-    template<typename T>
-    void Expand(size_t count) {
-        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
-        size_t newCapacity;
-        if (stack_ == 0) {
-            if (!allocator_)
-                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-            newCapacity = initialCapacity_;
-        } else {
-            newCapacity = GetCapacity();
-            newCapacity += (newCapacity + 1) / 2;
-        }
-        size_t newSize = GetSize() + sizeof(T) * count;
-        if (newCapacity < newSize)
-            newCapacity = newSize;
-
-        Resize(newCapacity);
-    }
-
-    void Resize(size_t newCapacity) {
-        const size_t size = GetSize();  // Backup the current size
-        stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
-        stackTop_ = stack_ + size;
-        stackEnd_ = stack_ + newCapacity;
-    }
-
-    void Destroy() {
-        Allocator::Free(stack_);
-        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
-    }
-
-    // Prohibit copy constructor & assignment operator.
-    Stack(const Stack&);
-    Stack& operator=(const Stack&);
-
-    Allocator* allocator_;
-    Allocator* ownAllocator_;
-    char *stack_;
-    char *stackTop_;
-    char *stackEnd_;
-    size_t initialCapacity_;
-};
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_STACK_H_
diff --git a/thirdparty/rapidjson/internal/strfunc.h b/thirdparty/rapidjson/internal/strfunc.h
deleted file mode 100644
index baecb6c..0000000
--- a/thirdparty/rapidjson/internal/strfunc.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_STRFUNC_H_
-#define RAPIDJSON_INTERNAL_STRFUNC_H_
-
-#include "../stream.h"
-#include <cwchar>
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-//! Custom strlen() which works on different character types.
-/*! \tparam Ch Character type (e.g. char, wchar_t, short)
-    \param s Null-terminated input string.
-    \return Number of characters in the string. 
-    \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
-*/
-template <typename Ch>
-inline SizeType StrLen(const Ch* s) {
-    RAPIDJSON_ASSERT(s != 0);
-    const Ch* p = s;
-    while (*p) ++p;
-    return SizeType(p - s);
-}
-
-template <>
-inline SizeType StrLen(const char* s) {
-    return SizeType(std::strlen(s));
-}
-
-template <>
-inline SizeType StrLen(const wchar_t* s) {
-    return SizeType(std::wcslen(s));
-}
-
-//! Returns number of code points in a encoded string.
-template<typename Encoding>
-bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) {
-    RAPIDJSON_ASSERT(s != 0);
-    RAPIDJSON_ASSERT(outCount != 0);
-    GenericStringStream<Encoding> is(s);
-    const typename Encoding::Ch* end = s + length;
-    SizeType count = 0;
-    while (is.src_ < end) {
-        unsigned codepoint;
-        if (!Encoding::Decode(is, &codepoint))
-            return false;
-        count++;
-    }
-    *outCount = count;
-    return true;
-}
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_INTERNAL_STRFUNC_H_
diff --git a/thirdparty/rapidjson/internal/strtod.h b/thirdparty/rapidjson/internal/strtod.h
deleted file mode 100644
index d61a67a..0000000
--- a/thirdparty/rapidjson/internal/strtod.h
+++ /dev/null
@@ -1,290 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_STRTOD_
-#define RAPIDJSON_STRTOD_
-
-#include "ieee754.h"
-#include "biginteger.h"
-#include "diyfp.h"
-#include "pow10.h"
-#include <climits>
-#include <limits>
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-inline double FastPath(double significand, int exp) {
-    if (exp < -308)
-        return 0.0;
-    else if (exp >= 0)
-        return significand * internal::Pow10(exp);
-    else
-        return significand / internal::Pow10(-exp);
-}
-
-inline double StrtodNormalPrecision(double d, int p) {
-    if (p < -308) {
-        // Prevent expSum < -308, making Pow10(p) = 0
-        d = FastPath(d, -308);
-        d = FastPath(d, p + 308);
-    }
-    else
-        d = FastPath(d, p);
-    return d;
-}
-
-template <typename T>
-inline T Min3(T a, T b, T c) {
-    T m = a;
-    if (m > b) m = b;
-    if (m > c) m = c;
-    return m;
-}
-
-inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) {
-    const Double db(b);
-    const uint64_t bInt = db.IntegerSignificand();
-    const int bExp = db.IntegerExponent();
-    const int hExp = bExp - 1;
-
-    int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
-
-    // Adjust for decimal exponent
-    if (dExp >= 0) {
-        dS_Exp2 += dExp;
-        dS_Exp5 += dExp;
-    }
-    else {
-        bS_Exp2 -= dExp;
-        bS_Exp5 -= dExp;
-        hS_Exp2 -= dExp;
-        hS_Exp5 -= dExp;
-    }
-
-    // Adjust for binary exponent
-    if (bExp >= 0)
-        bS_Exp2 += bExp;
-    else {
-        dS_Exp2 -= bExp;
-        hS_Exp2 -= bExp;
-    }
-
-    // Adjust for half ulp exponent
-    if (hExp >= 0)
-        hS_Exp2 += hExp;
-    else {
-        dS_Exp2 -= hExp;
-        bS_Exp2 -= hExp;
-    }
-
-    // Remove common power of two factor from all three scaled values
-    int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
-    dS_Exp2 -= common_Exp2;
-    bS_Exp2 -= common_Exp2;
-    hS_Exp2 -= common_Exp2;
-
-    BigInteger dS = d;
-    dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);
-
-    BigInteger bS(bInt);
-    bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);
-
-    BigInteger hS(1);
-    hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);
-
-    BigInteger delta(0);
-    dS.Difference(bS, &delta);
-
-    return delta.Compare(hS);
-}
-
-inline bool StrtodFast(double d, int p, double* result) {
-    // Use fast path for string-to-double conversion if possible
-    // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
-    if (p > 22  && p < 22 + 16) {
-        // Fast Path Cases In Disguise
-        d *= internal::Pow10(p - 22);
-        p = 22;
-    }
-
-    if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
-        *result = FastPath(d, p);
-        return true;
-    }
-    else
-        return false;
-}
-
-// Compute an approximation and see if it is within 1/2 ULP
-inline bool StrtodDiyFp(const char* decimals, int dLen, int dExp, double* result) {
-    uint64_t significand = 0;
-    int i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
-    for (; i < dLen; i++) {
-        if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
-            (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
-            break;
-        significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
-    }
-    
-    if (i < dLen && decimals[i] >= '5') // Rounding
-        significand++;
-
-    int remaining = dLen - i;
-    const int kUlpShift = 3;
-    const int kUlp = 1 << kUlpShift;
-    int64_t error = (remaining == 0) ? 0 : kUlp / 2;
-
-    DiyFp v(significand, 0);
-    v = v.Normalize();
-    error <<= -v.e;
-
-    dExp += remaining;
-
-    int actualExp;
-    DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
-    if (actualExp != dExp) {
-        static const DiyFp kPow10[] = {
-            DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60),  // 10^1
-            DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57),  // 10^2
-            DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54),  // 10^3
-            DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50),  // 10^4
-            DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47),  // 10^5
-            DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44),  // 10^6
-            DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40)   // 10^7
-        };
-        int adjustment = dExp - actualExp;
-        RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8);
-        v = v * kPow10[adjustment - 1];
-        if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit
-            error += kUlp / 2;
-    }
-
-    v = v * cachedPower;
-
-    error += kUlp + (error == 0 ? 0 : 1);
-
-    const int oldExp = v.e;
-    v = v.Normalize();
-    error <<= oldExp - v.e;
-
-    const int effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
-    int precisionSize = 64 - effectiveSignificandSize;
-    if (precisionSize + kUlpShift >= 64) {
-        int scaleExp = (precisionSize + kUlpShift) - 63;
-        v.f >>= scaleExp;
-        v.e += scaleExp; 
-        error = (error >> scaleExp) + 1 + kUlp;
-        precisionSize -= scaleExp;
-    }
-
-    DiyFp rounded(v.f >> precisionSize, v.e + precisionSize);
-    const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
-    const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
-    if (precisionBits >= halfWay + static_cast<unsigned>(error)) {
-        rounded.f++;
-        if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
-            rounded.f >>= 1;
-            rounded.e++;
-        }
-    }
-
-    *result = rounded.ToDouble();
-
-    return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
-}
-
-inline double StrtodBigInteger(double approx, const char* decimals, int dLen, int dExp) {
-    RAPIDJSON_ASSERT(dLen >= 0);
-    const BigInteger dInt(decimals, static_cast<unsigned>(dLen));
-    Double a(approx);
-    int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
-    if (cmp < 0)
-        return a.Value();  // within half ULP
-    else if (cmp == 0) {
-        // Round towards even
-        if (a.Significand() & 1)
-            return a.NextPositiveDouble();
-        else
-            return a.Value();
-    }
-    else // adjustment
-        return a.NextPositiveDouble();
-}
-
-inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) {
-    RAPIDJSON_ASSERT(d >= 0.0);
-    RAPIDJSON_ASSERT(length >= 1);
-
-    double result = 0.0;
-    if (StrtodFast(d, p, &result))
-        return result;
-
-    RAPIDJSON_ASSERT(length <= INT_MAX);
-    int dLen = static_cast<int>(length);
-
-    RAPIDJSON_ASSERT(length >= decimalPosition);
-    RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX);
-    int dExpAdjust = static_cast<int>(length - decimalPosition);
-
-    RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust);
-    int dExp = exp - dExpAdjust;
-
-    // Make sure length+dExp does not overflow
-    RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen);
-
-    // Trim leading zeros
-    while (dLen > 0 && *decimals == '0') {
-        dLen--;
-        decimals++;
-    }
-
-    // Trim trailing zeros
-    while (dLen > 0 && decimals[dLen - 1] == '0') {
-        dLen--;
-        dExp++;
-    }
-
-    if (dLen == 0) { // Buffer only contains zeros.
-        return 0.0;
-    }
-
-    // Trim right-most digits
-    const int kMaxDecimalDigit = 767 + 1;
-    if (dLen > kMaxDecimalDigit) {
-        dExp += dLen - kMaxDecimalDigit;
-        dLen = kMaxDecimalDigit;
-    }
-
-    // If too small, underflow to zero.
-    // Any x <= 10^-324 is interpreted as zero.
-    if (dLen + dExp <= -324)
-        return 0.0;
-
-    // If too large, overflow to infinity.
-    // Any x >= 10^309 is interpreted as +infinity.
-    if (dLen + dExp > 309)
-        return std::numeric_limits<double>::infinity();
-
-    if (StrtodDiyFp(decimals, dLen, dExp, &result))
-        return result;
-
-    // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
-    return StrtodBigInteger(result, decimals, dLen, dExp);
-}
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_STRTOD_
diff --git a/thirdparty/rapidjson/internal/swap.h b/thirdparty/rapidjson/internal/swap.h
deleted file mode 100644
index 2cf92f9..0000000
--- a/thirdparty/rapidjson/internal/swap.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_SWAP_H_
-#define RAPIDJSON_INTERNAL_SWAP_H_
-
-#include "../rapidjson.h"
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-//! Custom swap() to avoid dependency on C++ <algorithm> header
-/*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.
-    \note This has the same semantics as std::swap().
-*/
-template <typename T>
-inline void Swap(T& a, T& b) RAPIDJSON_NOEXCEPT {
-    T tmp = a;
-        a = b;
-        b = tmp;
-}
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_INTERNAL_SWAP_H_
diff --git a/thirdparty/rapidjson/istreamwrapper.h b/thirdparty/rapidjson/istreamwrapper.h
deleted file mode 100644
index 01437ec..0000000
--- a/thirdparty/rapidjson/istreamwrapper.h
+++ /dev/null
@@ -1,128 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ISTREAMWRAPPER_H_
-#define RAPIDJSON_ISTREAMWRAPPER_H_
-
-#include "stream.h"
-#include <iosfwd>
-#include <ios>
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Wrapper of \c std::basic_istream into RapidJSON's Stream concept.
-/*!
-    The classes can be wrapped including but not limited to:
-
-    - \c std::istringstream
-    - \c std::stringstream
-    - \c std::wistringstream
-    - \c std::wstringstream
-    - \c std::ifstream
-    - \c std::fstream
-    - \c std::wifstream
-    - \c std::wfstream
-
-    \tparam StreamType Class derived from \c std::basic_istream.
-*/
-   
-template <typename StreamType>
-class BasicIStreamWrapper {
-public:
-    typedef typename StreamType::char_type Ch;
-
-    //! Constructor.
-    /*!
-        \param stream stream opened for read.
-    */
-    BasicIStreamWrapper(StreamType &stream) : stream_(stream), buffer_(peekBuffer_), bufferSize_(4), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
-        Read();
-    }
-
-    //! Constructor.
-    /*!
-        \param stream stream opened for read.
-        \param buffer user-supplied buffer.
-        \param bufferSize size of buffer in bytes. Must >=4 bytes.
-    */
-    BasicIStreamWrapper(StreamType &stream, char* buffer, size_t bufferSize) : stream_(stream), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
-        RAPIDJSON_ASSERT(bufferSize >= 4);
-        Read();
-    }
-
-    Ch Peek() const { return *current_; }
-    Ch Take() { Ch c = *current_; Read(); return c; }
-    size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
-
-    // Not implemented
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); } 
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-    // For encoding detection only.
-    const Ch* Peek4() const {
-        return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
-    }
-
-private:
-    BasicIStreamWrapper();
-    BasicIStreamWrapper(const BasicIStreamWrapper&);
-    BasicIStreamWrapper& operator=(const BasicIStreamWrapper&);
-
-    void Read() {
-        if (current_ < bufferLast_)
-            ++current_;
-        else if (!eof_) {
-            count_ += readCount_;
-            readCount_ = bufferSize_;
-            bufferLast_ = buffer_ + readCount_ - 1;
-            current_ = buffer_;
-
-            if (!stream_.read(buffer_, static_cast<std::streamsize>(bufferSize_))) {
-                readCount_ = static_cast<size_t>(stream_.gcount());
-                *(bufferLast_ = buffer_ + readCount_) = '\0';
-                eof_ = true;
-            }
-        }
-    }
-
-    StreamType &stream_;
-    Ch peekBuffer_[4], *buffer_;
-    size_t bufferSize_;
-    Ch *bufferLast_;
-    Ch *current_;
-    size_t readCount_;
-    size_t count_;  //!< Number of characters read
-    bool eof_;
-};
-
-typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
-typedef BasicIStreamWrapper<std::wistream> WIStreamWrapper;
-
-#if defined(__clang__) || defined(_MSC_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ISTREAMWRAPPER_H_
diff --git a/thirdparty/rapidjson/memorybuffer.h b/thirdparty/rapidjson/memorybuffer.h
deleted file mode 100644
index ffbc41e..0000000
--- a/thirdparty/rapidjson/memorybuffer.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_MEMORYBUFFER_H_
-#define RAPIDJSON_MEMORYBUFFER_H_
-
-#include "stream.h"
-#include "internal/stack.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Represents an in-memory output byte stream.
-/*!
-    This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream.
-
-    It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file.
-
-    Differences between MemoryBuffer and StringBuffer:
-    1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer. 
-    2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator.
-
-    \tparam Allocator type for allocating memory buffer.
-    \note implements Stream concept
-*/
-template <typename Allocator = CrtAllocator>
-struct GenericMemoryBuffer {
-    typedef char Ch; // byte
-
-    GenericMemoryBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
-
-    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
-    void Flush() {}
-
-    void Clear() { stack_.Clear(); }
-    void ShrinkToFit() { stack_.ShrinkToFit(); }
-    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
-    void Pop(size_t count) { stack_.template Pop<Ch>(count); }
-
-    const Ch* GetBuffer() const {
-        return stack_.template Bottom<Ch>();
-    }
-
-    size_t GetSize() const { return stack_.GetSize(); }
-
-    static const size_t kDefaultCapacity = 256;
-    mutable internal::Stack<Allocator> stack_;
-};
-
-typedef GenericMemoryBuffer<> MemoryBuffer;
-
-//! Implement specialized version of PutN() with memset() for better performance.
-template<>
-inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) {
-    std::memset(memoryBuffer.stack_.Push<char>(n), c, n * sizeof(c));
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/thirdparty/rapidjson/memorystream.h b/thirdparty/rapidjson/memorystream.h
deleted file mode 100644
index 77af6c9..0000000
--- a/thirdparty/rapidjson/memorystream.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_MEMORYSTREAM_H_
-#define RAPIDJSON_MEMORYSTREAM_H_
-
-#include "stream.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(unreachable-code)
-RAPIDJSON_DIAG_OFF(missing-noreturn)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Represents an in-memory input byte stream.
-/*!
-    This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream.
-
-    It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file.
-
-    Differences between MemoryStream and StringStream:
-    1. StringStream has encoding but MemoryStream is a byte stream.
-    2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source.
-    3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4().
-    \note implements Stream concept
-*/
-struct MemoryStream {
-    typedef char Ch; // byte
-
-    MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}
-
-    Ch Peek() const { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_; }
-    Ch Take() { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_++; }
-    size_t Tell() const { return static_cast<size_t>(src_ - begin_); }
-
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-    // For encoding detection only.
-    const Ch* Peek4() const {
-        return Tell() + 4 <= size_ ? src_ : 0;
-    }
-
-    const Ch* src_;     //!< Current read position.
-    const Ch* begin_;   //!< Original head of the string.
-    const Ch* end_;     //!< End of stream.
-    size_t size_;       //!< Size of the stream.
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/thirdparty/rapidjson/msinttypes/inttypes.h b/thirdparty/rapidjson/msinttypes/inttypes.h
deleted file mode 100644
index 1811128..0000000
--- a/thirdparty/rapidjson/msinttypes/inttypes.h
+++ /dev/null
@@ -1,316 +0,0 @@
-// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
-// 
-//  Copyright (c) 2006-2013 Alexander Chemeris
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// 
-//   1. Redistributions of source code must retain the above copyright notice,
-//      this list of conditions and the following disclaimer.
-// 
-//   2. Redistributions in binary form must reproduce the above copyright
-//      notice, this list of conditions and the following disclaimer in the
-//      documentation and/or other materials provided with the distribution.
-// 
-//   3. Neither the name of the product nor the names of its contributors may
-//      be used to endorse or promote products derived from this software
-//      without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
-///////////////////////////////////////////////////////////////////////////////
-
-// The above software in this distribution may have been modified by 
-// THL A29 Limited ("Tencent Modifications"). 
-// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
-
-#ifndef _MSC_VER // [
-#error "Use this header only with Microsoft Visual C++ compilers!"
-#endif // _MSC_VER ]
-
-#ifndef _MSC_INTTYPES_H_ // [
-#define _MSC_INTTYPES_H_
-
-#if _MSC_VER > 1000
-#pragma once
-#endif
-
-#include "stdint.h"
-
-// miloyip: VC supports inttypes.h since VC2013
-#if _MSC_VER >= 1800
-#include <inttypes.h>
-#else
-
-// 7.8 Format conversion of integer types
-
-typedef struct {
-   intmax_t quot;
-   intmax_t rem;
-} imaxdiv_t;
-
-// 7.8.1 Macros for format specifiers
-
-#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
-
-// The fprintf macros for signed integers are:
-#define PRId8       "d"
-#define PRIi8       "i"
-#define PRIdLEAST8  "d"
-#define PRIiLEAST8  "i"
-#define PRIdFAST8   "d"
-#define PRIiFAST8   "i"
-
-#define PRId16       "hd"
-#define PRIi16       "hi"
-#define PRIdLEAST16  "hd"
-#define PRIiLEAST16  "hi"
-#define PRIdFAST16   "hd"
-#define PRIiFAST16   "hi"
-
-#define PRId32       "I32d"
-#define PRIi32       "I32i"
-#define PRIdLEAST32  "I32d"
-#define PRIiLEAST32  "I32i"
-#define PRIdFAST32   "I32d"
-#define PRIiFAST32   "I32i"
-
-#define PRId64       "I64d"
-#define PRIi64       "I64i"
-#define PRIdLEAST64  "I64d"
-#define PRIiLEAST64  "I64i"
-#define PRIdFAST64   "I64d"
-#define PRIiFAST64   "I64i"
-
-#define PRIdMAX     "I64d"
-#define PRIiMAX     "I64i"
-
-#define PRIdPTR     "Id"
-#define PRIiPTR     "Ii"
-
-// The fprintf macros for unsigned integers are:
-#define PRIo8       "o"
-#define PRIu8       "u"
-#define PRIx8       "x"
-#define PRIX8       "X"
-#define PRIoLEAST8  "o"
-#define PRIuLEAST8  "u"
-#define PRIxLEAST8  "x"
-#define PRIXLEAST8  "X"
-#define PRIoFAST8   "o"
-#define PRIuFAST8   "u"
-#define PRIxFAST8   "x"
-#define PRIXFAST8   "X"
-
-#define PRIo16       "ho"
-#define PRIu16       "hu"
-#define PRIx16       "hx"
-#define PRIX16       "hX"
-#define PRIoLEAST16  "ho"
-#define PRIuLEAST16  "hu"
-#define PRIxLEAST16  "hx"
-#define PRIXLEAST16  "hX"
-#define PRIoFAST16   "ho"
-#define PRIuFAST16   "hu"
-#define PRIxFAST16   "hx"
-#define PRIXFAST16   "hX"
-
-#define PRIo32       "I32o"
-#define PRIu32       "I32u"
-#define PRIx32       "I32x"
-#define PRIX32       "I32X"
-#define PRIoLEAST32  "I32o"
-#define PRIuLEAST32  "I32u"
-#define PRIxLEAST32  "I32x"
-#define PRIXLEAST32  "I32X"
-#define PRIoFAST32   "I32o"
-#define PRIuFAST32   "I32u"
-#define PRIxFAST32   "I32x"
-#define PRIXFAST32   "I32X"
-
-#define PRIo64       "I64o"
-#define PRIu64       "I64u"
-#define PRIx64       "I64x"
-#define PRIX64       "I64X"
-#define PRIoLEAST64  "I64o"
-#define PRIuLEAST64  "I64u"
-#define PRIxLEAST64  "I64x"
-#define PRIXLEAST64  "I64X"
-#define PRIoFAST64   "I64o"
-#define PRIuFAST64   "I64u"
-#define PRIxFAST64   "I64x"
-#define PRIXFAST64   "I64X"
-
-#define PRIoMAX     "I64o"
-#define PRIuMAX     "I64u"
-#define PRIxMAX     "I64x"
-#define PRIXMAX     "I64X"
-
-#define PRIoPTR     "Io"
-#define PRIuPTR     "Iu"
-#define PRIxPTR     "Ix"
-#define PRIXPTR     "IX"
-
-// The fscanf macros for signed integers are:
-#define SCNd8       "d"
-#define SCNi8       "i"
-#define SCNdLEAST8  "d"
-#define SCNiLEAST8  "i"
-#define SCNdFAST8   "d"
-#define SCNiFAST8   "i"
-
-#define SCNd16       "hd"
-#define SCNi16       "hi"
-#define SCNdLEAST16  "hd"
-#define SCNiLEAST16  "hi"
-#define SCNdFAST16   "hd"
-#define SCNiFAST16   "hi"
-
-#define SCNd32       "ld"
-#define SCNi32       "li"
-#define SCNdLEAST32  "ld"
-#define SCNiLEAST32  "li"
-#define SCNdFAST32   "ld"
-#define SCNiFAST32   "li"
-
-#define SCNd64       "I64d"
-#define SCNi64       "I64i"
-#define SCNdLEAST64  "I64d"
-#define SCNiLEAST64  "I64i"
-#define SCNdFAST64   "I64d"
-#define SCNiFAST64   "I64i"
-
-#define SCNdMAX     "I64d"
-#define SCNiMAX     "I64i"
-
-#ifdef _WIN64 // [
-#  define SCNdPTR     "I64d"
-#  define SCNiPTR     "I64i"
-#else  // _WIN64 ][
-#  define SCNdPTR     "ld"
-#  define SCNiPTR     "li"
-#endif  // _WIN64 ]
-
-// The fscanf macros for unsigned integers are:
-#define SCNo8       "o"
-#define SCNu8       "u"
-#define SCNx8       "x"
-#define SCNX8       "X"
-#define SCNoLEAST8  "o"
-#define SCNuLEAST8  "u"
-#define SCNxLEAST8  "x"
-#define SCNXLEAST8  "X"
-#define SCNoFAST8   "o"
-#define SCNuFAST8   "u"
-#define SCNxFAST8   "x"
-#define SCNXFAST8   "X"
-
-#define SCNo16       "ho"
-#define SCNu16       "hu"
-#define SCNx16       "hx"
-#define SCNX16       "hX"
-#define SCNoLEAST16  "ho"
-#define SCNuLEAST16  "hu"
-#define SCNxLEAST16  "hx"
-#define SCNXLEAST16  "hX"
-#define SCNoFAST16   "ho"
-#define SCNuFAST16   "hu"
-#define SCNxFAST16   "hx"
-#define SCNXFAST16   "hX"
-
-#define SCNo32       "lo"
-#define SCNu32       "lu"
-#define SCNx32       "lx"
-#define SCNX32       "lX"
-#define SCNoLEAST32  "lo"
-#define SCNuLEAST32  "lu"
-#define SCNxLEAST32  "lx"
-#define SCNXLEAST32  "lX"
-#define SCNoFAST32   "lo"
-#define SCNuFAST32   "lu"
-#define SCNxFAST32   "lx"
-#define SCNXFAST32   "lX"
-
-#define SCNo64       "I64o"
-#define SCNu64       "I64u"
-#define SCNx64       "I64x"
-#define SCNX64       "I64X"
-#define SCNoLEAST64  "I64o"
-#define SCNuLEAST64  "I64u"
-#define SCNxLEAST64  "I64x"
-#define SCNXLEAST64  "I64X"
-#define SCNoFAST64   "I64o"
-#define SCNuFAST64   "I64u"
-#define SCNxFAST64   "I64x"
-#define SCNXFAST64   "I64X"
-
-#define SCNoMAX     "I64o"
-#define SCNuMAX     "I64u"
-#define SCNxMAX     "I64x"
-#define SCNXMAX     "I64X"
-
-#ifdef _WIN64 // [
-#  define SCNoPTR     "I64o"
-#  define SCNuPTR     "I64u"
-#  define SCNxPTR     "I64x"
-#  define SCNXPTR     "I64X"
-#else  // _WIN64 ][
-#  define SCNoPTR     "lo"
-#  define SCNuPTR     "lu"
-#  define SCNxPTR     "lx"
-#  define SCNXPTR     "lX"
-#endif  // _WIN64 ]
-
-#endif // __STDC_FORMAT_MACROS ]
-
-// 7.8.2 Functions for greatest-width integer types
-
-// 7.8.2.1 The imaxabs function
-#define imaxabs _abs64
-
-// 7.8.2.2 The imaxdiv function
-
-// This is modified version of div() function from Microsoft's div.c found
-// in %MSVC.NET%\crt\src\div.c
-#ifdef STATIC_IMAXDIV // [
-static
-#else // STATIC_IMAXDIV ][
-_inline
-#endif // STATIC_IMAXDIV ]
-imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
-{
-   imaxdiv_t result;
-
-   result.quot = numer / denom;
-   result.rem = numer % denom;
-
-   if (numer < 0 && result.rem > 0) {
-      // did division wrong; must fix up
-      ++result.quot;
-      result.rem -= denom;
-   }
-
-   return result;
-}
-
-// 7.8.2.3 The strtoimax and strtoumax functions
-#define strtoimax _strtoi64
-#define strtoumax _strtoui64
-
-// 7.8.2.4 The wcstoimax and wcstoumax functions
-#define wcstoimax _wcstoi64
-#define wcstoumax _wcstoui64
-
-#endif // _MSC_VER >= 1800
-
-#endif // _MSC_INTTYPES_H_ ]
diff --git a/thirdparty/rapidjson/msinttypes/stdint.h b/thirdparty/rapidjson/msinttypes/stdint.h
deleted file mode 100644
index 3d4477b..0000000
--- a/thirdparty/rapidjson/msinttypes/stdint.h
+++ /dev/null
@@ -1,300 +0,0 @@
-// ISO C9x  compliant stdint.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
-// 
-//  Copyright (c) 2006-2013 Alexander Chemeris
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// 
-//   1. Redistributions of source code must retain the above copyright notice,
-//      this list of conditions and the following disclaimer.
-// 
-//   2. Redistributions in binary form must reproduce the above copyright
-//      notice, this list of conditions and the following disclaimer in the
-//      documentation and/or other materials provided with the distribution.
-// 
-//   3. Neither the name of the product nor the names of its contributors may
-//      be used to endorse or promote products derived from this software
-//      without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
-///////////////////////////////////////////////////////////////////////////////
-
-// The above software in this distribution may have been modified by 
-// THL A29 Limited ("Tencent Modifications"). 
-// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
-
-#ifndef _MSC_VER // [
-#error "Use this header only with Microsoft Visual C++ compilers!"
-#endif // _MSC_VER ]
-
-#ifndef _MSC_STDINT_H_ // [
-#define _MSC_STDINT_H_
-
-#if _MSC_VER > 1000
-#pragma once
-#endif
-
-// miloyip: Originally Visual Studio 2010 uses its own stdint.h. However it generates warning with INT64_C(), so change to use this file for vs2010.
-#if _MSC_VER >= 1600 // [
-#include <stdint.h>
-
-#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
-
-#undef INT8_C
-#undef INT16_C
-#undef INT32_C
-#undef INT64_C
-#undef UINT8_C
-#undef UINT16_C
-#undef UINT32_C
-#undef UINT64_C
-
-// 7.18.4.1 Macros for minimum-width integer constants
-
-#define INT8_C(val)  val##i8
-#define INT16_C(val) val##i16
-#define INT32_C(val) val##i32
-#define INT64_C(val) val##i64
-
-#define UINT8_C(val)  val##ui8
-#define UINT16_C(val) val##ui16
-#define UINT32_C(val) val##ui32
-#define UINT64_C(val) val##ui64
-
-// 7.18.4.2 Macros for greatest-width integer constants
-// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
-// Check out Issue 9 for the details.
-#ifndef INTMAX_C //   [
-#  define INTMAX_C   INT64_C
-#endif // INTMAX_C    ]
-#ifndef UINTMAX_C //  [
-#  define UINTMAX_C  UINT64_C
-#endif // UINTMAX_C   ]
-
-#endif // __STDC_CONSTANT_MACROS ]
-
-#else // ] _MSC_VER >= 1700 [
-
-#include <limits.h>
-
-// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
-// compiling for ARM we have to wrap <wchar.h> include with 'extern "C++" {}'
-// or compiler would give many errors like this:
-//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
-#if defined(__cplusplus) && !defined(_M_ARM)
-extern "C" {
-#endif
-#  include <wchar.h>
-#if defined(__cplusplus) && !defined(_M_ARM)
-}
-#endif
-
-// Define _W64 macros to mark types changing their size, like intptr_t.
-#ifndef _W64
-#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
-#     define _W64 __w64
-#  else
-#     define _W64
-#  endif
-#endif
-
-
-// 7.18.1 Integer types
-
-// 7.18.1.1 Exact-width integer types
-
-// Visual Studio 6 and Embedded Visual C++ 4 doesn't
-// realize that, e.g. char has the same size as __int8
-// so we give up on __intX for them.
-#if (_MSC_VER < 1300)
-   typedef signed char       int8_t;
-   typedef signed short      int16_t;
-   typedef signed int        int32_t;
-   typedef unsigned char     uint8_t;
-   typedef unsigned short    uint16_t;
-   typedef unsigned int      uint32_t;
-#else
-   typedef signed __int8     int8_t;
-   typedef signed __int16    int16_t;
-   typedef signed __int32    int32_t;
-   typedef unsigned __int8   uint8_t;
-   typedef unsigned __int16  uint16_t;
-   typedef unsigned __int32  uint32_t;
-#endif
-typedef signed __int64       int64_t;
-typedef unsigned __int64     uint64_t;
-
-
-// 7.18.1.2 Minimum-width integer types
-typedef int8_t    int_least8_t;
-typedef int16_t   int_least16_t;
-typedef int32_t   int_least32_t;
-typedef int64_t   int_least64_t;
-typedef uint8_t   uint_least8_t;
-typedef uint16_t  uint_least16_t;
-typedef uint32_t  uint_least32_t;
-typedef uint64_t  uint_least64_t;
-
-// 7.18.1.3 Fastest minimum-width integer types
-typedef int8_t    int_fast8_t;
-typedef int16_t   int_fast16_t;
-typedef int32_t   int_fast32_t;
-typedef int64_t   int_fast64_t;
-typedef uint8_t   uint_fast8_t;
-typedef uint16_t  uint_fast16_t;
-typedef uint32_t  uint_fast32_t;
-typedef uint64_t  uint_fast64_t;
-
-// 7.18.1.4 Integer types capable of holding object pointers
-#ifdef _WIN64 // [
-   typedef signed __int64    intptr_t;
-   typedef unsigned __int64  uintptr_t;
-#else // _WIN64 ][
-   typedef _W64 signed int   intptr_t;
-   typedef _W64 unsigned int uintptr_t;
-#endif // _WIN64 ]
-
-// 7.18.1.5 Greatest-width integer types
-typedef int64_t   intmax_t;
-typedef uint64_t  uintmax_t;
-
-
-// 7.18.2 Limits of specified-width integer types
-
-#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
-
-// 7.18.2.1 Limits of exact-width integer types
-#define INT8_MIN     ((int8_t)_I8_MIN)
-#define INT8_MAX     _I8_MAX
-#define INT16_MIN    ((int16_t)_I16_MIN)
-#define INT16_MAX    _I16_MAX
-#define INT32_MIN    ((int32_t)_I32_MIN)
-#define INT32_MAX    _I32_MAX
-#define INT64_MIN    ((int64_t)_I64_MIN)
-#define INT64_MAX    _I64_MAX
-#define UINT8_MAX    _UI8_MAX
-#define UINT16_MAX   _UI16_MAX
-#define UINT32_MAX   _UI32_MAX
-#define UINT64_MAX   _UI64_MAX
-
-// 7.18.2.2 Limits of minimum-width integer types
-#define INT_LEAST8_MIN    INT8_MIN
-#define INT_LEAST8_MAX    INT8_MAX
-#define INT_LEAST16_MIN   INT16_MIN
-#define INT_LEAST16_MAX   INT16_MAX
-#define INT_LEAST32_MIN   INT32_MIN
-#define INT_LEAST32_MAX   INT32_MAX
-#define INT_LEAST64_MIN   INT64_MIN
-#define INT_LEAST64_MAX   INT64_MAX
-#define UINT_LEAST8_MAX   UINT8_MAX
-#define UINT_LEAST16_MAX  UINT16_MAX
-#define UINT_LEAST32_MAX  UINT32_MAX
-#define UINT_LEAST64_MAX  UINT64_MAX
-
-// 7.18.2.3 Limits of fastest minimum-width integer types
-#define INT_FAST8_MIN    INT8_MIN
-#define INT_FAST8_MAX    INT8_MAX
-#define INT_FAST16_MIN   INT16_MIN
-#define INT_FAST16_MAX   INT16_MAX
-#define INT_FAST32_MIN   INT32_MIN
-#define INT_FAST32_MAX   INT32_MAX
-#define INT_FAST64_MIN   INT64_MIN
-#define INT_FAST64_MAX   INT64_MAX
-#define UINT_FAST8_MAX   UINT8_MAX
-#define UINT_FAST16_MAX  UINT16_MAX
-#define UINT_FAST32_MAX  UINT32_MAX
-#define UINT_FAST64_MAX  UINT64_MAX
-
-// 7.18.2.4 Limits of integer types capable of holding object pointers
-#ifdef _WIN64 // [
-#  define INTPTR_MIN   INT64_MIN
-#  define INTPTR_MAX   INT64_MAX
-#  define UINTPTR_MAX  UINT64_MAX
-#else // _WIN64 ][
-#  define INTPTR_MIN   INT32_MIN
-#  define INTPTR_MAX   INT32_MAX
-#  define UINTPTR_MAX  UINT32_MAX
-#endif // _WIN64 ]
-
-// 7.18.2.5 Limits of greatest-width integer types
-#define INTMAX_MIN   INT64_MIN
-#define INTMAX_MAX   INT64_MAX
-#define UINTMAX_MAX  UINT64_MAX
-
-// 7.18.3 Limits of other integer types
-
-#ifdef _WIN64 // [
-#  define PTRDIFF_MIN  _I64_MIN
-#  define PTRDIFF_MAX  _I64_MAX
-#else  // _WIN64 ][
-#  define PTRDIFF_MIN  _I32_MIN
-#  define PTRDIFF_MAX  _I32_MAX
-#endif  // _WIN64 ]
-
-#define SIG_ATOMIC_MIN  INT_MIN
-#define SIG_ATOMIC_MAX  INT_MAX
-
-#ifndef SIZE_MAX // [
-#  ifdef _WIN64 // [
-#     define SIZE_MAX  _UI64_MAX
-#  else // _WIN64 ][
-#     define SIZE_MAX  _UI32_MAX
-#  endif // _WIN64 ]
-#endif // SIZE_MAX ]
-
-// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
-#ifndef WCHAR_MIN // [
-#  define WCHAR_MIN  0
-#endif  // WCHAR_MIN ]
-#ifndef WCHAR_MAX // [
-#  define WCHAR_MAX  _UI16_MAX
-#endif  // WCHAR_MAX ]
-
-#define WINT_MIN  0
-#define WINT_MAX  _UI16_MAX
-
-#endif // __STDC_LIMIT_MACROS ]
-
-
-// 7.18.4 Limits of other integer types
-
-#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
-
-// 7.18.4.1 Macros for minimum-width integer constants
-
-#define INT8_C(val)  val##i8
-#define INT16_C(val) val##i16
-#define INT32_C(val) val##i32
-#define INT64_C(val) val##i64
-
-#define UINT8_C(val)  val##ui8
-#define UINT16_C(val) val##ui16
-#define UINT32_C(val) val##ui32
-#define UINT64_C(val) val##ui64
-
-// 7.18.4.2 Macros for greatest-width integer constants
-// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
-// Check out Issue 9 for the details.
-#ifndef INTMAX_C //   [
-#  define INTMAX_C   INT64_C
-#endif // INTMAX_C    ]
-#ifndef UINTMAX_C //  [
-#  define UINTMAX_C  UINT64_C
-#endif // UINTMAX_C   ]
-
-#endif // __STDC_CONSTANT_MACROS ]
-
-#endif // _MSC_VER >= 1600 ]
-
-#endif // _MSC_STDINT_H_ ]
diff --git a/thirdparty/rapidjson/ostreamwrapper.h b/thirdparty/rapidjson/ostreamwrapper.h
deleted file mode 100644
index 11ed4d3..0000000
--- a/thirdparty/rapidjson/ostreamwrapper.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_OSTREAMWRAPPER_H_
-#define RAPIDJSON_OSTREAMWRAPPER_H_
-
-#include "stream.h"
-#include <iosfwd>
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Wrapper of \c std::basic_ostream into RapidJSON's Stream concept.
-/*!
-    The classes can be wrapped including but not limited to:
-
-    - \c std::ostringstream
-    - \c std::stringstream
-    - \c std::wpstringstream
-    - \c std::wstringstream
-    - \c std::ifstream
-    - \c std::fstream
-    - \c std::wofstream
-    - \c std::wfstream
-
-    \tparam StreamType Class derived from \c std::basic_ostream.
-*/
-   
-template <typename StreamType>
-class BasicOStreamWrapper {
-public:
-    typedef typename StreamType::char_type Ch;
-    BasicOStreamWrapper(StreamType& stream) : stream_(stream) {}
-
-    void Put(Ch c) {
-        stream_.put(c);
-    }
-
-    void Flush() {
-        stream_.flush();
-    }
-
-    // Not implemented
-    char Peek() const { RAPIDJSON_ASSERT(false); return 0; }
-    char Take() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
-    char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    BasicOStreamWrapper(const BasicOStreamWrapper&);
-    BasicOStreamWrapper& operator=(const BasicOStreamWrapper&);
-
-    StreamType& stream_;
-};
-
-typedef BasicOStreamWrapper<std::ostream> OStreamWrapper;
-typedef BasicOStreamWrapper<std::wostream> WOStreamWrapper;
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_OSTREAMWRAPPER_H_
diff --git a/thirdparty/rapidjson/pointer.h b/thirdparty/rapidjson/pointer.h
deleted file mode 100644
index 90e5903..0000000
--- a/thirdparty/rapidjson/pointer.h
+++ /dev/null
@@ -1,1415 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_POINTER_H_
-#define RAPIDJSON_POINTER_H_
-
-#include "document.h"
-#include "internal/itoa.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(switch-enum)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-static const SizeType kPointerInvalidIndex = ~SizeType(0);  //!< Represents an invalid index in GenericPointer::Token
-
-//! Error code of parsing.
-/*! \ingroup RAPIDJSON_ERRORS
-    \see GenericPointer::GenericPointer, GenericPointer::GetParseErrorCode
-*/
-enum PointerParseErrorCode {
-    kPointerParseErrorNone = 0,                     //!< The parse is successful
-
-    kPointerParseErrorTokenMustBeginWithSolidus,    //!< A token must begin with a '/'
-    kPointerParseErrorInvalidEscape,                //!< Invalid escape
-    kPointerParseErrorInvalidPercentEncoding,       //!< Invalid percent encoding in URI fragment
-    kPointerParseErrorCharacterMustPercentEncode    //!< A character must percent encoded in URI fragment
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericPointer
-
-//! Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
-/*!
-    This class implements RFC 6901 "JavaScript Object Notation (JSON) Pointer" 
-    (https://tools.ietf.org/html/rfc6901).
-
-    A JSON pointer is for identifying a specific value in a JSON document
-    (GenericDocument). It can simplify coding of DOM tree manipulation, because it
-    can access multiple-level depth of DOM tree with single API call.
-
-    After it parses a string representation (e.g. "/foo/0" or URI fragment 
-    representation (e.g. "#/foo/0") into its internal representation (tokens),
-    it can be used to resolve a specific value in multiple documents, or sub-tree 
-    of documents.
-
-    Contrary to GenericValue, Pointer can be copy constructed and copy assigned.
-    Apart from assignment, a Pointer cannot be modified after construction.
-
-    Although Pointer is very convenient, please aware that constructing Pointer
-    involves parsing and dynamic memory allocation. A special constructor with user-
-    supplied tokens eliminates these.
-
-    GenericPointer depends on GenericDocument and GenericValue.
-    
-    \tparam ValueType The value type of the DOM tree. E.g. GenericValue<UTF8<> >
-    \tparam Allocator The allocator type for allocating memory for internal representation.
-    
-    \note GenericPointer uses same encoding of ValueType.
-    However, Allocator of GenericPointer is independent of Allocator of Value.
-*/
-template <typename ValueType, typename Allocator = CrtAllocator>
-class GenericPointer {
-public:
-    typedef typename ValueType::EncodingType EncodingType;  //!< Encoding type from Value
-    typedef typename ValueType::Ch Ch;                      //!< Character type from Value
-
-    //! A token is the basic units of internal representation.
-    /*!
-        A JSON pointer string representation "/foo/123" is parsed to two tokens: 
-        "foo" and 123. 123 will be represented in both numeric form and string form.
-        They are resolved according to the actual value type (object or array).
-
-        For token that are not numbers, or the numeric value is out of bound
-        (greater than limits of SizeType), they are only treated as string form
-        (i.e. the token's index will be equal to kPointerInvalidIndex).
-
-        This struct is public so that user can create a Pointer without parsing and 
-        allocation, using a special constructor.
-    */
-    struct Token {
-        const Ch* name;             //!< Name of the token. It has null character at the end but it can contain null character.
-        SizeType length;            //!< Length of the name.
-        SizeType index;             //!< A valid array index, if it is not equal to kPointerInvalidIndex.
-    };
-
-    //!@name Constructors and destructor.
-    //@{
-
-    //! Default constructor.
-    GenericPointer(Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
-
-    //! Constructor that parses a string or URI fragment representation.
-    /*!
-        \param source A null-terminated, string or URI fragment representation of JSON pointer.
-        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
-    */
-    explicit GenericPointer(const Ch* source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
-        Parse(source, internal::StrLen(source));
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Constructor that parses a string or URI fragment representation.
-    /*!
-        \param source A string or URI fragment representation of JSON pointer.
-        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
-        \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-    */
-    explicit GenericPointer(const std::basic_string<Ch>& source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
-        Parse(source.c_str(), source.size());
-    }
-#endif
-
-    //! Constructor that parses a string or URI fragment representation, with length of the source string.
-    /*!
-        \param source A string or URI fragment representation of JSON pointer.
-        \param length Length of source.
-        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
-        \note Slightly faster than the overload without length.
-    */
-    GenericPointer(const Ch* source, size_t length, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
-        Parse(source, length);
-    }
-
-    //! Constructor with user-supplied tokens.
-    /*!
-        This constructor let user supplies const array of tokens.
-        This prevents the parsing process and eliminates allocation.
-        This is preferred for memory constrained environments.
-
-        \param tokens An constant array of tokens representing the JSON pointer.
-        \param tokenCount Number of tokens.
-
-        \b Example
-        \code
-        #define NAME(s) { s, sizeof(s) / sizeof(s[0]) - 1, kPointerInvalidIndex }
-        #define INDEX(i) { #i, sizeof(#i) - 1, i }
-
-        static const Pointer::Token kTokens[] = { NAME("foo"), INDEX(123) };
-        static const Pointer p(kTokens, sizeof(kTokens) / sizeof(kTokens[0]));
-        // Equivalent to static const Pointer p("/foo/123");
-
-        #undef NAME
-        #undef INDEX
-        \endcode
-    */
-    GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
-
-    //! Copy constructor.
-    GenericPointer(const GenericPointer& rhs) : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
-        *this = rhs;
-    }
-
-    //! Copy constructor.
-    GenericPointer(const GenericPointer& rhs, Allocator* allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
-        *this = rhs;
-    }
-
-    //! Destructor.
-    ~GenericPointer() {
-        if (nameBuffer_)    // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated.
-            Allocator::Free(tokens_);
-        RAPIDJSON_DELETE(ownAllocator_);
-    }
-
-    //! Assignment operator.
-    GenericPointer& operator=(const GenericPointer& rhs) {
-        if (this != &rhs) {
-            // Do not delete ownAllcator
-            if (nameBuffer_)
-                Allocator::Free(tokens_);
-
-            tokenCount_ = rhs.tokenCount_;
-            parseErrorOffset_ = rhs.parseErrorOffset_;
-            parseErrorCode_ = rhs.parseErrorCode_;
-
-            if (rhs.nameBuffer_)
-                CopyFromRaw(rhs); // Normally parsed tokens.
-            else {
-                tokens_ = rhs.tokens_; // User supplied const tokens.
-                nameBuffer_ = 0;
-            }
-        }
-        return *this;
-    }
-
-    //! Swap the content of this pointer with an other.
-    /*!
-        \param other The pointer to swap with.
-        \note Constant complexity.
-    */
-    GenericPointer& Swap(GenericPointer& other) RAPIDJSON_NOEXCEPT {
-        internal::Swap(allocator_, other.allocator_);
-        internal::Swap(ownAllocator_, other.ownAllocator_);
-        internal::Swap(nameBuffer_, other.nameBuffer_);
-        internal::Swap(tokens_, other.tokens_);
-        internal::Swap(tokenCount_, other.tokenCount_);
-        internal::Swap(parseErrorOffset_, other.parseErrorOffset_);
-        internal::Swap(parseErrorCode_, other.parseErrorCode_);
-        return *this;
-    }
-
-    //! free-standing swap function helper
-    /*!
-        Helper function to enable support for common swap implementation pattern based on \c std::swap:
-        \code
-        void swap(MyClass& a, MyClass& b) {
-            using std::swap;
-            swap(a.pointer, b.pointer);
-            // ...
-        }
-        \endcode
-        \see Swap()
-     */
-    friend inline void swap(GenericPointer& a, GenericPointer& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }
-
-    //@}
-
-    //!@name Append token
-    //@{
-
-    //! Append a token and return a new Pointer
-    /*!
-        \param token Token to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(const Token& token, Allocator* allocator = 0) const {
-        GenericPointer r;
-        r.allocator_ = allocator;
-        Ch *p = r.CopyFromRaw(*this, 1, token.length + 1);
-        std::memcpy(p, token.name, (token.length + 1) * sizeof(Ch));
-        r.tokens_[tokenCount_].name = p;
-        r.tokens_[tokenCount_].length = token.length;
-        r.tokens_[tokenCount_].index = token.index;
-        return r;
-    }
-
-    //! Append a name token with length, and return a new Pointer
-    /*!
-        \param name Name to be appended.
-        \param length Length of name.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(const Ch* name, SizeType length, Allocator* allocator = 0) const {
-        Token token = { name, length, kPointerInvalidIndex };
-        return Append(token, allocator);
-    }
-
-    //! Append a name token without length, and return a new Pointer
-    /*!
-        \param name Name (const Ch*) to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >), (GenericPointer))
-    Append(T* name, Allocator* allocator = 0) const {
-        return Append(name, internal::StrLen(name), allocator);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Append a name token, and return a new Pointer
-    /*!
-        \param name Name to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(const std::basic_string<Ch>& name, Allocator* allocator = 0) const {
-        return Append(name.c_str(), static_cast<SizeType>(name.size()), allocator);
-    }
-#endif
-
-    //! Append a index token, and return a new Pointer
-    /*!
-        \param index Index to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(SizeType index, Allocator* allocator = 0) const {
-        char buffer[21];
-        char* end = sizeof(SizeType) == 4 ? internal::u32toa(index, buffer) : internal::u64toa(index, buffer);
-        SizeType length = static_cast<SizeType>(end - buffer);
-        buffer[length] = '\0';
-
-        if (sizeof(Ch) == 1) {
-            Token token = { reinterpret_cast<Ch*>(buffer), length, index };
-            return Append(token, allocator);
-        }
-        else {
-            Ch name[21];
-            for (size_t i = 0; i <= length; i++)
-                name[i] = static_cast<Ch>(buffer[i]);
-            Token token = { name, length, index };
-            return Append(token, allocator);
-        }
-    }
-
-    //! Append a token by value, and return a new Pointer
-    /*!
-        \param token token to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(const ValueType& token, Allocator* allocator = 0) const {
-        if (token.IsString())
-            return Append(token.GetString(), token.GetStringLength(), allocator);
-        else {
-            RAPIDJSON_ASSERT(token.IsUint64());
-            RAPIDJSON_ASSERT(token.GetUint64() <= SizeType(~0));
-            return Append(static_cast<SizeType>(token.GetUint64()), allocator);
-        }
-    }
-
-    //!@name Handling Parse Error
-    //@{
-
-    //! Check whether this is a valid pointer.
-    bool IsValid() const { return parseErrorCode_ == kPointerParseErrorNone; }
-
-    //! Get the parsing error offset in code unit.
-    size_t GetParseErrorOffset() const { return parseErrorOffset_; }
-
-    //! Get the parsing error code.
-    PointerParseErrorCode GetParseErrorCode() const { return parseErrorCode_; }
-
-    //@}
-
-    //! Get the allocator of this pointer.
-    Allocator& GetAllocator() { return *allocator_; }
-
-    //!@name Tokens
-    //@{
-
-    //! Get the token array (const version only).
-    const Token* GetTokens() const { return tokens_; }
-
-    //! Get the number of tokens.
-    size_t GetTokenCount() const { return tokenCount_; }
-
-    //@}
-
-    //!@name Equality/inequality operators
-    //@{
-
-    //! Equality operator.
-    /*!
-        \note When any pointers are invalid, always returns false.
-    */
-    bool operator==(const GenericPointer& rhs) const {
-        if (!IsValid() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_)
-            return false;
-
-        for (size_t i = 0; i < tokenCount_; i++) {
-            if (tokens_[i].index != rhs.tokens_[i].index ||
-                tokens_[i].length != rhs.tokens_[i].length || 
-                (tokens_[i].length != 0 && std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch)* tokens_[i].length) != 0))
-            {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    //! Inequality operator.
-    /*!
-        \note When any pointers are invalid, always returns true.
-    */
-    bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); }
-
-    //! Less than operator.
-    /*!
-        \note Invalid pointers are always greater than valid ones.
-    */
-    bool operator<(const GenericPointer& rhs) const {
-        if (!IsValid())
-            return false;
-        if (!rhs.IsValid())
-            return true;
-
-        if (tokenCount_ != rhs.tokenCount_)
-            return tokenCount_ < rhs.tokenCount_;
-
-        for (size_t i = 0; i < tokenCount_; i++) {
-            if (tokens_[i].index != rhs.tokens_[i].index)
-                return tokens_[i].index < rhs.tokens_[i].index;
-
-            if (tokens_[i].length != rhs.tokens_[i].length)
-                return tokens_[i].length < rhs.tokens_[i].length;
-
-            if (int cmp = std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch) * tokens_[i].length))
-                return cmp < 0;
-        }
-
-        return false;
-    }
-
-    //@}
-
-    //!@name Stringify
-    //@{
-
-    //! Stringify the pointer into string representation.
-    /*!
-        \tparam OutputStream Type of output stream.
-        \param os The output stream.
-    */
-    template<typename OutputStream>
-    bool Stringify(OutputStream& os) const {
-        return Stringify<false, OutputStream>(os);
-    }
-
-    //! Stringify the pointer into URI fragment representation.
-    /*!
-        \tparam OutputStream Type of output stream.
-        \param os The output stream.
-    */
-    template<typename OutputStream>
-    bool StringifyUriFragment(OutputStream& os) const {
-        return Stringify<true, OutputStream>(os);
-    }
-
-    //@}
-
-    //!@name Create value
-    //@{
-
-    //! Create a value in a subtree.
-    /*!
-        If the value is not exist, it creates all parent values and a JSON Null value.
-        So it always succeed and return the newly created or existing value.
-
-        Remind that it may change types of parents according to tokens, so it 
-        potentially removes previously stored values. For example, if a document 
-        was an array, and "/foo" is used to create a value, then the document 
-        will be changed to an object, and all existing array elements are lost.
-
-        \param root Root value of a DOM subtree to be resolved. It can be any value other than document root.
-        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
-        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
-        \return The resolved newly created (a JSON Null value), or already exists value.
-    */
-    ValueType& Create(ValueType& root, typename ValueType::AllocatorType& allocator, bool* alreadyExist = 0) const {
-        RAPIDJSON_ASSERT(IsValid());
-        ValueType* v = &root;
-        bool exist = true;
-        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
-            if (v->IsArray() && t->name[0] == '-' && t->length == 1) {
-                v->PushBack(ValueType().Move(), allocator);
-                v = &((*v)[v->Size() - 1]);
-                exist = false;
-            }
-            else {
-                if (t->index == kPointerInvalidIndex) { // must be object name
-                    if (!v->IsObject())
-                        v->SetObject(); // Change to Object
-                }
-                else { // object name or array index
-                    if (!v->IsArray() && !v->IsObject())
-                        v->SetArray(); // Change to Array
-                }
-
-                if (v->IsArray()) {
-                    if (t->index >= v->Size()) {
-                        v->Reserve(t->index + 1, allocator);
-                        while (t->index >= v->Size())
-                            v->PushBack(ValueType().Move(), allocator);
-                        exist = false;
-                    }
-                    v = &((*v)[t->index]);
-                }
-                else {
-                    typename ValueType::MemberIterator m = v->FindMember(GenericValue<EncodingType>(GenericStringRef<Ch>(t->name, t->length)));
-                    if (m == v->MemberEnd()) {
-                        v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator);
-                        m = v->MemberEnd();
-                        v = &(--m)->value; // Assumes AddMember() appends at the end
-                        exist = false;
-                    }
-                    else
-                        v = &m->value;
-                }
-            }
-        }
-
-        if (alreadyExist)
-            *alreadyExist = exist;
-
-        return *v;
-    }
-
-    //! Creates a value in a document.
-    /*!
-        \param document A document to be resolved.
-        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
-        \return The resolved newly created, or already exists value.
-    */
-    template <typename stackAllocator>
-    ValueType& Create(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, bool* alreadyExist = 0) const {
-        return Create(document, document.GetAllocator(), alreadyExist);
-    }
-
-    //@}
-
-    //!@name Query value
-    //@{
-
-    //! Query a value in a subtree.
-    /*!
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \param unresolvedTokenIndex If the pointer cannot resolve a token in the pointer, this parameter can obtain the index of unresolved token.
-        \return Pointer to the value if it can be resolved. Otherwise null.
-
-        \note
-        There are only 3 situations when a value cannot be resolved:
-        1. A value in the path is not an array nor object.
-        2. An object value does not contain the token.
-        3. A token is out of range of an array value.
-
-        Use unresolvedTokenIndex to retrieve the token index.
-    */
-    ValueType* Get(ValueType& root, size_t* unresolvedTokenIndex = 0) const {
-        RAPIDJSON_ASSERT(IsValid());
-        ValueType* v = &root;
-        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
-            switch (v->GetType()) {
-            case kObjectType:
-                {
-                    typename ValueType::MemberIterator m = v->FindMember(GenericValue<EncodingType>(GenericStringRef<Ch>(t->name, t->length)));
-                    if (m == v->MemberEnd())
-                        break;
-                    v = &m->value;
-                }
-                continue;
-            case kArrayType:
-                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
-                    break;
-                v = &((*v)[t->index]);
-                continue;
-            default:
-                break;
-            }
-
-            // Error: unresolved token
-            if (unresolvedTokenIndex)
-                *unresolvedTokenIndex = static_cast<size_t>(t - tokens_);
-            return 0;
-        }
-        return v;
-    }
-
-    //! Query a const value in a const subtree.
-    /*!
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \return Pointer to the value if it can be resolved. Otherwise null.
-    */
-    const ValueType* Get(const ValueType& root, size_t* unresolvedTokenIndex = 0) const { 
-        return Get(const_cast<ValueType&>(root), unresolvedTokenIndex);
-    }
-
-    //@}
-
-    //!@name Query a value with default
-    //@{
-
-    //! Query a value in a subtree with default value.
-    /*!
-        Similar to Get(), but if the specified value do not exists, it creates all parents and clone the default value.
-        So that this function always succeed.
-
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \param defaultValue Default value to be cloned if the value was not exists.
-        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
-        \see Create()
-    */
-    ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const {
-        bool alreadyExist;
-        ValueType& v = Create(root, allocator, &alreadyExist);
-        return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
-    }
-
-    //! Query a value in a subtree with default null-terminated string.
-    ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const {
-        bool alreadyExist;
-        ValueType& v = Create(root, allocator, &alreadyExist);
-        return alreadyExist ? v : v.SetString(defaultValue, allocator);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Query a value in a subtree with default std::basic_string.
-    ValueType& GetWithDefault(ValueType& root, const std::basic_string<Ch>& defaultValue, typename ValueType::AllocatorType& allocator) const {
-        bool alreadyExist;
-        ValueType& v = Create(root, allocator, &alreadyExist);
-        return alreadyExist ? v : v.SetString(defaultValue, allocator);
-    }
-#endif
-
-    //! Query a value in a subtree with default primitive value.
-    /*!
-        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
-    GetWithDefault(ValueType& root, T defaultValue, typename ValueType::AllocatorType& allocator) const {
-        return GetWithDefault(root, ValueType(defaultValue).Move(), allocator);
-    }
-
-    //! Query a value in a document with default value.
-    template <typename stackAllocator>
-    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& defaultValue) const {
-        return GetWithDefault(document, defaultValue, document.GetAllocator());
-    }
-
-    //! Query a value in a document with default null-terminated string.
-    template <typename stackAllocator>
-    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* defaultValue) const {
-        return GetWithDefault(document, defaultValue, document.GetAllocator());
-    }
-    
-#if RAPIDJSON_HAS_STDSTRING
-    //! Query a value in a document with default std::basic_string.
-    template <typename stackAllocator>
-    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& defaultValue) const {
-        return GetWithDefault(document, defaultValue, document.GetAllocator());
-    }
-#endif
-
-    //! Query a value in a document with default primitive value.
-    /*!
-        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
-    */
-    template <typename T, typename stackAllocator>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
-    GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T defaultValue) const {
-        return GetWithDefault(document, defaultValue, document.GetAllocator());
-    }
-
-    //@}
-
-    //!@name Set a value
-    //@{
-
-    //! Set a value in a subtree, with move semantics.
-    /*!
-        It creates all parents if they are not exist or types are different to the tokens.
-        So this function always succeeds but potentially remove existing values.
-
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \param value Value to be set.
-        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
-        \see Create()
-    */
-    ValueType& Set(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
-        return Create(root, allocator) = value;
-    }
-
-    //! Set a value in a subtree, with copy semantics.
-    ValueType& Set(ValueType& root, const ValueType& value, typename ValueType::AllocatorType& allocator) const {
-        return Create(root, allocator).CopyFrom(value, allocator);
-    }
-
-    //! Set a null-terminated string in a subtree.
-    ValueType& Set(ValueType& root, const Ch* value, typename ValueType::AllocatorType& allocator) const {
-        return Create(root, allocator) = ValueType(value, allocator).Move();
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Set a std::basic_string in a subtree.
-    ValueType& Set(ValueType& root, const std::basic_string<Ch>& value, typename ValueType::AllocatorType& allocator) const {
-        return Create(root, allocator) = ValueType(value, allocator).Move();
-    }
-#endif
-
-    //! Set a primitive value in a subtree.
-    /*!
-        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
-    Set(ValueType& root, T value, typename ValueType::AllocatorType& allocator) const {
-        return Create(root, allocator) = ValueType(value).Move();
-    }
-
-    //! Set a value in a document, with move semantics.
-    template <typename stackAllocator>
-    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
-        return Create(document) = value;
-    }
-
-    //! Set a value in a document, with copy semantics.
-    template <typename stackAllocator>
-    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& value) const {
-        return Create(document).CopyFrom(value, document.GetAllocator());
-    }
-
-    //! Set a null-terminated string in a document.
-    template <typename stackAllocator>
-    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* value) const {
-        return Create(document) = ValueType(value, document.GetAllocator()).Move();
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Sets a std::basic_string in a document.
-    template <typename stackAllocator>
-    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& value) const {
-        return Create(document) = ValueType(value, document.GetAllocator()).Move();
-    }
-#endif
-
-    //! Set a primitive value in a document.
-    /*!
-    \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
-    */
-    template <typename T, typename stackAllocator>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
-        Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T value) const {
-            return Create(document) = value;
-    }
-
-    //@}
-
-    //!@name Swap a value
-    //@{
-
-    //! Swap a value with a value in a subtree.
-    /*!
-        It creates all parents if they are not exist or types are different to the tokens.
-        So this function always succeeds but potentially remove existing values.
-
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \param value Value to be swapped.
-        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
-        \see Create()
-    */
-    ValueType& Swap(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
-        return Create(root, allocator).Swap(value);
-    }
-
-    //! Swap a value with a value in a document.
-    template <typename stackAllocator>
-    ValueType& Swap(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
-        return Create(document).Swap(value);
-    }
-
-    //@}
-
-    //! Erase a value in a subtree.
-    /*!
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \return Whether the resolved value is found and erased.
-
-        \note Erasing with an empty pointer \c Pointer(""), i.e. the root, always fail and return false.
-    */
-    bool Erase(ValueType& root) const {
-        RAPIDJSON_ASSERT(IsValid());
-        if (tokenCount_ == 0) // Cannot erase the root
-            return false;
-
-        ValueType* v = &root;
-        const Token* last = tokens_ + (tokenCount_ - 1);
-        for (const Token *t = tokens_; t != last; ++t) {
-            switch (v->GetType()) {
-            case kObjectType:
-                {
-                    typename ValueType::MemberIterator m = v->FindMember(GenericValue<EncodingType>(GenericStringRef<Ch>(t->name, t->length)));
-                    if (m == v->MemberEnd())
-                        return false;
-                    v = &m->value;
-                }
-                break;
-            case kArrayType:
-                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
-                    return false;
-                v = &((*v)[t->index]);
-                break;
-            default:
-                return false;
-            }
-        }
-
-        switch (v->GetType()) {
-        case kObjectType:
-            return v->EraseMember(GenericStringRef<Ch>(last->name, last->length));
-        case kArrayType:
-            if (last->index == kPointerInvalidIndex || last->index >= v->Size())
-                return false;
-            v->Erase(v->Begin() + last->index);
-            return true;
-        default:
-            return false;
-        }
-    }
-
-private:
-    //! Clone the content from rhs to this.
-    /*!
-        \param rhs Source pointer.
-        \param extraToken Extra tokens to be allocated.
-        \param extraNameBufferSize Extra name buffer size (in number of Ch) to be allocated.
-        \return Start of non-occupied name buffer, for storing extra names.
-    */
-    Ch* CopyFromRaw(const GenericPointer& rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0) {
-        if (!allocator_) // allocator is independently owned.
-            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-
-        size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens
-        for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t)
-            nameBufferSize += t->length;
-
-        tokenCount_ = rhs.tokenCount_ + extraToken;
-        tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + (nameBufferSize + extraNameBufferSize) * sizeof(Ch)));
-        nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
-        if (rhs.tokenCount_ > 0) {
-            std::memcpy(tokens_, rhs.tokens_, rhs.tokenCount_ * sizeof(Token));
-        }
-        if (nameBufferSize > 0) {
-            std::memcpy(nameBuffer_, rhs.nameBuffer_, nameBufferSize * sizeof(Ch));
-        }
-
-        // Adjust pointers to name buffer
-        std::ptrdiff_t diff = nameBuffer_ - rhs.nameBuffer_;
-        for (Token *t = tokens_; t != tokens_ + rhs.tokenCount_; ++t)
-            t->name += diff;
-
-        return nameBuffer_ + nameBufferSize;
-    }
-
-    //! Check whether a character should be percent-encoded.
-    /*!
-        According to RFC 3986 2.3 Unreserved Characters.
-        \param c The character (code unit) to be tested.
-    */
-    bool NeedPercentEncode(Ch c) const {
-        return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~');
-    }
-
-    //! Parse a JSON String or its URI fragment representation into tokens.
-#ifndef __clang__ // -Wdocumentation
-    /*!
-        \param source Either a JSON Pointer string, or its URI fragment representation. Not need to be null terminated.
-        \param length Length of the source string.
-        \note Source cannot be JSON String Representation of JSON Pointer, e.g. In "/\u0000", \u0000 will not be unescaped.
-    */
-#endif
-    void Parse(const Ch* source, size_t length) {
-        RAPIDJSON_ASSERT(source != NULL);
-        RAPIDJSON_ASSERT(nameBuffer_ == 0);
-        RAPIDJSON_ASSERT(tokens_ == 0);
-
-        // Create own allocator if user did not supply.
-        if (!allocator_)
-            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-
-        // Count number of '/' as tokenCount
-        tokenCount_ = 0;
-        for (const Ch* s = source; s != source + length; s++) 
-            if (*s == '/')
-                tokenCount_++;
-
-        Token* token = tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + length * sizeof(Ch)));
-        Ch* name = nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
-        size_t i = 0;
-
-        // Detect if it is a URI fragment
-        bool uriFragment = false;
-        if (source[i] == '#') {
-            uriFragment = true;
-            i++;
-        }
-
-        if (i != length && source[i] != '/') {
-            parseErrorCode_ = kPointerParseErrorTokenMustBeginWithSolidus;
-            goto error;
-        }
-
-        while (i < length) {
-            RAPIDJSON_ASSERT(source[i] == '/');
-            i++; // consumes '/'
-
-            token->name = name;
-            bool isNumber = true;
-
-            while (i < length && source[i] != '/') {
-                Ch c = source[i];
-                if (uriFragment) {
-                    // Decoding percent-encoding for URI fragment
-                    if (c == '%') {
-                        PercentDecodeStream is(&source[i], source + length);
-                        GenericInsituStringStream<EncodingType> os(name);
-                        Ch* begin = os.PutBegin();
-                        if (!Transcoder<UTF8<>, EncodingType>().Validate(is, os) || !is.IsValid()) {
-                            parseErrorCode_ = kPointerParseErrorInvalidPercentEncoding;
-                            goto error;
-                        }
-                        size_t len = os.PutEnd(begin);
-                        i += is.Tell() - 1;
-                        if (len == 1)
-                            c = *name;
-                        else {
-                            name += len;
-                            isNumber = false;
-                            i++;
-                            continue;
-                        }
-                    }
-                    else if (NeedPercentEncode(c)) {
-                        parseErrorCode_ = kPointerParseErrorCharacterMustPercentEncode;
-                        goto error;
-                    }
-                }
-
-                i++;
-                
-                // Escaping "~0" -> '~', "~1" -> '/'
-                if (c == '~') {
-                    if (i < length) {
-                        c = source[i];
-                        if (c == '0')       c = '~';
-                        else if (c == '1')  c = '/';
-                        else {
-                            parseErrorCode_ = kPointerParseErrorInvalidEscape;
-                            goto error;
-                        }
-                        i++;
-                    }
-                    else {
-                        parseErrorCode_ = kPointerParseErrorInvalidEscape;
-                        goto error;
-                    }
-                }
-
-                // First check for index: all of characters are digit
-                if (c < '0' || c > '9')
-                    isNumber = false;
-
-                *name++ = c;
-            }
-            token->length = static_cast<SizeType>(name - token->name);
-            if (token->length == 0)
-                isNumber = false;
-            *name++ = '\0'; // Null terminator
-
-            // Second check for index: more than one digit cannot have leading zero
-            if (isNumber && token->length > 1 && token->name[0] == '0')
-                isNumber = false;
-
-            // String to SizeType conversion
-            SizeType n = 0;
-            if (isNumber) {
-                for (size_t j = 0; j < token->length; j++) {
-                    SizeType m = n * 10 + static_cast<SizeType>(token->name[j] - '0');
-                    if (m < n) {   // overflow detection
-                        isNumber = false;
-                        break;
-                    }
-                    n = m;
-                }
-            }
-
-            token->index = isNumber ? n : kPointerInvalidIndex;
-            token++;
-        }
-
-        RAPIDJSON_ASSERT(name <= nameBuffer_ + length); // Should not overflow buffer
-        parseErrorCode_ = kPointerParseErrorNone;
-        return;
-
-    error:
-        Allocator::Free(tokens_);
-        nameBuffer_ = 0;
-        tokens_ = 0;
-        tokenCount_ = 0;
-        parseErrorOffset_ = i;
-        return;
-    }
-
-    //! Stringify to string or URI fragment representation.
-    /*!
-        \tparam uriFragment True for stringifying to URI fragment representation. False for string representation.
-        \tparam OutputStream type of output stream.
-        \param os The output stream.
-    */
-    template<bool uriFragment, typename OutputStream>
-    bool Stringify(OutputStream& os) const {
-        RAPIDJSON_ASSERT(IsValid());
-
-        if (uriFragment)
-            os.Put('#');
-
-        for (Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
-            os.Put('/');
-            for (size_t j = 0; j < t->length; j++) {
-                Ch c = t->name[j];
-                if (c == '~') {
-                    os.Put('~');
-                    os.Put('0');
-                }
-                else if (c == '/') {
-                    os.Put('~');
-                    os.Put('1');
-                }
-                else if (uriFragment && NeedPercentEncode(c)) { 
-                    // Transcode to UTF8 sequence
-                    GenericStringStream<typename ValueType::EncodingType> source(&t->name[j]);
-                    PercentEncodeStream<OutputStream> target(os);
-                    if (!Transcoder<EncodingType, UTF8<> >().Validate(source, target))
-                        return false;
-                    j += source.Tell() - 1;
-                }
-                else
-                    os.Put(c);
-            }
-        }
-        return true;
-    }
-
-    //! A helper stream for decoding a percent-encoded sequence into code unit.
-    /*!
-        This stream decodes %XY triplet into code unit (0-255).
-        If it encounters invalid characters, it sets output code unit as 0 and 
-        mark invalid, and to be checked by IsValid().
-    */
-    class PercentDecodeStream {
-    public:
-        typedef typename ValueType::Ch Ch;
-
-        //! Constructor
-        /*!
-            \param source Start of the stream
-            \param end Past-the-end of the stream.
-        */
-        PercentDecodeStream(const Ch* source, const Ch* end) : src_(source), head_(source), end_(end), valid_(true) {}
-
-        Ch Take() {
-            if (*src_ != '%' || src_ + 3 > end_) { // %XY triplet
-                valid_ = false;
-                return 0;
-            }
-            src_++;
-            Ch c = 0;
-            for (int j = 0; j < 2; j++) {
-                c = static_cast<Ch>(c << 4);
-                Ch h = *src_;
-                if      (h >= '0' && h <= '9') c = static_cast<Ch>(c + h - '0');
-                else if (h >= 'A' && h <= 'F') c = static_cast<Ch>(c + h - 'A' + 10);
-                else if (h >= 'a' && h <= 'f') c = static_cast<Ch>(c + h - 'a' + 10);
-                else {
-                    valid_ = false;
-                    return 0;
-                }
-                src_++;
-            }
-            return c;
-        }
-
-        size_t Tell() const { return static_cast<size_t>(src_ - head_); }
-        bool IsValid() const { return valid_; }
-
-    private:
-        const Ch* src_;     //!< Current read position.
-        const Ch* head_;    //!< Original head of the string.
-        const Ch* end_;     //!< Past-the-end position.
-        bool valid_;        //!< Whether the parsing is valid.
-    };
-
-    //! A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence.
-    template <typename OutputStream>
-    class PercentEncodeStream {
-    public:
-        PercentEncodeStream(OutputStream& os) : os_(os) {}
-        void Put(char c) { // UTF-8 must be byte
-            unsigned char u = static_cast<unsigned char>(c);
-            static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-            os_.Put('%');
-            os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u >> 4]));
-            os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u & 15]));
-        }
-    private:
-        OutputStream& os_;
-    };
-
-    Allocator* allocator_;                  //!< The current allocator. It is either user-supplied or equal to ownAllocator_.
-    Allocator* ownAllocator_;               //!< Allocator owned by this Pointer.
-    Ch* nameBuffer_;                        //!< A buffer containing all names in tokens.
-    Token* tokens_;                         //!< A list of tokens.
-    size_t tokenCount_;                     //!< Number of tokens in tokens_.
-    size_t parseErrorOffset_;               //!< Offset in code unit when parsing fail.
-    PointerParseErrorCode parseErrorCode_;  //!< Parsing error code.
-};
-
-//! GenericPointer for Value (UTF-8, default allocator).
-typedef GenericPointer<Value> Pointer;
-
-//!@name Helper functions for GenericPointer
-//@{
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType& CreateValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::AllocatorType& a) {
-    return pointer.Create(root, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType& CreateValueByPointer(T& root, const CharType(&source)[N], typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Create(root, a);
-}
-
-// No allocator parameter
-
-template <typename DocumentType>
-typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer) {
-    return pointer.Create(document);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const CharType(&source)[N]) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Create(document);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType* GetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, size_t* unresolvedTokenIndex = 0) {
-    return pointer.Get(root, unresolvedTokenIndex);
-}
-
-template <typename T>
-const typename T::ValueType* GetValueByPointer(const T& root, const GenericPointer<typename T::ValueType>& pointer, size_t* unresolvedTokenIndex = 0) {
-    return pointer.Get(root, unresolvedTokenIndex);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType* GetValueByPointer(T& root, const CharType (&source)[N], size_t* unresolvedTokenIndex = 0) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
-}
-
-template <typename T, typename CharType, size_t N>
-const typename T::ValueType* GetValueByPointer(const T& root, const CharType(&source)[N], size_t* unresolvedTokenIndex = 0) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
-    return pointer.GetWithDefault(root, defaultValue, a);
-}
-
-template <typename T>
-typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
-    return pointer.GetWithDefault(root, defaultValue, a);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename T>
-typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
-    return pointer.GetWithDefault(root, defaultValue, a);
-}
-#endif
-
-template <typename T, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
-GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 defaultValue, typename T::AllocatorType& a) {
-    return pointer.GetWithDefault(root, defaultValue, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename T, typename CharType, size_t N>
-typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
-}
-#endif
-
-template <typename T, typename CharType, size_t N, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
-GetValueByPointerWithDefault(T& root, const CharType(&source)[N], T2 defaultValue, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
-}
-
-// No allocator parameter
-
-template <typename DocumentType>
-typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& defaultValue) {
-    return pointer.GetWithDefault(document, defaultValue);
-}
-
-template <typename DocumentType>
-typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* defaultValue) {
-    return pointer.GetWithDefault(document, defaultValue);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename DocumentType>
-typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& defaultValue) {
-    return pointer.GetWithDefault(document, defaultValue);
-}
-#endif
-
-template <typename DocumentType, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
-GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 defaultValue) {
-    return pointer.GetWithDefault(document, defaultValue);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& defaultValue) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* defaultValue) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& defaultValue) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
-}
-#endif
-
-template <typename DocumentType, typename CharType, size_t N, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
-GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], T2 defaultValue) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
-    return pointer.Set(root, value, a);
-}
-
-template <typename T>
-typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& value, typename T::AllocatorType& a) {
-    return pointer.Set(root, value, a);
-}
-
-template <typename T>
-typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* value, typename T::AllocatorType& a) {
-    return pointer.Set(root, value, a);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename T>
-typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
-    return pointer.Set(root, value, a);
-}
-#endif
-
-template <typename T, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
-SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 value, typename T::AllocatorType& a) {
-    return pointer.Set(root, value, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::ValueType& value, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::Ch* value, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename T, typename CharType, size_t N>
-typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-#endif
-
-template <typename T, typename CharType, size_t N, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
-SetValueByPointer(T& root, const CharType(&source)[N], T2 value, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-
-// No allocator parameter
-
-template <typename DocumentType>
-typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
-    return pointer.Set(document, value);
-}
-
-template <typename DocumentType>
-typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& value) {
-    return pointer.Set(document, value);
-}
-
-template <typename DocumentType>
-typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* value) {
-    return pointer.Set(document, value);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename DocumentType>
-typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& value) {
-    return pointer.Set(document, value);
-}
-#endif
-
-template <typename DocumentType, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
-SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 value) {
-    return pointer.Set(document, value);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& value) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* value) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& value) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-#endif
-
-template <typename DocumentType, typename CharType, size_t N, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
-SetValueByPointer(DocumentType& document, const CharType(&source)[N], T2 value) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType& SwapValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
-    return pointer.Swap(root, value, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType& SwapValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Swap(root, value, a);
-}
-
-template <typename DocumentType>
-typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
-    return pointer.Swap(document, value);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
-    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Swap(document, value);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-bool EraseValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer) {
-    return pointer.Erase(root);
-}
-
-template <typename T, typename CharType, size_t N>
-bool EraseValueByPointer(T& root, const CharType(&source)[N]) {
-    return GenericPointer<typename T::ValueType>(source, N - 1).Erase(root);
-}
-
-//@}
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__) || defined(_MSC_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_POINTER_H_
diff --git a/thirdparty/rapidjson/prettywriter.h b/thirdparty/rapidjson/prettywriter.h
deleted file mode 100644
index fe45df1..0000000
--- a/thirdparty/rapidjson/prettywriter.h
+++ /dev/null
@@ -1,277 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_PRETTYWRITER_H_
-#define RAPIDJSON_PRETTYWRITER_H_
-
-#include "writer.h"
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Combination of PrettyWriter format flags.
-/*! \see PrettyWriter::SetFormatOptions
- */
-enum PrettyFormatOptions {
-    kFormatDefault = 0,         //!< Default pretty formatting.
-    kFormatSingleLineArray = 1  //!< Format arrays on a single line.
-};
-
-//! Writer with indentation and spacing.
-/*!
-    \tparam OutputStream Type of output os.
-    \tparam SourceEncoding Encoding of source string.
-    \tparam TargetEncoding Encoding of output stream.
-    \tparam StackAllocator Type of allocator for allocating memory of stack.
-*/
-template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
-class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> {
-public:
-    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base;
-    typedef typename Base::Ch Ch;
-
-    //! Constructor
-    /*! \param os Output stream.
-        \param allocator User supplied allocator. If it is null, it will create a private one.
-        \param levelDepth Initial capacity of stack.
-    */
-    explicit PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
-        Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
-
-
-    explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
-        Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    PrettyWriter(PrettyWriter&& rhs) :
-        Base(std::forward<PrettyWriter>(rhs)), indentChar_(rhs.indentChar_), indentCharCount_(rhs.indentCharCount_), formatOptions_(rhs.formatOptions_) {}
-#endif
-
-    //! Set custom indentation.
-    /*! \param indentChar       Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
-        \param indentCharCount  Number of indent characters for each indentation level.
-        \note The default indentation is 4 spaces.
-    */
-    PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) {
-        RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
-        indentChar_ = indentChar;
-        indentCharCount_ = indentCharCount;
-        return *this;
-    }
-
-    //! Set pretty writer formatting options.
-    /*! \param options Formatting options.
-    */
-    PrettyWriter& SetFormatOptions(PrettyFormatOptions options) {
-        formatOptions_ = options;
-        return *this;
-    }
-
-    /*! @name Implementation of Handler
-        \see Handler
-    */
-    //@{
-
-    bool Null()                 { PrettyPrefix(kNullType);   return Base::EndValue(Base::WriteNull()); }
-    bool Bool(bool b)           { PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); }
-    bool Int(int i)             { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); }
-    bool Uint(unsigned u)       { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); }
-    bool Int64(int64_t i64)     { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); }
-    bool Uint64(uint64_t u64)   { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64));  }
-    bool Double(double d)       { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); }
-
-    bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
-        RAPIDJSON_ASSERT(str != 0);
-        (void)copy;
-        PrettyPrefix(kNumberType);
-        return Base::EndValue(Base::WriteString(str, length));
-    }
-
-    bool String(const Ch* str, SizeType length, bool copy = false) {
-        RAPIDJSON_ASSERT(str != 0);
-        (void)copy;
-        PrettyPrefix(kStringType);
-        return Base::EndValue(Base::WriteString(str, length));
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool String(const std::basic_string<Ch>& str) {
-        return String(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool StartObject() {
-        PrettyPrefix(kObjectType);
-        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
-        return Base::WriteStartObject();
-    }
-
-    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool Key(const std::basic_string<Ch>& str) {
-        return Key(str.data(), SizeType(str.size()));
-    }
-#endif
-	
-    bool EndObject(SizeType memberCount = 0) {
-        (void)memberCount;
-        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object
-        RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray); // currently inside an Array, not Object
-        RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top<typename Base::Level>()->valueCount % 2); // Object has a Key without a Value
-       
-        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
-
-        if (!empty) {
-            Base::os_->Put('\n');
-            WriteIndent();
-        }
-        bool ret = Base::EndValue(Base::WriteEndObject());
-        (void)ret;
-        RAPIDJSON_ASSERT(ret == true);
-        if (Base::level_stack_.Empty()) // end of json text
-            Base::Flush();
-        return true;
-    }
-
-    bool StartArray() {
-        PrettyPrefix(kArrayType);
-        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
-        return Base::WriteStartArray();
-    }
-
-    bool EndArray(SizeType memberCount = 0) {
-        (void)memberCount;
-        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
-        RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
-        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
-
-        if (!empty && !(formatOptions_ & kFormatSingleLineArray)) {
-            Base::os_->Put('\n');
-            WriteIndent();
-        }
-        bool ret = Base::EndValue(Base::WriteEndArray());
-        (void)ret;
-        RAPIDJSON_ASSERT(ret == true);
-        if (Base::level_stack_.Empty()) // end of json text
-            Base::Flush();
-        return true;
-    }
-
-    //@}
-
-    /*! @name Convenience extensions */
-    //@{
-
-    //! Simpler but slower overload.
-    bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
-    bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
-
-    //@}
-
-    //! Write a raw JSON value.
-    /*!
-        For user to write a stringified JSON as a value.
-
-        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
-        \param length Length of the json.
-        \param type Type of the root of json.
-        \note When using PrettyWriter::RawValue(), the result json may not be indented correctly.
-    */
-    bool RawValue(const Ch* json, size_t length, Type type) {
-        RAPIDJSON_ASSERT(json != 0);
-        PrettyPrefix(type);
-        return Base::EndValue(Base::WriteRawValue(json, length));
-    }
-
-protected:
-    void PrettyPrefix(Type type) {
-        (void)type;
-        if (Base::level_stack_.GetSize() != 0) { // this value is not at root
-            typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();
-
-            if (level->inArray) {
-                if (level->valueCount > 0) {
-                    Base::os_->Put(','); // add comma if it is not the first element in array
-                    if (formatOptions_ & kFormatSingleLineArray)
-                        Base::os_->Put(' ');
-                }
-
-                if (!(formatOptions_ & kFormatSingleLineArray)) {
-                    Base::os_->Put('\n');
-                    WriteIndent();
-                }
-            }
-            else {  // in object
-                if (level->valueCount > 0) {
-                    if (level->valueCount % 2 == 0) {
-                        Base::os_->Put(',');
-                        Base::os_->Put('\n');
-                    }
-                    else {
-                        Base::os_->Put(':');
-                        Base::os_->Put(' ');
-                    }
-                }
-                else
-                    Base::os_->Put('\n');
-
-                if (level->valueCount % 2 == 0)
-                    WriteIndent();
-            }
-            if (!level->inArray && level->valueCount % 2 == 0)
-                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
-            level->valueCount++;
-        }
-        else {
-            RAPIDJSON_ASSERT(!Base::hasRoot_);  // Should only has one and only one root.
-            Base::hasRoot_ = true;
-        }
-    }
-
-    void WriteIndent()  {
-        size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
-        PutN(*Base::os_, static_cast<typename OutputStream::Ch>(indentChar_), count);
-    }
-
-    Ch indentChar_;
-    unsigned indentCharCount_;
-    PrettyFormatOptions formatOptions_;
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    PrettyWriter(const PrettyWriter&);
-    PrettyWriter& operator=(const PrettyWriter&);
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/thirdparty/rapidjson/rapidjson.h b/thirdparty/rapidjson/rapidjson.h
deleted file mode 100644
index a4e8953..0000000
--- a/thirdparty/rapidjson/rapidjson.h
+++ /dev/null
@@ -1,741 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_RAPIDJSON_H_
-#define RAPIDJSON_RAPIDJSON_H_
-
-/*!\file rapidjson.h
-    \brief common definitions and configuration
-    
-    \see RAPIDJSON_CONFIG
- */
-
-/*! \defgroup RAPIDJSON_CONFIG RapidJSON configuration
-    \brief Configuration macros for library features
-
-    Some RapidJSON features are configurable to adapt the library to a wide
-    variety of platforms, environments and usage scenarios.  Most of the
-    features can be configured in terms of overridden or predefined
-    preprocessor macros at compile-time.
-
-    Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs.
-
-    \note These macros should be given on the compiler command-line
-          (where applicable)  to avoid inconsistent values when compiling
-          different translation units of a single application.
- */
-
-#include <cstdlib>  // malloc(), realloc(), free(), size_t
-#include <cstring>  // memset(), memcpy(), memmove(), memcmp()
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_VERSION_STRING
-//
-// ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt.
-//
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-// token stringification
-#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x)
-#define RAPIDJSON_DO_STRINGIFY(x) #x
-
-// token concatenation
-#define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y)
-#define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y)
-#define RAPIDJSON_DO_JOIN2(X, Y) X##Y
-//!@endcond
-
-/*! \def RAPIDJSON_MAJOR_VERSION
-    \ingroup RAPIDJSON_CONFIG
-    \brief Major version of RapidJSON in integer.
-*/
-/*! \def RAPIDJSON_MINOR_VERSION
-    \ingroup RAPIDJSON_CONFIG
-    \brief Minor version of RapidJSON in integer.
-*/
-/*! \def RAPIDJSON_PATCH_VERSION
-    \ingroup RAPIDJSON_CONFIG
-    \brief Patch version of RapidJSON in integer.
-*/
-/*! \def RAPIDJSON_VERSION_STRING
-    \ingroup RAPIDJSON_CONFIG
-    \brief Version of RapidJSON in "<major>.<minor>.<patch>" string format.
-*/
-#define RAPIDJSON_MAJOR_VERSION 1
-#define RAPIDJSON_MINOR_VERSION 1
-#define RAPIDJSON_PATCH_VERSION 0
-#define RAPIDJSON_VERSION_STRING \
-    RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION)
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NAMESPACE_(BEGIN|END)
-/*! \def RAPIDJSON_NAMESPACE
-    \ingroup RAPIDJSON_CONFIG
-    \brief   provide custom rapidjson namespace
-
-    In order to avoid symbol clashes and/or "One Definition Rule" errors
-    between multiple inclusions of (different versions of) RapidJSON in
-    a single binary, users can customize the name of the main RapidJSON
-    namespace.
-
-    In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE
-    to a custom name (e.g. \c MyRapidJSON) is sufficient.  If multiple
-    levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref
-    RAPIDJSON_NAMESPACE_END need to be defined as well:
-
-    \code
-    // in some .cpp file
-    #define RAPIDJSON_NAMESPACE my::rapidjson
-    #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {
-    #define RAPIDJSON_NAMESPACE_END   } }
-    #include "rapidjson/..."
-    \endcode
-
-    \see rapidjson
- */
-/*! \def RAPIDJSON_NAMESPACE_BEGIN
-    \ingroup RAPIDJSON_CONFIG
-    \brief   provide custom rapidjson namespace (opening expression)
-    \see RAPIDJSON_NAMESPACE
-*/
-/*! \def RAPIDJSON_NAMESPACE_END
-    \ingroup RAPIDJSON_CONFIG
-    \brief   provide custom rapidjson namespace (closing expression)
-    \see RAPIDJSON_NAMESPACE
-*/
-#ifndef RAPIDJSON_NAMESPACE
-#define RAPIDJSON_NAMESPACE rapidjson
-#endif
-#ifndef RAPIDJSON_NAMESPACE_BEGIN
-#define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE {
-#endif
-#ifndef RAPIDJSON_NAMESPACE_END
-#define RAPIDJSON_NAMESPACE_END }
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// __cplusplus macro
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-
-#if defined(_MSC_VER)
-#define RAPIDJSON_CPLUSPLUS _MSVC_LANG
-#else
-#define RAPIDJSON_CPLUSPLUS __cplusplus
-#endif
-
-//!@endcond
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_HAS_STDSTRING
-
-#ifndef RAPIDJSON_HAS_STDSTRING
-#ifdef RAPIDJSON_DOXYGEN_RUNNING
-#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation
-#else
-#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default
-#endif
-/*! \def RAPIDJSON_HAS_STDSTRING
-    \ingroup RAPIDJSON_CONFIG
-    \brief Enable RapidJSON support for \c std::string
-
-    By defining this preprocessor symbol to \c 1, several convenience functions for using
-    \ref rapidjson::GenericValue with \c std::string are enabled, especially
-    for construction and comparison.
-
-    \hideinitializer
-*/
-#endif // !defined(RAPIDJSON_HAS_STDSTRING)
-
-#if RAPIDJSON_HAS_STDSTRING
-#include <string>
-#endif // RAPIDJSON_HAS_STDSTRING
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_USE_MEMBERSMAP
-
-/*! \def RAPIDJSON_USE_MEMBERSMAP
-    \ingroup RAPIDJSON_CONFIG
-    \brief Enable RapidJSON support for object members handling in a \c std::multimap
-
-    By defining this preprocessor symbol to \c 1, \ref rapidjson::GenericValue object
-    members are stored in a \c std::multimap for faster lookup and deletion times, a
-    trade off with a slightly slower insertion time and a small object allocat(or)ed
-    memory overhead.
-
-    \hideinitializer
-*/
-#ifndef RAPIDJSON_USE_MEMBERSMAP
-#define RAPIDJSON_USE_MEMBERSMAP 0 // not by default
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NO_INT64DEFINE
-
-/*! \def RAPIDJSON_NO_INT64DEFINE
-    \ingroup RAPIDJSON_CONFIG
-    \brief Use external 64-bit integer types.
-
-    RapidJSON requires the 64-bit integer types \c int64_t and  \c uint64_t types
-    to be available at global scope.
-
-    If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to
-    prevent RapidJSON from defining its own types.
-*/
-#ifndef RAPIDJSON_NO_INT64DEFINE
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#if defined(_MSC_VER) && (_MSC_VER < 1800)	// Visual Studio 2013
-#include "msinttypes/stdint.h"
-#include "msinttypes/inttypes.h"
-#else
-// Other compilers should have this.
-#include <stdint.h>
-#include <inttypes.h>
-#endif
-//!@endcond
-#ifdef RAPIDJSON_DOXYGEN_RUNNING
-#define RAPIDJSON_NO_INT64DEFINE
-#endif
-#endif // RAPIDJSON_NO_INT64TYPEDEF
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_FORCEINLINE
-
-#ifndef RAPIDJSON_FORCEINLINE
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#if defined(_MSC_VER) && defined(NDEBUG)
-#define RAPIDJSON_FORCEINLINE __forceinline
-#elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG)
-#define RAPIDJSON_FORCEINLINE __attribute__((always_inline))
-#else
-#define RAPIDJSON_FORCEINLINE
-#endif
-//!@endcond
-#endif // RAPIDJSON_FORCEINLINE
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ENDIAN
-#define RAPIDJSON_LITTLEENDIAN  0   //!< Little endian machine
-#define RAPIDJSON_BIGENDIAN     1   //!< Big endian machine
-
-//! Endianness of the machine.
-/*!
-    \def RAPIDJSON_ENDIAN
-    \ingroup RAPIDJSON_CONFIG
-
-    GCC 4.6 provided macro for detecting endianness of the target machine. But other
-    compilers may not have this. User can define RAPIDJSON_ENDIAN to either
-    \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN.
-
-    Default detection implemented with reference to
-    \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html
-    \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp
-*/
-#ifndef RAPIDJSON_ENDIAN
-// Detect with GCC 4.6's macro
-#  ifdef __BYTE_ORDER__
-#    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-#    else
-#      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
-#    endif // __BYTE_ORDER__
-// Detect with GLIBC's endian.h
-#  elif defined(__GLIBC__)
-#    include <endian.h>
-#    if (__BYTE_ORDER == __LITTLE_ENDIAN)
-#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#    elif (__BYTE_ORDER == __BIG_ENDIAN)
-#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-#    else
-#      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
-#   endif // __GLIBC__
-// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
-#  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#  elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-// Detect with architecture macros
-#  elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-#  elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#  elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
-#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#  elif defined(RAPIDJSON_DOXYGEN_RUNNING)
-#    define RAPIDJSON_ENDIAN
-#  else
-#    error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.   
-#  endif
-#endif // RAPIDJSON_ENDIAN
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_64BIT
-
-//! Whether using 64-bit architecture
-#ifndef RAPIDJSON_64BIT
-#if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__)
-#define RAPIDJSON_64BIT 1
-#else
-#define RAPIDJSON_64BIT 0
-#endif
-#endif // RAPIDJSON_64BIT
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ALIGN
-
-//! Data alignment of the machine.
-/*! \ingroup RAPIDJSON_CONFIG
-    \param x pointer to align
-
-    Some machines require strict data alignment. The default is 8 bytes.
-    User can customize by defining the RAPIDJSON_ALIGN function macro.
-*/
-#ifndef RAPIDJSON_ALIGN
-#define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_UINT64_C2
-
-//! Construct a 64-bit literal by a pair of 32-bit integer.
-/*!
-    64-bit literal with or without ULL suffix is prone to compiler warnings.
-    UINT64_C() is C macro which cause compilation problems.
-    Use this macro to define 64-bit constants by a pair of 32-bit integer.
-*/
-#ifndef RAPIDJSON_UINT64_C2
-#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_48BITPOINTER_OPTIMIZATION
-
-//! Use only lower 48-bit address for some pointers.
-/*!
-    \ingroup RAPIDJSON_CONFIG
-
-    This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address.
-    The higher 16-bit can be used for storing other data.
-    \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture.
-*/
-#ifndef RAPIDJSON_48BITPOINTER_OPTIMIZATION
-#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
-#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 1
-#else
-#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 0
-#endif
-#endif // RAPIDJSON_48BITPOINTER_OPTIMIZATION
-
-#if RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1
-#if RAPIDJSON_64BIT != 1
-#error RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when RAPIDJSON_64BIT=1
-#endif
-#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x))))
-#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
-#else
-#define RAPIDJSON_SETPOINTER(type, p, x) (p = (x))
-#define RAPIDJSON_GETPOINTER(type, p) (p)
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_NEON/RAPIDJSON_SIMD
-
-/*! \def RAPIDJSON_SIMD
-    \ingroup RAPIDJSON_CONFIG
-    \brief Enable SSE2/SSE4.2/Neon optimization.
-
-    RapidJSON supports optimized implementations for some parsing operations
-    based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel
-    or ARM compatible processors.
-
-    To enable these optimizations, three different symbols can be defined;
-    \code
-    // Enable SSE2 optimization.
-    #define RAPIDJSON_SSE2
-
-    // Enable SSE4.2 optimization.
-    #define RAPIDJSON_SSE42
-    \endcode
-
-    // Enable ARM Neon optimization.
-    #define RAPIDJSON_NEON
-    \endcode
-
-    \c RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined.
-
-    If any of these symbols is defined, RapidJSON defines the macro
-    \c RAPIDJSON_SIMD to indicate the availability of the optimized code.
-*/
-#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \
-    || defined(RAPIDJSON_NEON) || defined(RAPIDJSON_DOXYGEN_RUNNING)
-#define RAPIDJSON_SIMD
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NO_SIZETYPEDEFINE
-
-#ifndef RAPIDJSON_NO_SIZETYPEDEFINE
-/*! \def RAPIDJSON_NO_SIZETYPEDEFINE
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-provided \c SizeType definition.
-
-    In order to avoid using 32-bit size types for indexing strings and arrays,
-    define this preprocessor symbol and provide the type rapidjson::SizeType
-    before including RapidJSON:
-    \code
-    #define RAPIDJSON_NO_SIZETYPEDEFINE
-    namespace rapidjson { typedef ::std::size_t SizeType; }
-    #include "rapidjson/..."
-    \endcode
-
-    \see rapidjson::SizeType
-*/
-#ifdef RAPIDJSON_DOXYGEN_RUNNING
-#define RAPIDJSON_NO_SIZETYPEDEFINE
-#endif
-RAPIDJSON_NAMESPACE_BEGIN
-//! Size type (for string lengths, array sizes, etc.)
-/*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,
-    instead of using \c size_t. Users may override the SizeType by defining
-    \ref RAPIDJSON_NO_SIZETYPEDEFINE.
-*/
-typedef unsigned SizeType;
-RAPIDJSON_NAMESPACE_END
-#endif
-
-// always import std::size_t to rapidjson namespace
-RAPIDJSON_NAMESPACE_BEGIN
-using std::size_t;
-RAPIDJSON_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ASSERT
-
-//! Assertion.
-/*! \ingroup RAPIDJSON_CONFIG
-    By default, rapidjson uses C \c assert() for internal assertions.
-    User can override it by defining RAPIDJSON_ASSERT(x) macro.
-
-    \note Parsing errors are handled and can be customized by the
-          \ref RAPIDJSON_ERRORS APIs.
-*/
-#ifndef RAPIDJSON_ASSERT
-#include <cassert>
-#define RAPIDJSON_ASSERT(x) assert(x)
-#endif // RAPIDJSON_ASSERT
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_STATIC_ASSERT
-
-// Prefer C++11 static_assert, if available
-#ifndef RAPIDJSON_STATIC_ASSERT
-#if RAPIDJSON_CPLUSPLUS >= 201103L || ( defined(_MSC_VER) && _MSC_VER >= 1800 )
-#define RAPIDJSON_STATIC_ASSERT(x) \
-   static_assert(x, RAPIDJSON_STRINGIFY(x))
-#endif // C++11
-#endif // RAPIDJSON_STATIC_ASSERT
-
-// Adopt C++03 implementation from boost
-#ifndef RAPIDJSON_STATIC_ASSERT
-#ifndef __clang__
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#endif
-RAPIDJSON_NAMESPACE_BEGIN
-template <bool x> struct STATIC_ASSERTION_FAILURE;
-template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
-template <size_t x> struct StaticAssertTest {};
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__GNUC__) || defined(__clang__)
-#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
-#else
-#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE 
-#endif
-#ifndef __clang__
-//!@endcond
-#endif
-
-/*! \def RAPIDJSON_STATIC_ASSERT
-    \brief (Internal) macro to check for conditions at compile-time
-    \param x compile-time condition
-    \hideinitializer
- */
-#define RAPIDJSON_STATIC_ASSERT(x) \
-    typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \
-      sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
-    RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
-#endif // RAPIDJSON_STATIC_ASSERT
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY
-
-//! Compiler branching hint for expression with high probability to be true.
-/*!
-    \ingroup RAPIDJSON_CONFIG
-    \param x Boolean expression likely to be true.
-*/
-#ifndef RAPIDJSON_LIKELY
-#if defined(__GNUC__) || defined(__clang__)
-#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
-#else
-#define RAPIDJSON_LIKELY(x) (x)
-#endif
-#endif
-
-//! Compiler branching hint for expression with low probability to be true.
-/*!
-    \ingroup RAPIDJSON_CONFIG
-    \param x Boolean expression unlikely to be true.
-*/
-#ifndef RAPIDJSON_UNLIKELY
-#if defined(__GNUC__) || defined(__clang__)
-#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
-#else
-#define RAPIDJSON_UNLIKELY(x) (x)
-#endif
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// Helpers
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-
-#define RAPIDJSON_MULTILINEMACRO_BEGIN do {  
-#define RAPIDJSON_MULTILINEMACRO_END \
-} while((void)0, 0)
-
-// adopted from Boost
-#define RAPIDJSON_VERSION_CODE(x,y,z) \
-  (((x)*100000) + ((y)*100) + (z))
-
-#if defined(__has_builtin)
-#define RAPIDJSON_HAS_BUILTIN(x) __has_builtin(x)
-#else
-#define RAPIDJSON_HAS_BUILTIN(x) 0
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF
-
-#if defined(__GNUC__)
-#define RAPIDJSON_GNUC \
-    RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
-#endif
-
-#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0))
-
-#define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x))
-#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x)
-#define RAPIDJSON_DIAG_OFF(x) \
-    RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x)))
-
-// push/pop support in Clang and GCC>=4.6
-#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0))
-#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
-#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
-#else // GCC >= 4.2, < 4.6
-#define RAPIDJSON_DIAG_PUSH /* ignored */
-#define RAPIDJSON_DIAG_POP /* ignored */
-#endif
-
-#elif defined(_MSC_VER)
-
-// pragma (MSVC specific)
-#define RAPIDJSON_PRAGMA(x) __pragma(x)
-#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x))
-
-#define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x)
-#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
-#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
-
-#else
-
-#define RAPIDJSON_DIAG_OFF(x) /* ignored */
-#define RAPIDJSON_DIAG_PUSH   /* ignored */
-#define RAPIDJSON_DIAG_POP    /* ignored */
-
-#endif // RAPIDJSON_DIAG_*
-
-///////////////////////////////////////////////////////////////////////////////
-// C++11 features
-
-#ifndef RAPIDJSON_HAS_CXX11
-#define RAPIDJSON_HAS_CXX11 (RAPIDJSON_CPLUSPLUS >= 201103L)
-#endif
-
-#ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
-#if RAPIDJSON_HAS_CXX11
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
-#elif defined(__clang__)
-#if __has_feature(cxx_rvalue_references) && \
-    (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
-#else
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
-#endif
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
-      (defined(_MSC_VER) && _MSC_VER >= 1600) || \
-      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
-
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
-#else
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
-#endif
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-#include <utility> // std::move
-#endif
-
-#ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
-#if RAPIDJSON_HAS_CXX11
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
-#elif defined(__clang__)
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
-    (defined(_MSC_VER) && _MSC_VER >= 1900) || \
-    (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
-#else
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
-#endif
-#endif
-#ifndef RAPIDJSON_NOEXCEPT
-#if RAPIDJSON_HAS_CXX11_NOEXCEPT
-#define RAPIDJSON_NOEXCEPT noexcept
-#else
-#define RAPIDJSON_NOEXCEPT throw()
-#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
-#endif
-
-// no automatic detection, yet
-#ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
-#if (defined(_MSC_VER) && _MSC_VER >= 1700)
-#define RAPIDJSON_HAS_CXX11_TYPETRAITS 1
-#else
-#define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
-#endif
-#endif
-
-#ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR
-#if defined(__clang__)
-#define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
-      (defined(_MSC_VER) && _MSC_VER >= 1700) || \
-      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
-#define RAPIDJSON_HAS_CXX11_RANGE_FOR 1
-#else
-#define RAPIDJSON_HAS_CXX11_RANGE_FOR 0
-#endif
-#endif // RAPIDJSON_HAS_CXX11_RANGE_FOR
-
-///////////////////////////////////////////////////////////////////////////////
-// C++17 features
-
-#ifndef RAPIDJSON_HAS_CXX17
-#define RAPIDJSON_HAS_CXX17 (RAPIDJSON_CPLUSPLUS >= 201703L)
-#endif
-
-#if RAPIDJSON_HAS_CXX17
-# define RAPIDJSON_DELIBERATE_FALLTHROUGH [[fallthrough]]
-#elif defined(__has_cpp_attribute)
-# if __has_cpp_attribute(clang::fallthrough)
-#  define RAPIDJSON_DELIBERATE_FALLTHROUGH [[clang::fallthrough]]
-# elif __has_cpp_attribute(fallthrough)
-#  define RAPIDJSON_DELIBERATE_FALLTHROUGH __attribute__((fallthrough))
-# else
-#  define RAPIDJSON_DELIBERATE_FALLTHROUGH
-# endif
-#else
-# define RAPIDJSON_DELIBERATE_FALLTHROUGH
-#endif
-
-//!@endcond
-
-//! Assertion (in non-throwing contexts).
- /*! \ingroup RAPIDJSON_CONFIG
-    Some functions provide a \c noexcept guarantee, if the compiler supports it.
-    In these cases, the \ref RAPIDJSON_ASSERT macro cannot be overridden to
-    throw an exception.  This macro adds a separate customization point for
-    such cases.
-
-    Defaults to C \c assert() (as \ref RAPIDJSON_ASSERT), if \c noexcept is
-    supported, and to \ref RAPIDJSON_ASSERT otherwise.
- */
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NOEXCEPT_ASSERT
-
-#ifndef RAPIDJSON_NOEXCEPT_ASSERT
-#ifdef RAPIDJSON_ASSERT_THROWS
-#include <cassert>
-#define RAPIDJSON_NOEXCEPT_ASSERT(x) assert(x)
-#else
-#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
-#endif // RAPIDJSON_ASSERT_THROWS
-#endif // RAPIDJSON_NOEXCEPT_ASSERT
-
-///////////////////////////////////////////////////////////////////////////////
-// malloc/realloc/free
-
-#ifndef RAPIDJSON_MALLOC
-///! customization point for global \c malloc
-#define RAPIDJSON_MALLOC(size) std::malloc(size)
-#endif
-#ifndef RAPIDJSON_REALLOC
-///! customization point for global \c realloc
-#define RAPIDJSON_REALLOC(ptr, new_size) std::realloc(ptr, new_size)
-#endif
-#ifndef RAPIDJSON_FREE
-///! customization point for global \c free
-#define RAPIDJSON_FREE(ptr) std::free(ptr)
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// new/delete
-
-#ifndef RAPIDJSON_NEW
-///! customization point for global \c new
-#define RAPIDJSON_NEW(TypeName) new TypeName
-#endif
-#ifndef RAPIDJSON_DELETE
-///! customization point for global \c delete
-#define RAPIDJSON_DELETE(x) delete x
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// Type
-
-/*! \namespace rapidjson
-    \brief main RapidJSON namespace
-    \see RAPIDJSON_NAMESPACE
-*/
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Type of JSON value
-enum Type {
-    kNullType = 0,      //!< null
-    kFalseType = 1,     //!< false
-    kTrueType = 2,      //!< true
-    kObjectType = 3,    //!< object
-    kArrayType = 4,     //!< array 
-    kStringType = 5,    //!< string
-    kNumberType = 6     //!< number
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/thirdparty/rapidjson/reader.h b/thirdparty/rapidjson/reader.h
deleted file mode 100644
index 09ace4e..0000000
--- a/thirdparty/rapidjson/reader.h
+++ /dev/null
@@ -1,2244 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_READER_H_
-#define RAPIDJSON_READER_H_
-
-/*! \file reader.h */
-
-#include "allocators.h"
-#include "stream.h"
-#include "encodedstream.h"
-#include "internal/clzll.h"
-#include "internal/meta.h"
-#include "internal/stack.h"
-#include "internal/strtod.h"
-#include <limits>
-
-#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
-#include <intrin.h>
-#pragma intrinsic(_BitScanForward)
-#endif
-#ifdef RAPIDJSON_SSE42
-#include <nmmintrin.h>
-#elif defined(RAPIDJSON_SSE2)
-#include <emmintrin.h>
-#elif defined(RAPIDJSON_NEON)
-#include <arm_neon.h>
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(old-style-cast)
-RAPIDJSON_DIAG_OFF(padded)
-RAPIDJSON_DIAG_OFF(switch-enum)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127)  // conditional expression is constant
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#define RAPIDJSON_NOTHING /* deliberately empty */
-#ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN
-#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \
-    RAPIDJSON_MULTILINEMACRO_BEGIN \
-    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
-    RAPIDJSON_MULTILINEMACRO_END
-#endif
-#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \
-    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
-//!@endcond
-
-/*! \def RAPIDJSON_PARSE_ERROR_NORETURN
-    \ingroup RAPIDJSON_ERRORS
-    \brief Macro to indicate a parse error.
-    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
-    \param offset  position of the error in JSON input (\c size_t)
-
-    This macros can be used as a customization point for the internal
-    error handling mechanism of RapidJSON.
-
-    A common usage model is to throw an exception instead of requiring the
-    caller to explicitly check the \ref rapidjson::GenericReader::Parse's
-    return value:
-
-    \code
-    #define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \
-       throw ParseException(parseErrorCode, #parseErrorCode, offset)
-
-    #include <stdexcept>               // std::runtime_error
-    #include "rapidjson/error/error.h" // rapidjson::ParseResult
-
-    struct ParseException : std::runtime_error, rapidjson::ParseResult {
-      ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset)
-        : std::runtime_error(msg), ParseResult(code, offset) {}
-    };
-
-    #include "rapidjson/reader.h"
-    \endcode
-
-    \see RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse
- */
-#ifndef RAPIDJSON_PARSE_ERROR_NORETURN
-#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \
-    RAPIDJSON_MULTILINEMACRO_BEGIN \
-    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
-    SetParseError(parseErrorCode, offset); \
-    RAPIDJSON_MULTILINEMACRO_END
-#endif
-
-/*! \def RAPIDJSON_PARSE_ERROR
-    \ingroup RAPIDJSON_ERRORS
-    \brief (Internal) macro to indicate and handle a parse error.
-    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
-    \param offset  position of the error in JSON input (\c size_t)
-
-    Invokes RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing.
-
-    \see RAPIDJSON_PARSE_ERROR_NORETURN
-    \hideinitializer
- */
-#ifndef RAPIDJSON_PARSE_ERROR
-#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \
-    RAPIDJSON_MULTILINEMACRO_BEGIN \
-    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
-    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
-    RAPIDJSON_MULTILINEMACRO_END
-#endif
-
-#include "error/error.h" // ParseErrorCode, ParseResult
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// ParseFlag
-
-/*! \def RAPIDJSON_PARSE_DEFAULT_FLAGS
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-defined kParseDefaultFlags definition.
-
-    User can define this as any \c ParseFlag combinations.
-*/
-#ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS
-#define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags
-#endif
-
-//! Combination of parseFlags
-/*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream
- */
-enum ParseFlag {
-    kParseNoFlags = 0,              //!< No flags are set.
-    kParseInsituFlag = 1,           //!< In-situ(destructive) parsing.
-    kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings.
-    kParseIterativeFlag = 4,        //!< Iterative(constant complexity in terms of function call stack size) parsing.
-    kParseStopWhenDoneFlag = 8,     //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error.
-    kParseFullPrecisionFlag = 16,   //!< Parse number in full precision (but slower).
-    kParseCommentsFlag = 32,        //!< Allow one-line (//) and multi-line (/**/) comments.
-    kParseNumbersAsStringsFlag = 64,    //!< Parse all numbers (ints/doubles) as strings.
-    kParseTrailingCommasFlag = 128, //!< Allow trailing commas at the end of objects and arrays.
-    kParseNanAndInfFlag = 256,      //!< Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
-    kParseEscapedApostropheFlag = 512,  //!< Allow escaped apostrophe in strings.
-    kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS  //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Handler
-
-/*! \class rapidjson::Handler
-    \brief Concept for receiving events from GenericReader upon parsing.
-    The functions return true if no error occurs. If they return false,
-    the event publisher should terminate the process.
-\code
-concept Handler {
-    typename Ch;
-
-    bool Null();
-    bool Bool(bool b);
-    bool Int(int i);
-    bool Uint(unsigned i);
-    bool Int64(int64_t i);
-    bool Uint64(uint64_t i);
-    bool Double(double d);
-    /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
-    bool RawNumber(const Ch* str, SizeType length, bool copy);
-    bool String(const Ch* str, SizeType length, bool copy);
-    bool StartObject();
-    bool Key(const Ch* str, SizeType length, bool copy);
-    bool EndObject(SizeType memberCount);
-    bool StartArray();
-    bool EndArray(SizeType elementCount);
-};
-\endcode
-*/
-///////////////////////////////////////////////////////////////////////////////
-// BaseReaderHandler
-
-//! Default implementation of Handler.
-/*! This can be used as base class of any reader handler.
-    \note implements Handler concept
-*/
-template<typename Encoding = UTF8<>, typename Derived = void>
-struct BaseReaderHandler {
-    typedef typename Encoding::Ch Ch;
-
-    typedef typename internal::SelectIf<internal::IsSame<Derived, void>, BaseReaderHandler, Derived>::Type Override;
-
-    bool Default() { return true; }
-    bool Null() { return static_cast<Override&>(*this).Default(); }
-    bool Bool(bool) { return static_cast<Override&>(*this).Default(); }
-    bool Int(int) { return static_cast<Override&>(*this).Default(); }
-    bool Uint(unsigned) { return static_cast<Override&>(*this).Default(); }
-    bool Int64(int64_t) { return static_cast<Override&>(*this).Default(); }
-    bool Uint64(uint64_t) { return static_cast<Override&>(*this).Default(); }
-    bool Double(double) { return static_cast<Override&>(*this).Default(); }
-    /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
-    bool RawNumber(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
-    bool String(const Ch*, SizeType, bool) { return static_cast<Override&>(*this).Default(); }
-    bool StartObject() { return static_cast<Override&>(*this).Default(); }
-    bool Key(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
-    bool EndObject(SizeType) { return static_cast<Override&>(*this).Default(); }
-    bool StartArray() { return static_cast<Override&>(*this).Default(); }
-    bool EndArray(SizeType) { return static_cast<Override&>(*this).Default(); }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// StreamLocalCopy
-
-namespace internal {
-
-template<typename Stream, int = StreamTraits<Stream>::copyOptimization>
-class StreamLocalCopy;
-
-//! Do copy optimization.
-template<typename Stream>
-class StreamLocalCopy<Stream, 1> {
-public:
-    StreamLocalCopy(Stream& original) : s(original), original_(original) {}
-    ~StreamLocalCopy() { original_ = s; }
-
-    Stream s;
-
-private:
-    StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
-
-    Stream& original_;
-};
-
-//! Keep reference.
-template<typename Stream>
-class StreamLocalCopy<Stream, 0> {
-public:
-    StreamLocalCopy(Stream& original) : s(original) {}
-
-    Stream& s;
-
-private:
-    StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
-};
-
-} // namespace internal
-
-///////////////////////////////////////////////////////////////////////////////
-// SkipWhitespace
-
-//! Skip the JSON white spaces in a stream.
-/*! \param is A input stream for skipping white spaces.
-    \note This function has SSE2/SSE4.2 specialization.
-*/
-template<typename InputStream>
-void SkipWhitespace(InputStream& is) {
-    internal::StreamLocalCopy<InputStream> copy(is);
-    InputStream& s(copy.s);
-
-    typename InputStream::Ch c;
-    while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t')
-        s.Take();
-}
-
-inline const char* SkipWhitespace(const char* p, const char* end) {
-    while (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
-        ++p;
-    return p;
-}
-
-#ifdef RAPIDJSON_SSE42
-//! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once.
-inline const char *SkipWhitespace_SIMD(const char* p) {
-    // Fast return for single non-whitespace
-    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-        ++p;
-    else
-        return p;
-
-    // 16-byte align to the next boundary
-    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-    while (p != nextAligned)
-        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-            ++p;
-        else
-            return p;
-
-    // The rest of string using SIMD
-    static const char whitespace[16] = " \n\r\t";
-    const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
-
-    for (;; p += 16) {
-        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-        const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
-        if (r != 16)    // some of characters is non-whitespace
-            return p + r;
-    }
-}
-
-inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
-    // Fast return for single non-whitespace
-    if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
-        ++p;
-    else
-        return p;
-
-    // The middle of string using SIMD
-    static const char whitespace[16] = " \n\r\t";
-    const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
-
-    for (; p <= end - 16; p += 16) {
-        const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
-        const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
-        if (r != 16)    // some of characters is non-whitespace
-            return p + r;
-    }
-
-    return SkipWhitespace(p, end);
-}
-
-#elif defined(RAPIDJSON_SSE2)
-
-//! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once.
-inline const char *SkipWhitespace_SIMD(const char* p) {
-    // Fast return for single non-whitespace
-    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-        ++p;
-    else
-        return p;
-
-    // 16-byte align to the next boundary
-    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-    while (p != nextAligned)
-        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-            ++p;
-        else
-            return p;
-
-    // The rest of string
-    #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
-    static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
-    #undef C16
-
-    const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
-    const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
-    const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
-    const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
-
-    for (;; p += 16) {
-        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-        __m128i x = _mm_cmpeq_epi8(s, w0);
-        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
-        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
-        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
-        unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
-        if (r != 0) {   // some of characters may be non-whitespace
-#ifdef _MSC_VER         // Find the index of first non-whitespace
-            unsigned long offset;
-            _BitScanForward(&offset, r);
-            return p + offset;
-#else
-            return p + __builtin_ffs(r) - 1;
-#endif
-        }
-    }
-}
-
-inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
-    // Fast return for single non-whitespace
-    if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
-        ++p;
-    else
-        return p;
-
-    // The rest of string
-    #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
-    static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
-    #undef C16
-
-    const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
-    const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
-    const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
-    const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
-
-    for (; p <= end - 16; p += 16) {
-        const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
-        __m128i x = _mm_cmpeq_epi8(s, w0);
-        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
-        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
-        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
-        unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
-        if (r != 0) {   // some of characters may be non-whitespace
-#ifdef _MSC_VER         // Find the index of first non-whitespace
-            unsigned long offset;
-            _BitScanForward(&offset, r);
-            return p + offset;
-#else
-            return p + __builtin_ffs(r) - 1;
-#endif
-        }
-    }
-
-    return SkipWhitespace(p, end);
-}
-
-#elif defined(RAPIDJSON_NEON)
-
-//! Skip whitespace with ARM Neon instructions, testing 16 8-byte characters at once.
-inline const char *SkipWhitespace_SIMD(const char* p) {
-    // Fast return for single non-whitespace
-    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-        ++p;
-    else
-        return p;
-
-    // 16-byte align to the next boundary
-    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-    while (p != nextAligned)
-        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-            ++p;
-        else
-            return p;
-
-    const uint8x16_t w0 = vmovq_n_u8(' ');
-    const uint8x16_t w1 = vmovq_n_u8('\n');
-    const uint8x16_t w2 = vmovq_n_u8('\r');
-    const uint8x16_t w3 = vmovq_n_u8('\t');
-
-    for (;; p += 16) {
-        const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
-        uint8x16_t x = vceqq_u8(s, w0);
-        x = vorrq_u8(x, vceqq_u8(s, w1));
-        x = vorrq_u8(x, vceqq_u8(s, w2));
-        x = vorrq_u8(x, vceqq_u8(s, w3));
-
-        x = vmvnq_u8(x);                       // Negate
-        x = vrev64q_u8(x);                     // Rev in 64
-        uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
-        uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
-
-        if (low == 0) {
-            if (high != 0) {
-                uint32_t lz = internal::clzll(high);
-                return p + 8 + (lz >> 3);
-            }
-        } else {
-            uint32_t lz = internal::clzll(low);
-            return p + (lz >> 3);
-        }
-    }
-}
-
-inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
-    // Fast return for single non-whitespace
-    if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
-        ++p;
-    else
-        return p;
-
-    const uint8x16_t w0 = vmovq_n_u8(' ');
-    const uint8x16_t w1 = vmovq_n_u8('\n');
-    const uint8x16_t w2 = vmovq_n_u8('\r');
-    const uint8x16_t w3 = vmovq_n_u8('\t');
-
-    for (; p <= end - 16; p += 16) {
-        const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
-        uint8x16_t x = vceqq_u8(s, w0);
-        x = vorrq_u8(x, vceqq_u8(s, w1));
-        x = vorrq_u8(x, vceqq_u8(s, w2));
-        x = vorrq_u8(x, vceqq_u8(s, w3));
-
-        x = vmvnq_u8(x);                       // Negate
-        x = vrev64q_u8(x);                     // Rev in 64
-        uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
-        uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
-
-        if (low == 0) {
-            if (high != 0) {
-                uint32_t lz = internal::clzll(high);
-                return p + 8 + (lz >> 3);
-            }
-        } else {
-            uint32_t lz = internal::clzll(low);
-            return p + (lz >> 3);
-        }
-    }
-
-    return SkipWhitespace(p, end);
-}
-
-#endif // RAPIDJSON_NEON
-
-#ifdef RAPIDJSON_SIMD
-//! Template function specialization for InsituStringStream
-template<> inline void SkipWhitespace(InsituStringStream& is) {
-    is.src_ = const_cast<char*>(SkipWhitespace_SIMD(is.src_));
-}
-
-//! Template function specialization for StringStream
-template<> inline void SkipWhitespace(StringStream& is) {
-    is.src_ = SkipWhitespace_SIMD(is.src_);
-}
-
-template<> inline void SkipWhitespace(EncodedInputStream<UTF8<>, MemoryStream>& is) {
-    is.is_.src_ = SkipWhitespace_SIMD(is.is_.src_, is.is_.end_);
-}
-#endif // RAPIDJSON_SIMD
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericReader
-
-//! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator.
-/*! GenericReader parses JSON text from a stream, and send events synchronously to an
-    object implementing Handler concept.
-
-    It needs to allocate a stack for storing a single decoded string during
-    non-destructive parsing.
-
-    For in-situ parsing, the decoded string is directly written to the source
-    text string, no temporary buffer is required.
-
-    A GenericReader object can be reused for parsing multiple JSON text.
-
-    \tparam SourceEncoding Encoding of the input stream.
-    \tparam TargetEncoding Encoding of the parse output.
-    \tparam StackAllocator Allocator type for stack.
-*/
-template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>
-class GenericReader {
-public:
-    typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type
-
-    //! Constructor.
-    /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
-        \param stackCapacity stack capacity in bytes for storing a single decoded string.  (Only use for non-destructive parsing)
-    */
-    GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) :
-        stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
-
-    //! Parse JSON text.
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \tparam InputStream Type of input stream, implementing Stream concept.
-        \tparam Handler Type of handler, implementing Handler concept.
-        \param is Input stream to be parsed.
-        \param handler The handler to receive events.
-        \return Whether the parsing is successful.
-    */
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    ParseResult Parse(InputStream& is, Handler& handler) {
-        if (parseFlags & kParseIterativeFlag)
-            return IterativeParse<parseFlags>(is, handler);
-
-        parseResult_.Clear();
-
-        ClearStackOnExit scope(*this);
-
-        SkipWhitespaceAndComments<parseFlags>(is);
-        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-
-        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) {
-            RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-        }
-        else {
-            ParseValue<parseFlags>(is, handler);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-
-            if (!(parseFlags & kParseStopWhenDoneFlag)) {
-                SkipWhitespaceAndComments<parseFlags>(is);
-                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-
-                if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) {
-                    RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
-                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-                }
-            }
-        }
-
-        return parseResult_;
-    }
-
-    //! Parse JSON text (with \ref kParseDefaultFlags)
-    /*! \tparam InputStream Type of input stream, implementing Stream concept
-        \tparam Handler Type of handler, implementing Handler concept.
-        \param is Input stream to be parsed.
-        \param handler The handler to receive events.
-        \return Whether the parsing is successful.
-    */
-    template <typename InputStream, typename Handler>
-    ParseResult Parse(InputStream& is, Handler& handler) {
-        return Parse<kParseDefaultFlags>(is, handler);
-    }
-
-    //! Initialize JSON text token-by-token parsing
-    /*!
-     */
-    void IterativeParseInit() {
-        parseResult_.Clear();
-        state_ = IterativeParsingStartState;
-    }
-
-    //! Parse one token from JSON text
-    /*! \tparam InputStream Type of input stream, implementing Stream concept
-        \tparam Handler Type of handler, implementing Handler concept.
-        \param is Input stream to be parsed.
-        \param handler The handler to receive events.
-        \return Whether the parsing is successful.
-     */
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    bool IterativeParseNext(InputStream& is, Handler& handler) {
-        while (RAPIDJSON_LIKELY(is.Peek() != '\0')) {
-            SkipWhitespaceAndComments<parseFlags>(is);
-
-            Token t = Tokenize(is.Peek());
-            IterativeParsingState n = Predict(state_, t);
-            IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
-
-            // If we've finished or hit an error...
-            if (RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d))) {
-                // Report errors.
-                if (d == IterativeParsingErrorState) {
-                    HandleError(state_, is);
-                    return false;
-                }
-
-                // Transition to the finish state.
-                RAPIDJSON_ASSERT(d == IterativeParsingFinishState);
-                state_ = d;
-
-                // If StopWhenDone is not set...
-                if (!(parseFlags & kParseStopWhenDoneFlag)) {
-                    // ... and extra non-whitespace data is found...
-                    SkipWhitespaceAndComments<parseFlags>(is);
-                    if (is.Peek() != '\0') {
-                        // ... this is considered an error.
-                        HandleError(state_, is);
-                        return false;
-                    }
-                }
-
-                // Success! We are done!
-                return true;
-            }
-
-            // Transition to the new state.
-            state_ = d;
-
-            // If we parsed anything other than a delimiter, we invoked the handler, so we can return true now.
-            if (!IsIterativeParsingDelimiterState(n))
-                return true;
-        }
-
-        // We reached the end of file.
-        stack_.Clear();
-
-        if (state_ != IterativeParsingFinishState) {
-            HandleError(state_, is);
-            return false;
-        }
-
-        return true;
-    }
-
-    //! Check if token-by-token parsing JSON text is complete
-    /*! \return Whether the JSON has been fully decoded.
-     */
-    RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const {
-        return IsIterativeParsingCompleteState(state_);
-    }
-
-    //! Whether a parse error has occurred in the last parsing.
-    bool HasParseError() const { return parseResult_.IsError(); }
-
-    //! Get the \ref ParseErrorCode of last parsing.
-    ParseErrorCode GetParseErrorCode() const { return parseResult_.Code(); }
-
-    //! Get the position of last parsing error in input, 0 otherwise.
-    size_t GetErrorOffset() const { return parseResult_.Offset(); }
-
-protected:
-    void SetParseError(ParseErrorCode code, size_t offset) { parseResult_.Set(code, offset); }
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    GenericReader(const GenericReader&);
-    GenericReader& operator=(const GenericReader&);
-
-    void ClearStack() { stack_.Clear(); }
-
-    // clear stack on any exit from ParseStream, e.g. due to exception
-    struct ClearStackOnExit {
-        explicit ClearStackOnExit(GenericReader& r) : r_(r) {}
-        ~ClearStackOnExit() { r_.ClearStack(); }
-    private:
-        GenericReader& r_;
-        ClearStackOnExit(const ClearStackOnExit&);
-        ClearStackOnExit& operator=(const ClearStackOnExit&);
-    };
-
-    template<unsigned parseFlags, typename InputStream>
-    void SkipWhitespaceAndComments(InputStream& is) {
-        SkipWhitespace(is);
-
-        if (parseFlags & kParseCommentsFlag) {
-            while (RAPIDJSON_UNLIKELY(Consume(is, '/'))) {
-                if (Consume(is, '*')) {
-                    while (true) {
-                        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
-                            RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
-                        else if (Consume(is, '*')) {
-                            if (Consume(is, '/'))
-                                break;
-                        }
-                        else
-                            is.Take();
-                    }
-                }
-                else if (RAPIDJSON_LIKELY(Consume(is, '/')))
-                    while (is.Peek() != '\0' && is.Take() != '\n') {}
-                else
-                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
-
-                SkipWhitespace(is);
-            }
-        }
-    }
-
-    // Parse object: { string : value, ... }
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseObject(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == '{');
-        is.Take();  // Skip '{'
-
-        if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-
-        SkipWhitespaceAndComments<parseFlags>(is);
-        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-        if (Consume(is, '}')) {
-            if (RAPIDJSON_UNLIKELY(!handler.EndObject(0)))  // empty object
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-            return;
-        }
-
-        for (SizeType memberCount = 0;;) {
-            if (RAPIDJSON_UNLIKELY(is.Peek() != '"'))
-                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
-
-            ParseString<parseFlags>(is, handler, true);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            SkipWhitespaceAndComments<parseFlags>(is);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            if (RAPIDJSON_UNLIKELY(!Consume(is, ':')))
-                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
-
-            SkipWhitespaceAndComments<parseFlags>(is);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            ParseValue<parseFlags>(is, handler);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            SkipWhitespaceAndComments<parseFlags>(is);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            ++memberCount;
-
-            switch (is.Peek()) {
-                case ',':
-                    is.Take();
-                    SkipWhitespaceAndComments<parseFlags>(is);
-                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-                    break;
-                case '}':
-                    is.Take();
-                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
-                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-                    return;
-                default:
-                    RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy
-            }
-
-            if (parseFlags & kParseTrailingCommasFlag) {
-                if (is.Peek() == '}') {
-                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
-                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-                    is.Take();
-                    return;
-                }
-            }
-        }
-    }
-
-    // Parse array: [ value, ... ]
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseArray(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == '[');
-        is.Take();  // Skip '['
-
-        if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-
-        SkipWhitespaceAndComments<parseFlags>(is);
-        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-        if (Consume(is, ']')) {
-            if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-            return;
-        }
-
-        for (SizeType elementCount = 0;;) {
-            ParseValue<parseFlags>(is, handler);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            ++elementCount;
-            SkipWhitespaceAndComments<parseFlags>(is);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            if (Consume(is, ',')) {
-                SkipWhitespaceAndComments<parseFlags>(is);
-                RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-            }
-            else if (Consume(is, ']')) {
-                if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
-                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-                return;
-            }
-            else
-                RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
-
-            if (parseFlags & kParseTrailingCommasFlag) {
-                if (is.Peek() == ']') {
-                    if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
-                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-                    is.Take();
-                    return;
-                }
-            }
-        }
-    }
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseNull(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == 'n');
-        is.Take();
-
-        if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) {
-            if (RAPIDJSON_UNLIKELY(!handler.Null()))
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        }
-        else
-            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
-    }
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseTrue(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == 't');
-        is.Take();
-
-        if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) {
-            if (RAPIDJSON_UNLIKELY(!handler.Bool(true)))
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        }
-        else
-            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
-    }
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseFalse(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == 'f');
-        is.Take();
-
-        if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) {
-            if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        }
-        else
-            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
-    }
-
-    template<typename InputStream>
-    RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) {
-        if (RAPIDJSON_LIKELY(is.Peek() == expect)) {
-            is.Take();
-            return true;
-        }
-        else
-            return false;
-    }
-
-    // Helper function to parse four hexadecimal digits in \uXXXX in ParseString().
-    template<typename InputStream>
-    unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
-        unsigned codepoint = 0;
-        for (int i = 0; i < 4; i++) {
-            Ch c = is.Peek();
-            codepoint <<= 4;
-            codepoint += static_cast<unsigned>(c);
-            if (c >= '0' && c <= '9')
-                codepoint -= '0';
-            else if (c >= 'A' && c <= 'F')
-                codepoint -= 'A' - 10;
-            else if (c >= 'a' && c <= 'f')
-                codepoint -= 'a' - 10;
-            else {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
-                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
-            }
-            is.Take();
-        }
-        return codepoint;
-    }
-
-    template <typename CharType>
-    class StackStream {
-    public:
-        typedef CharType Ch;
-
-        StackStream(internal::Stack<StackAllocator>& stack) : stack_(stack), length_(0) {}
-        RAPIDJSON_FORCEINLINE void Put(Ch c) {
-            *stack_.template Push<Ch>() = c;
-            ++length_;
-        }
-
-        RAPIDJSON_FORCEINLINE void* Push(SizeType count) {
-            length_ += count;
-            return stack_.template Push<Ch>(count);
-        }
-
-        size_t Length() const { return length_; }
-
-        Ch* Pop() {
-            return stack_.template Pop<Ch>(length_);
-        }
-
-    private:
-        StackStream(const StackStream&);
-        StackStream& operator=(const StackStream&);
-
-        internal::Stack<StackAllocator>& stack_;
-        SizeType length_;
-    };
-
-    // Parse string and generate String event. Different code paths for kParseInsituFlag.
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
-        internal::StreamLocalCopy<InputStream> copy(is);
-        InputStream& s(copy.s);
-
-        RAPIDJSON_ASSERT(s.Peek() == '\"');
-        s.Take();  // Skip '\"'
-
-        bool success = false;
-        if (parseFlags & kParseInsituFlag) {
-            typename InputStream::Ch *head = s.PutBegin();
-            ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-            size_t length = s.PutEnd(head) - 1;
-            RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
-            const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
-            success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
-        }
-        else {
-            StackStream<typename TargetEncoding::Ch> stackStream(stack_);
-            ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-            SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
-            const typename TargetEncoding::Ch* const str = stackStream.Pop();
-            success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
-        }
-        if (RAPIDJSON_UNLIKELY(!success))
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
-    }
-
-    // Parse string to an output is
-    // This function handles the prefix/suffix double quotes, escaping, and optional encoding validation.
-    template<unsigned parseFlags, typename SEncoding, typename TEncoding, typename InputStream, typename OutputStream>
-    RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-        static const char escape[256] = {
-            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
-            Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
-            0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
-            0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
-        };
-#undef Z16
-//!@endcond
-
-        for (;;) {
-            // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
-            if (!(parseFlags & kParseValidateEncodingFlag))
-                ScanCopyUnescapedString(is, os);
-
-            Ch c = is.Peek();
-            if (RAPIDJSON_UNLIKELY(c == '\\')) {    // Escape
-                size_t escapeOffset = is.Tell();    // For invalid escaping, report the initial '\\' as error offset
-                is.Take();
-                Ch e = is.Peek();
-                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
-                    is.Take();
-                    os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
-                }
-                else if ((parseFlags & kParseEscapedApostropheFlag) && RAPIDJSON_LIKELY(e == '\'')) { // Allow escaped apostrophe
-                    is.Take();
-                    os.Put('\'');
-                }
-                else if (RAPIDJSON_LIKELY(e == 'u')) {    // Unicode
-                    is.Take();
-                    unsigned codepoint = ParseHex4(is, escapeOffset);
-                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-                    if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDFFF)) {
-                        // high surrogate, check if followed by valid low surrogate
-                        if (RAPIDJSON_LIKELY(codepoint <= 0xDBFF)) {
-                            // Handle UTF-16 surrogate pair
-                            if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
-                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
-                            unsigned codepoint2 = ParseHex4(is, escapeOffset);
-                            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-                            if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
-                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
-                            codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
-                        }
-                        // single low surrogate
-                        else
-                        {
-                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
-                        }
-                    }
-                    TEncoding::Encode(os, codepoint);
-                }
-                else
-                    RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
-            }
-            else if (RAPIDJSON_UNLIKELY(c == '"')) {    // Closing double quote
-                is.Take();
-                os.Put('\0');   // null-terminate the string
-                return;
-            }
-            else if (RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
-                if (c == '\0')
-                    RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
-                else
-                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
-            }
-            else {
-                size_t offset = is.Tell();
-                if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
-                    !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
-                    !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
-                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
-            }
-        }
-    }
-
-    template<typename InputStream, typename OutputStream>
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InputStream&, OutputStream&) {
-            // Do nothing for generic version
-    }
-
-#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
-    // StringStream -> StackStream<char>
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
-        const char* p = is.src_;
-
-        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-        while (p != nextAligned)
-            if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
-                is.src_ = p;
-                return;
-            }
-            else
-                os.Put(*p++);
-
-        // The rest of string using SIMD
-        static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
-        static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
-        static const char space[16]  = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
-        const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
-        const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
-        const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
-
-        for (;; p += 16) {
-            const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-            const __m128i t1 = _mm_cmpeq_epi8(s, dq);
-            const __m128i t2 = _mm_cmpeq_epi8(s, bs);
-            const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
-            const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
-            unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
-            if (RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
-                SizeType length;
-    #ifdef _MSC_VER         // Find the index of first escaped
-                unsigned long offset;
-                _BitScanForward(&offset, r);
-                length = offset;
-    #else
-                length = static_cast<SizeType>(__builtin_ffs(r) - 1);
-    #endif
-                if (length != 0) {
-                    char* q = reinterpret_cast<char*>(os.Push(length));
-                    for (size_t i = 0; i < length; i++)
-                        q[i] = p[i];
-
-                    p += length;
-                }
-                break;
-            }
-            _mm_storeu_si128(reinterpret_cast<__m128i *>(os.Push(16)), s);
-        }
-
-        is.src_ = p;
-    }
-
-    // InsituStringStream -> InsituStringStream
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
-        RAPIDJSON_ASSERT(&is == &os);
-        (void)os;
-
-        if (is.src_ == is.dst_) {
-            SkipUnescapedString(is);
-            return;
-        }
-
-        char* p = is.src_;
-        char *q = is.dst_;
-
-        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-        while (p != nextAligned)
-            if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
-                is.src_ = p;
-                is.dst_ = q;
-                return;
-            }
-            else
-                *q++ = *p++;
-
-        // The rest of string using SIMD
-        static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
-        static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
-        static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
-        const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
-        const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
-        const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
-
-        for (;; p += 16, q += 16) {
-            const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-            const __m128i t1 = _mm_cmpeq_epi8(s, dq);
-            const __m128i t2 = _mm_cmpeq_epi8(s, bs);
-            const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
-            const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
-            unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
-            if (RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
-                size_t length;
-#ifdef _MSC_VER         // Find the index of first escaped
-                unsigned long offset;
-                _BitScanForward(&offset, r);
-                length = offset;
-#else
-                length = static_cast<size_t>(__builtin_ffs(r) - 1);
-#endif
-                for (const char* pend = p + length; p != pend; )
-                    *q++ = *p++;
-                break;
-            }
-            _mm_storeu_si128(reinterpret_cast<__m128i *>(q), s);
-        }
-
-        is.src_ = p;
-        is.dst_ = q;
-    }
-
-    // When read/write pointers are the same for insitu stream, just skip unescaped characters
-    static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) {
-        RAPIDJSON_ASSERT(is.src_ == is.dst_);
-        char* p = is.src_;
-
-        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-        for (; p != nextAligned; p++)
-            if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
-                is.src_ = is.dst_ = p;
-                return;
-            }
-
-        // The rest of string using SIMD
-        static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
-        static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
-        static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
-        const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
-        const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
-        const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
-
-        for (;; p += 16) {
-            const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-            const __m128i t1 = _mm_cmpeq_epi8(s, dq);
-            const __m128i t2 = _mm_cmpeq_epi8(s, bs);
-            const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
-            const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
-            unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
-            if (RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
-                size_t length;
-#ifdef _MSC_VER         // Find the index of first escaped
-                unsigned long offset;
-                _BitScanForward(&offset, r);
-                length = offset;
-#else
-                length = static_cast<size_t>(__builtin_ffs(r) - 1);
-#endif
-                p += length;
-                break;
-            }
-        }
-
-        is.src_ = is.dst_ = p;
-    }
-#elif defined(RAPIDJSON_NEON)
-    // StringStream -> StackStream<char>
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
-        const char* p = is.src_;
-
-        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-        while (p != nextAligned)
-            if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
-                is.src_ = p;
-                return;
-            }
-            else
-                os.Put(*p++);
-
-        // The rest of string using SIMD
-        const uint8x16_t s0 = vmovq_n_u8('"');
-        const uint8x16_t s1 = vmovq_n_u8('\\');
-        const uint8x16_t s2 = vmovq_n_u8('\b');
-        const uint8x16_t s3 = vmovq_n_u8(32);
-
-        for (;; p += 16) {
-            const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
-            uint8x16_t x = vceqq_u8(s, s0);
-            x = vorrq_u8(x, vceqq_u8(s, s1));
-            x = vorrq_u8(x, vceqq_u8(s, s2));
-            x = vorrq_u8(x, vcltq_u8(s, s3));
-
-            x = vrev64q_u8(x);                     // Rev in 64
-            uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
-            uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
-
-            SizeType length = 0;
-            bool escaped = false;
-            if (low == 0) {
-                if (high != 0) {
-                    uint32_t lz = internal::clzll(high);
-                    length = 8 + (lz >> 3);
-                    escaped = true;
-                }
-            } else {
-                uint32_t lz = internal::clzll(low);
-                length = lz >> 3;
-                escaped = true;
-            }
-            if (RAPIDJSON_UNLIKELY(escaped)) {   // some of characters is escaped
-                if (length != 0) {
-                    char* q = reinterpret_cast<char*>(os.Push(length));
-                    for (size_t i = 0; i < length; i++)
-                        q[i] = p[i];
-
-                    p += length;
-                }
-                break;
-            }
-            vst1q_u8(reinterpret_cast<uint8_t *>(os.Push(16)), s);
-        }
-
-        is.src_ = p;
-    }
-
-    // InsituStringStream -> InsituStringStream
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
-        RAPIDJSON_ASSERT(&is == &os);
-        (void)os;
-
-        if (is.src_ == is.dst_) {
-            SkipUnescapedString(is);
-            return;
-        }
-
-        char* p = is.src_;
-        char *q = is.dst_;
-
-        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-        while (p != nextAligned)
-            if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
-                is.src_ = p;
-                is.dst_ = q;
-                return;
-            }
-            else
-                *q++ = *p++;
-
-        // The rest of string using SIMD
-        const uint8x16_t s0 = vmovq_n_u8('"');
-        const uint8x16_t s1 = vmovq_n_u8('\\');
-        const uint8x16_t s2 = vmovq_n_u8('\b');
-        const uint8x16_t s3 = vmovq_n_u8(32);
-
-        for (;; p += 16, q += 16) {
-            const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
-            uint8x16_t x = vceqq_u8(s, s0);
-            x = vorrq_u8(x, vceqq_u8(s, s1));
-            x = vorrq_u8(x, vceqq_u8(s, s2));
-            x = vorrq_u8(x, vcltq_u8(s, s3));
-
-            x = vrev64q_u8(x);                     // Rev in 64
-            uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
-            uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
-
-            SizeType length = 0;
-            bool escaped = false;
-            if (low == 0) {
-                if (high != 0) {
-                    uint32_t lz = internal::clzll(high);
-                    length = 8 + (lz >> 3);
-                    escaped = true;
-                }
-            } else {
-                uint32_t lz = internal::clzll(low);
-                length = lz >> 3;
-                escaped = true;
-            }
-            if (RAPIDJSON_UNLIKELY(escaped)) {   // some of characters is escaped
-                for (const char* pend = p + length; p != pend; ) {
-                    *q++ = *p++;
-                }
-                break;
-            }
-            vst1q_u8(reinterpret_cast<uint8_t *>(q), s);
-        }
-
-        is.src_ = p;
-        is.dst_ = q;
-    }
-
-    // When read/write pointers are the same for insitu stream, just skip unescaped characters
-    static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) {
-        RAPIDJSON_ASSERT(is.src_ == is.dst_);
-        char* p = is.src_;
-
-        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-        for (; p != nextAligned; p++)
-            if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
-                is.src_ = is.dst_ = p;
-                return;
-            }
-
-        // The rest of string using SIMD
-        const uint8x16_t s0 = vmovq_n_u8('"');
-        const uint8x16_t s1 = vmovq_n_u8('\\');
-        const uint8x16_t s2 = vmovq_n_u8('\b');
-        const uint8x16_t s3 = vmovq_n_u8(32);
-
-        for (;; p += 16) {
-            const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
-            uint8x16_t x = vceqq_u8(s, s0);
-            x = vorrq_u8(x, vceqq_u8(s, s1));
-            x = vorrq_u8(x, vceqq_u8(s, s2));
-            x = vorrq_u8(x, vcltq_u8(s, s3));
-
-            x = vrev64q_u8(x);                     // Rev in 64
-            uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
-            uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
-
-            if (low == 0) {
-                if (high != 0) {
-                    uint32_t lz = internal::clzll(high);
-                    p += 8 + (lz >> 3);
-                    break;
-                }
-            } else {
-                uint32_t lz = internal::clzll(low);
-                p += lz >> 3;
-                break;
-            }
-        }
-
-        is.src_ = is.dst_ = p;
-    }
-#endif // RAPIDJSON_NEON
-
-    template<typename InputStream, bool backup, bool pushOnTake>
-    class NumberStream;
-
-    template<typename InputStream>
-    class NumberStream<InputStream, false, false> {
-    public:
-        typedef typename InputStream::Ch Ch;
-
-        NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader;  }
-
-        RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); }
-        RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }
-        RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); }
-        RAPIDJSON_FORCEINLINE void Push(char) {}
-
-        size_t Tell() { return is.Tell(); }
-        size_t Length() { return 0; }
-        const char* Pop() { return 0; }
-
-    protected:
-        NumberStream& operator=(const NumberStream&);
-
-        InputStream& is;
-    };
-
-    template<typename InputStream>
-    class NumberStream<InputStream, true, false> : public NumberStream<InputStream, false, false> {
-        typedef NumberStream<InputStream, false, false> Base;
-    public:
-        NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is), stackStream(reader.stack_) {}
-
-        RAPIDJSON_FORCEINLINE Ch TakePush() {
-            stackStream.Put(static_cast<char>(Base::is.Peek()));
-            return Base::is.Take();
-        }
-
-        RAPIDJSON_FORCEINLINE void Push(char c) {
-            stackStream.Put(c);
-        }
-
-        size_t Length() { return stackStream.Length(); }
-
-        const char* Pop() {
-            stackStream.Put('\0');
-            return stackStream.Pop();
-        }
-
-    private:
-        StackStream<char> stackStream;
-    };
-
-    template<typename InputStream>
-    class NumberStream<InputStream, true, true> : public NumberStream<InputStream, true, false> {
-        typedef NumberStream<InputStream, true, false> Base;
-    public:
-        NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is) {}
-
-        RAPIDJSON_FORCEINLINE Ch Take() { return Base::TakePush(); }
-    };
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseNumber(InputStream& is, Handler& handler) {
-        internal::StreamLocalCopy<InputStream> copy(is);
-        NumberStream<InputStream,
-            ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
-                ((parseFlags & kParseInsituFlag) == 0) :
-                ((parseFlags & kParseFullPrecisionFlag) != 0),
-            (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
-                (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);
-
-        size_t startOffset = s.Tell();
-        double d = 0.0;
-        bool useNanOrInf = false;
-
-        // Parse minus
-        bool minus = Consume(s, '-');
-
-        // Parse int: zero / ( digit1-9 *DIGIT )
-        unsigned i = 0;
-        uint64_t i64 = 0;
-        bool use64bit = false;
-        int significandDigit = 0;
-        if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) {
-            i = 0;
-            s.TakePush();
-        }
-        else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) {
-            i = static_cast<unsigned>(s.TakePush() - '0');
-
-            if (minus)
-                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                    if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648
-                        if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) {
-                            i64 = i;
-                            use64bit = true;
-                            break;
-                        }
-                    }
-                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                    significandDigit++;
-                }
-            else
-                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                    if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295
-                        if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) {
-                            i64 = i;
-                            use64bit = true;
-                            break;
-                        }
-                    }
-                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                    significandDigit++;
-                }
-        }
-        // Parse NaN or Infinity here
-        else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
-            if (Consume(s, 'N')) {
-                if (Consume(s, 'a') && Consume(s, 'N')) {
-                    d = std::numeric_limits<double>::quiet_NaN();
-                    useNanOrInf = true;
-                }
-            }
-            else if (RAPIDJSON_LIKELY(Consume(s, 'I'))) {
-                if (Consume(s, 'n') && Consume(s, 'f')) {
-                    d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
-                    useNanOrInf = true;
-
-                    if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
-                                                                && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) {
-                        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
-                    }
-                }
-            }
-
-            if (RAPIDJSON_UNLIKELY(!useNanOrInf)) {
-                RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
-            }
-        }
-        else
-            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
-
-        // Parse 64bit int
-        bool useDouble = false;
-        if (use64bit) {
-            if (minus)
-                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                     if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
-                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) {
-                            d = static_cast<double>(i64);
-                            useDouble = true;
-                            break;
-                        }
-                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                    significandDigit++;
-                }
-            else
-                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                    if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
-                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) {
-                            d = static_cast<double>(i64);
-                            useDouble = true;
-                            break;
-                        }
-                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                    significandDigit++;
-                }
-        }
-
-        // Force double for big integer
-        if (useDouble) {
-            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                d = d * 10 + (s.TakePush() - '0');
-            }
-        }
-
-        // Parse frac = decimal-point 1*DIGIT
-        int expFrac = 0;
-        size_t decimalPosition;
-        if (Consume(s, '.')) {
-            decimalPosition = s.Length();
-
-            if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
-                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
-
-            if (!useDouble) {
-#if RAPIDJSON_64BIT
-                // Use i64 to store significand in 64-bit architecture
-                if (!use64bit)
-                    i64 = i;
-
-                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                    if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
-                        break;
-                    else {
-                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                        --expFrac;
-                        if (i64 != 0)
-                            significandDigit++;
-                    }
-                }
-
-                d = static_cast<double>(i64);
-#else
-                // Use double to store significand in 32-bit architecture
-                d = static_cast<double>(use64bit ? i64 : i);
-#endif
-                useDouble = true;
-            }
-
-            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                if (significandDigit < 17) {
-                    d = d * 10.0 + (s.TakePush() - '0');
-                    --expFrac;
-                    if (RAPIDJSON_LIKELY(d > 0.0))
-                        significandDigit++;
-                }
-                else
-                    s.TakePush();
-            }
-        }
-        else
-            decimalPosition = s.Length(); // decimal position at the end of integer.
-
-        // Parse exp = e [ minus / plus ] 1*DIGIT
-        int exp = 0;
-        if (Consume(s, 'e') || Consume(s, 'E')) {
-            if (!useDouble) {
-                d = static_cast<double>(use64bit ? i64 : i);
-                useDouble = true;
-            }
-
-            bool expMinus = false;
-            if (Consume(s, '+'))
-                ;
-            else if (Consume(s, '-'))
-                expMinus = true;
-
-            if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                exp = static_cast<int>(s.Take() - '0');
-                if (expMinus) {
-                    // (exp + expFrac) must not underflow int => we're detecting when -exp gets
-                    // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
-                    // underflow territory):
-                    //
-                    //        -(exp * 10 + 9) + expFrac >= INT_MIN
-                    //   <=>  exp <= (expFrac - INT_MIN - 9) / 10
-                    RAPIDJSON_ASSERT(expFrac <= 0);
-                    int maxExp = (expFrac + 2147483639) / 10;
-
-                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
-                        if (RAPIDJSON_UNLIKELY(exp > maxExp)) {
-                            while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
-                                s.Take();
-                        }
-                    }
-                }
-                else {  // positive exp
-                    int maxExp = 308 - expFrac;
-                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
-                        if (RAPIDJSON_UNLIKELY(exp > maxExp))
-                            RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
-                    }
-                }
-            }
-            else
-                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
-
-            if (expMinus)
-                exp = -exp;
-        }
-
-        // Finish parsing, call event according to the type of number.
-        bool cont = true;
-
-        if (parseFlags & kParseNumbersAsStringsFlag) {
-            if (parseFlags & kParseInsituFlag) {
-                s.Pop();  // Pop stack no matter if it will be used or not.
-                typename InputStream::Ch* head = is.PutBegin();
-                const size_t length = s.Tell() - startOffset;
-                RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
-                // unable to insert the \0 character here, it will erase the comma after this number
-                const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
-                cont = handler.RawNumber(str, SizeType(length), false);
-            }
-            else {
-                SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
-                StringStream srcStream(s.Pop());
-                StackStream<typename TargetEncoding::Ch> dstStream(stack_);
-                while (numCharsToCopy--) {
-                    Transcoder<UTF8<>, TargetEncoding>::Transcode(srcStream, dstStream);
-                }
-                dstStream.Put('\0');
-                const typename TargetEncoding::Ch* str = dstStream.Pop();
-                const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
-                cont = handler.RawNumber(str, SizeType(length), true);
-            }
-        }
-        else {
-           size_t length = s.Length();
-           const char* decimal = s.Pop();  // Pop stack no matter if it will be used or not.
-
-           if (useDouble) {
-               int p = exp + expFrac;
-               if (parseFlags & kParseFullPrecisionFlag)
-                   d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
-               else
-                   d = internal::StrtodNormalPrecision(d, p);
-
-               // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
-               if (d > (std::numeric_limits<double>::max)()) {
-                   // Overflow
-                   // TODO: internal::StrtodX should report overflow (or underflow)
-                   RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
-               }
-
-               cont = handler.Double(minus ? -d : d);
-           }
-           else if (useNanOrInf) {
-               cont = handler.Double(d);
-           }
-           else {
-               if (use64bit) {
-                   if (minus)
-                       cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
-                   else
-                       cont = handler.Uint64(i64);
-               }
-               else {
-                   if (minus)
-                       cont = handler.Int(static_cast<int32_t>(~i + 1));
-                   else
-                       cont = handler.Uint(i);
-               }
-           }
-        }
-        if (RAPIDJSON_UNLIKELY(!cont))
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
-    }
-
-    // Parse any JSON value
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseValue(InputStream& is, Handler& handler) {
-        switch (is.Peek()) {
-            case 'n': ParseNull  <parseFlags>(is, handler); break;
-            case 't': ParseTrue  <parseFlags>(is, handler); break;
-            case 'f': ParseFalse <parseFlags>(is, handler); break;
-            case '"': ParseString<parseFlags>(is, handler); break;
-            case '{': ParseObject<parseFlags>(is, handler); break;
-            case '[': ParseArray <parseFlags>(is, handler); break;
-            default :
-                      ParseNumber<parseFlags>(is, handler);
-                      break;
-
-        }
-    }
-
-    // Iterative Parsing
-
-    // States
-    enum IterativeParsingState {
-        IterativeParsingFinishState = 0, // sink states at top
-        IterativeParsingErrorState,      // sink states at top
-        IterativeParsingStartState,
-
-        // Object states
-        IterativeParsingObjectInitialState,
-        IterativeParsingMemberKeyState,
-        IterativeParsingMemberValueState,
-        IterativeParsingObjectFinishState,
-
-        // Array states
-        IterativeParsingArrayInitialState,
-        IterativeParsingElementState,
-        IterativeParsingArrayFinishState,
-
-        // Single value state
-        IterativeParsingValueState,
-
-        // Delimiter states (at bottom)
-        IterativeParsingElementDelimiterState,
-        IterativeParsingMemberDelimiterState,
-        IterativeParsingKeyValueDelimiterState,
-
-        cIterativeParsingStateCount
-    };
-
-    // Tokens
-    enum Token {
-        LeftBracketToken = 0,
-        RightBracketToken,
-
-        LeftCurlyBracketToken,
-        RightCurlyBracketToken,
-
-        CommaToken,
-        ColonToken,
-
-        StringToken,
-        FalseToken,
-        TrueToken,
-        NullToken,
-        NumberToken,
-
-        kTokenCount
-    };
-
-    RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const {
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#define N NumberToken
-#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
-        // Maps from ASCII to Token
-        static const unsigned char tokenMap[256] = {
-            N16, // 00~0F
-            N16, // 10~1F
-            N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F
-            N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F
-            N16, // 40~4F
-            N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F
-            N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F
-            N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F
-            N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF
-        };
-#undef N
-#undef N16
-//!@endcond
-
-        if (sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256)
-            return static_cast<Token>(tokenMap[static_cast<unsigned char>(c)]);
-        else
-            return NumberToken;
-    }
-
-    RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const {
-        // current state x one lookahead token -> new state
-        static const char G[cIterativeParsingStateCount][kTokenCount] = {
-            // Finish(sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            },
-            // Error(sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            },
-            // Start
-            {
-                IterativeParsingArrayInitialState,  // Left bracket
-                IterativeParsingErrorState,         // Right bracket
-                IterativeParsingObjectInitialState, // Left curly bracket
-                IterativeParsingErrorState,         // Right curly bracket
-                IterativeParsingErrorState,         // Comma
-                IterativeParsingErrorState,         // Colon
-                IterativeParsingValueState,         // String
-                IterativeParsingValueState,         // False
-                IterativeParsingValueState,         // True
-                IterativeParsingValueState,         // Null
-                IterativeParsingValueState          // Number
-            },
-            // ObjectInitial
-            {
-                IterativeParsingErrorState,         // Left bracket
-                IterativeParsingErrorState,         // Right bracket
-                IterativeParsingErrorState,         // Left curly bracket
-                IterativeParsingObjectFinishState,  // Right curly bracket
-                IterativeParsingErrorState,         // Comma
-                IterativeParsingErrorState,         // Colon
-                IterativeParsingMemberKeyState,     // String
-                IterativeParsingErrorState,         // False
-                IterativeParsingErrorState,         // True
-                IterativeParsingErrorState,         // Null
-                IterativeParsingErrorState          // Number
-            },
-            // MemberKey
-            {
-                IterativeParsingErrorState,             // Left bracket
-                IterativeParsingErrorState,             // Right bracket
-                IterativeParsingErrorState,             // Left curly bracket
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingErrorState,             // Comma
-                IterativeParsingKeyValueDelimiterState, // Colon
-                IterativeParsingErrorState,             // String
-                IterativeParsingErrorState,             // False
-                IterativeParsingErrorState,             // True
-                IterativeParsingErrorState,             // Null
-                IterativeParsingErrorState              // Number
-            },
-            // MemberValue
-            {
-                IterativeParsingErrorState,             // Left bracket
-                IterativeParsingErrorState,             // Right bracket
-                IterativeParsingErrorState,             // Left curly bracket
-                IterativeParsingObjectFinishState,      // Right curly bracket
-                IterativeParsingMemberDelimiterState,   // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingErrorState,             // String
-                IterativeParsingErrorState,             // False
-                IterativeParsingErrorState,             // True
-                IterativeParsingErrorState,             // Null
-                IterativeParsingErrorState              // Number
-            },
-            // ObjectFinish(sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            },
-            // ArrayInitial
-            {
-                IterativeParsingArrayInitialState,      // Left bracket(push Element state)
-                IterativeParsingArrayFinishState,       // Right bracket
-                IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingErrorState,             // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingElementState,           // String
-                IterativeParsingElementState,           // False
-                IterativeParsingElementState,           // True
-                IterativeParsingElementState,           // Null
-                IterativeParsingElementState            // Number
-            },
-            // Element
-            {
-                IterativeParsingErrorState,             // Left bracket
-                IterativeParsingArrayFinishState,       // Right bracket
-                IterativeParsingErrorState,             // Left curly bracket
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingElementDelimiterState,  // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingErrorState,             // String
-                IterativeParsingErrorState,             // False
-                IterativeParsingErrorState,             // True
-                IterativeParsingErrorState,             // Null
-                IterativeParsingErrorState              // Number
-            },
-            // ArrayFinish(sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            },
-            // Single Value (sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            },
-            // ElementDelimiter
-            {
-                IterativeParsingArrayInitialState,      // Left bracket(push Element state)
-                IterativeParsingArrayFinishState,       // Right bracket
-                IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingErrorState,             // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingElementState,           // String
-                IterativeParsingElementState,           // False
-                IterativeParsingElementState,           // True
-                IterativeParsingElementState,           // Null
-                IterativeParsingElementState            // Number
-            },
-            // MemberDelimiter
-            {
-                IterativeParsingErrorState,         // Left bracket
-                IterativeParsingErrorState,         // Right bracket
-                IterativeParsingErrorState,         // Left curly bracket
-                IterativeParsingObjectFinishState,  // Right curly bracket
-                IterativeParsingErrorState,         // Comma
-                IterativeParsingErrorState,         // Colon
-                IterativeParsingMemberKeyState,     // String
-                IterativeParsingErrorState,         // False
-                IterativeParsingErrorState,         // True
-                IterativeParsingErrorState,         // Null
-                IterativeParsingErrorState          // Number
-            },
-            // KeyValueDelimiter
-            {
-                IterativeParsingArrayInitialState,      // Left bracket(push MemberValue state)
-                IterativeParsingErrorState,             // Right bracket
-                IterativeParsingObjectInitialState,     // Left curly bracket(push MemberValue state)
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingErrorState,             // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingMemberValueState,       // String
-                IterativeParsingMemberValueState,       // False
-                IterativeParsingMemberValueState,       // True
-                IterativeParsingMemberValueState,       // Null
-                IterativeParsingMemberValueState        // Number
-            },
-        }; // End of G
-
-        return static_cast<IterativeParsingState>(G[state][token]);
-    }
-
-    // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit().
-    // May return a new state on state pop.
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) {
-        (void)token;
-
-        switch (dst) {
-        case IterativeParsingErrorState:
-            return dst;
-
-        case IterativeParsingObjectInitialState:
-        case IterativeParsingArrayInitialState:
-        {
-            // Push the state(Element or MemeberValue) if we are nested in another array or value of member.
-            // In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop.
-            IterativeParsingState n = src;
-            if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
-                n = IterativeParsingElementState;
-            else if (src == IterativeParsingKeyValueDelimiterState)
-                n = IterativeParsingMemberValueState;
-            // Push current state.
-            *stack_.template Push<SizeType>(1) = n;
-            // Initialize and push the member/element count.
-            *stack_.template Push<SizeType>(1) = 0;
-            // Call handler
-            bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
-            // On handler short circuits the parsing.
-            if (!hr) {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
-                return IterativeParsingErrorState;
-            }
-            else {
-                is.Take();
-                return dst;
-            }
-        }
-
-        case IterativeParsingMemberKeyState:
-            ParseString<parseFlags>(is, handler, true);
-            if (HasParseError())
-                return IterativeParsingErrorState;
-            else
-                return dst;
-
-        case IterativeParsingKeyValueDelimiterState:
-            RAPIDJSON_ASSERT(token == ColonToken);
-            is.Take();
-            return dst;
-
-        case IterativeParsingMemberValueState:
-            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
-            ParseValue<parseFlags>(is, handler);
-            if (HasParseError()) {
-                return IterativeParsingErrorState;
-            }
-            return dst;
-
-        case IterativeParsingElementState:
-            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
-            ParseValue<parseFlags>(is, handler);
-            if (HasParseError()) {
-                return IterativeParsingErrorState;
-            }
-            return dst;
-
-        case IterativeParsingMemberDelimiterState:
-        case IterativeParsingElementDelimiterState:
-            is.Take();
-            // Update member/element count.
-            *stack_.template Top<SizeType>() = *stack_.template Top<SizeType>() + 1;
-            return dst;
-
-        case IterativeParsingObjectFinishState:
-        {
-            // Transit from delimiter is only allowed when trailing commas are enabled
-            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingMemberDelimiterState) {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorObjectMissName, is.Tell());
-                return IterativeParsingErrorState;
-            }
-            // Get member count.
-            SizeType c = *stack_.template Pop<SizeType>(1);
-            // If the object is not empty, count the last member.
-            if (src == IterativeParsingMemberValueState)
-                ++c;
-            // Restore the state.
-            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
-            // Transit to Finish state if this is the topmost scope.
-            if (n == IterativeParsingStartState)
-                n = IterativeParsingFinishState;
-            // Call handler
-            bool hr = handler.EndObject(c);
-            // On handler short circuits the parsing.
-            if (!hr) {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
-                return IterativeParsingErrorState;
-            }
-            else {
-                is.Take();
-                return n;
-            }
-        }
-
-        case IterativeParsingArrayFinishState:
-        {
-            // Transit from delimiter is only allowed when trailing commas are enabled
-            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingElementDelimiterState) {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorValueInvalid, is.Tell());
-                return IterativeParsingErrorState;
-            }
-            // Get element count.
-            SizeType c = *stack_.template Pop<SizeType>(1);
-            // If the array is not empty, count the last element.
-            if (src == IterativeParsingElementState)
-                ++c;
-            // Restore the state.
-            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
-            // Transit to Finish state if this is the topmost scope.
-            if (n == IterativeParsingStartState)
-                n = IterativeParsingFinishState;
-            // Call handler
-            bool hr = handler.EndArray(c);
-            // On handler short circuits the parsing.
-            if (!hr) {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
-                return IterativeParsingErrorState;
-            }
-            else {
-                is.Take();
-                return n;
-            }
-        }
-
-        default:
-            // This branch is for IterativeParsingValueState actually.
-            // Use `default:` rather than
-            // `case IterativeParsingValueState:` is for code coverage.
-
-            // The IterativeParsingStartState is not enumerated in this switch-case.
-            // It is impossible for that case. And it can be caught by following assertion.
-
-            // The IterativeParsingFinishState is not enumerated in this switch-case either.
-            // It is a "derivative" state which cannot triggered from Predict() directly.
-            // Therefore it cannot happen here. And it can be caught by following assertion.
-            RAPIDJSON_ASSERT(dst == IterativeParsingValueState);
-
-            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
-            ParseValue<parseFlags>(is, handler);
-            if (HasParseError()) {
-                return IterativeParsingErrorState;
-            }
-            return IterativeParsingFinishState;
-        }
-    }
-
-    template <typename InputStream>
-    void HandleError(IterativeParsingState src, InputStream& is) {
-        if (HasParseError()) {
-            // Error flag has been set.
-            return;
-        }
-
-        switch (src) {
-        case IterativeParsingStartState:            RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell()); return;
-        case IterativeParsingFinishState:           RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell()); return;
-        case IterativeParsingObjectInitialState:
-        case IterativeParsingMemberDelimiterState:  RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell()); return;
-        case IterativeParsingMemberKeyState:        RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell()); return;
-        case IterativeParsingMemberValueState:      RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); return;
-        case IterativeParsingKeyValueDelimiterState:
-        case IterativeParsingArrayInitialState:
-        case IterativeParsingElementDelimiterState: RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); return;
-        default: RAPIDJSON_ASSERT(src == IterativeParsingElementState); RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell()); return;
-        }
-    }
-
-    RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const {
-        return s >= IterativeParsingElementDelimiterState;
-    }
-
-    RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const {
-        return s <= IterativeParsingErrorState;
-    }
-
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    ParseResult IterativeParse(InputStream& is, Handler& handler) {
-        parseResult_.Clear();
-        ClearStackOnExit scope(*this);
-        IterativeParsingState state = IterativeParsingStartState;
-
-        SkipWhitespaceAndComments<parseFlags>(is);
-        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-        while (is.Peek() != '\0') {
-            Token t = Tokenize(is.Peek());
-            IterativeParsingState n = Predict(state, t);
-            IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
-
-            if (d == IterativeParsingErrorState) {
-                HandleError(state, is);
-                break;
-            }
-
-            state = d;
-
-            // Do not further consume streams if a root JSON has been parsed.
-            if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
-                break;
-
-            SkipWhitespaceAndComments<parseFlags>(is);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-        }
-
-        // Handle the end of file.
-        if (state != IterativeParsingFinishState)
-            HandleError(state, is);
-
-        return parseResult_;
-    }
-
-    static const size_t kDefaultStackCapacity = 256;    //!< Default stack capacity in bytes for storing a single decoded string.
-    internal::Stack<StackAllocator> stack_;  //!< A stack for storing decoded string temporarily during non-destructive parsing.
-    ParseResult parseResult_;
-    IterativeParsingState state_;
-}; // class GenericReader
-
-//! Reader with UTF8 encoding and default allocator.
-typedef GenericReader<UTF8<>, UTF8<> > Reader;
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__) || defined(_MSC_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_READER_H_
diff --git a/thirdparty/rapidjson/schema.h b/thirdparty/rapidjson/schema.h
deleted file mode 100644
index a034021..0000000
--- a/thirdparty/rapidjson/schema.h
+++ /dev/null
@@ -1,2648 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available->
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip-> All rights reserved->
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License-> You may obtain a copy of the License at
-//
-// http://opensource->org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied-> See the License for the 
-// specific language governing permissions and limitations under the License->
-
-#ifndef RAPIDJSON_SCHEMA_H_
-#define RAPIDJSON_SCHEMA_H_
-
-#include "document.h"
-#include "pointer.h"
-#include "stringbuffer.h"
-#include "error/en.h"
-#include <cmath> // abs, floor
-
-#if !defined(RAPIDJSON_SCHEMA_USE_INTERNALREGEX)
-#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 1
-#else
-#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0
-#endif
-
-#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
-#define RAPIDJSON_SCHEMA_USE_STDREGEX 1
-#else
-#define RAPIDJSON_SCHEMA_USE_STDREGEX 0
-#endif
-
-#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
-#include "internal/regex.h"
-#elif RAPIDJSON_SCHEMA_USE_STDREGEX
-#include <regex>
-#endif
-
-#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX || RAPIDJSON_SCHEMA_USE_STDREGEX
-#define RAPIDJSON_SCHEMA_HAS_REGEX 1
-#else
-#define RAPIDJSON_SCHEMA_HAS_REGEX 0
-#endif
-
-#ifndef RAPIDJSON_SCHEMA_VERBOSE
-#define RAPIDJSON_SCHEMA_VERBOSE 0
-#endif
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-#include "stringbuffer.h"
-#endif
-
-RAPIDJSON_DIAG_PUSH
-
-#if defined(__GNUC__)
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_OFF(weak-vtables)
-RAPIDJSON_DIAG_OFF(exit-time-destructors)
-RAPIDJSON_DIAG_OFF(c++98-compat-pedantic)
-RAPIDJSON_DIAG_OFF(variadic-macros)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Verbose Utilities
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-
-namespace internal {
-
-inline void PrintInvalidKeyword(const char* keyword) {
-    printf("Fail keyword: %s\n", keyword);
-}
-
-inline void PrintInvalidKeyword(const wchar_t* keyword) {
-    wprintf(L"Fail keyword: %ls\n", keyword);
-}
-
-inline void PrintInvalidDocument(const char* document) {
-    printf("Fail document: %s\n\n", document);
-}
-
-inline void PrintInvalidDocument(const wchar_t* document) {
-    wprintf(L"Fail document: %ls\n\n", document);
-}
-
-inline void PrintValidatorPointers(unsigned depth, const char* s, const char* d) {
-    printf("S: %*s%s\nD: %*s%s\n\n", depth * 4, " ", s, depth * 4, " ", d);
-}
-
-inline void PrintValidatorPointers(unsigned depth, const wchar_t* s, const wchar_t* d) {
-    wprintf(L"S: %*ls%ls\nD: %*ls%ls\n\n", depth * 4, L" ", s, depth * 4, L" ", d);
-}
-
-} // namespace internal
-
-#endif // RAPIDJSON_SCHEMA_VERBOSE
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_INVALID_KEYWORD_RETURN
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) internal::PrintInvalidKeyword(keyword)
-#else
-#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword)
-#endif
-
-#define RAPIDJSON_INVALID_KEYWORD_RETURN(code)\
-RAPIDJSON_MULTILINEMACRO_BEGIN\
-    context.invalidCode = code;\
-    context.invalidKeyword = SchemaType::GetValidateErrorKeyword(code).GetString();\
-    RAPIDJSON_INVALID_KEYWORD_VERBOSE(context.invalidKeyword);\
-    return false;\
-RAPIDJSON_MULTILINEMACRO_END
-
-///////////////////////////////////////////////////////////////////////////////
-// ValidateFlag
-
-/*! \def RAPIDJSON_VALIDATE_DEFAULT_FLAGS
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-defined kValidateDefaultFlags definition.
-
-    User can define this as any \c ValidateFlag combinations.
-*/
-#ifndef RAPIDJSON_VALIDATE_DEFAULT_FLAGS
-#define RAPIDJSON_VALIDATE_DEFAULT_FLAGS kValidateNoFlags
-#endif
-
-//! Combination of validate flags
-/*! \see
- */
-enum ValidateFlag {
-    kValidateNoFlags = 0,                                       //!< No flags are set.
-    kValidateContinueOnErrorFlag = 1,                           //!< Don't stop after first validation error.
-    kValidateDefaultFlags = RAPIDJSON_VALIDATE_DEFAULT_FLAGS    //!< Default validate flags. Can be customized by defining RAPIDJSON_VALIDATE_DEFAULT_FLAGS
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Forward declarations
-
-template <typename ValueType, typename Allocator>
-class GenericSchemaDocument;
-
-namespace internal {
-
-template <typename SchemaDocumentType>
-class Schema;
-
-///////////////////////////////////////////////////////////////////////////////
-// ISchemaValidator
-
-class ISchemaValidator {
-public:
-    virtual ~ISchemaValidator() {}
-    virtual bool IsValid() const = 0;
-    virtual void SetValidateFlags(unsigned flags) = 0;
-    virtual unsigned GetValidateFlags() const = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// ISchemaStateFactory
-
-template <typename SchemaType>
-class ISchemaStateFactory {
-public:
-    virtual ~ISchemaStateFactory() {}
-    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType&, const bool inheritContinueOnErrors) = 0;
-    virtual void DestroySchemaValidator(ISchemaValidator* validator) = 0;
-    virtual void* CreateHasher() = 0;
-    virtual uint64_t GetHashCode(void* hasher) = 0;
-    virtual void DestroryHasher(void* hasher) = 0;
-    virtual void* MallocState(size_t size) = 0;
-    virtual void FreeState(void* p) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// IValidationErrorHandler
-
-template <typename SchemaType>
-class IValidationErrorHandler {
-public:
-    typedef typename SchemaType::Ch Ch;
-    typedef typename SchemaType::SValue SValue;
-
-    virtual ~IValidationErrorHandler() {}
-
-    virtual void NotMultipleOf(int64_t actual, const SValue& expected) = 0;
-    virtual void NotMultipleOf(uint64_t actual, const SValue& expected) = 0;
-    virtual void NotMultipleOf(double actual, const SValue& expected) = 0;
-    virtual void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) = 0;
-    virtual void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
-    virtual void AboveMaximum(double actual, const SValue& expected, bool exclusive) = 0;
-    virtual void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) = 0;
-    virtual void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
-    virtual void BelowMinimum(double actual, const SValue& expected, bool exclusive) = 0;
-
-    virtual void TooLong(const Ch* str, SizeType length, SizeType expected) = 0;
-    virtual void TooShort(const Ch* str, SizeType length, SizeType expected) = 0;
-    virtual void DoesNotMatch(const Ch* str, SizeType length) = 0;
-
-    virtual void DisallowedItem(SizeType index) = 0;
-    virtual void TooFewItems(SizeType actualCount, SizeType expectedCount) = 0;
-    virtual void TooManyItems(SizeType actualCount, SizeType expectedCount) = 0;
-    virtual void DuplicateItems(SizeType index1, SizeType index2) = 0;
-
-    virtual void TooManyProperties(SizeType actualCount, SizeType expectedCount) = 0;
-    virtual void TooFewProperties(SizeType actualCount, SizeType expectedCount) = 0;
-    virtual void StartMissingProperties() = 0;
-    virtual void AddMissingProperty(const SValue& name) = 0;
-    virtual bool EndMissingProperties() = 0;
-    virtual void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) = 0;
-    virtual void DisallowedProperty(const Ch* name, SizeType length) = 0;
-
-    virtual void StartDependencyErrors() = 0;
-    virtual void StartMissingDependentProperties() = 0;
-    virtual void AddMissingDependentProperty(const SValue& targetName) = 0;
-    virtual void EndMissingDependentProperties(const SValue& sourceName) = 0;
-    virtual void AddDependencySchemaError(const SValue& souceName, ISchemaValidator* subvalidator) = 0;
-    virtual bool EndDependencyErrors() = 0;
-
-    virtual void DisallowedValue(const ValidateErrorCode code) = 0;
-    virtual void StartDisallowedType() = 0;
-    virtual void AddExpectedType(const typename SchemaType::ValueType& expectedType) = 0;
-    virtual void EndDisallowedType(const typename SchemaType::ValueType& actualType) = 0;
-    virtual void NotAllOf(ISchemaValidator** subvalidators, SizeType count) = 0;
-    virtual void NoneOf(ISchemaValidator** subvalidators, SizeType count) = 0;
-    virtual void NotOneOf(ISchemaValidator** subvalidators, SizeType count, bool matched) = 0;
-    virtual void Disallowed() = 0;
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Hasher
-
-// For comparison of compound value
-template<typename Encoding, typename Allocator>
-class Hasher {
-public:
-    typedef typename Encoding::Ch Ch;
-
-    Hasher(Allocator* allocator = 0, size_t stackCapacity = kDefaultSize) : stack_(allocator, stackCapacity) {}
-
-    bool Null() { return WriteType(kNullType); }
-    bool Bool(bool b) { return WriteType(b ? kTrueType : kFalseType); }
-    bool Int(int i) { Number n; n.u.i = i; n.d = static_cast<double>(i); return WriteNumber(n); }
-    bool Uint(unsigned u) { Number n; n.u.u = u; n.d = static_cast<double>(u); return WriteNumber(n); }
-    bool Int64(int64_t i) { Number n; n.u.i = i; n.d = static_cast<double>(i); return WriteNumber(n); }
-    bool Uint64(uint64_t u) { Number n; n.u.u = u; n.d = static_cast<double>(u); return WriteNumber(n); }
-    bool Double(double d) { 
-        Number n; 
-        if (d < 0) n.u.i = static_cast<int64_t>(d);
-        else       n.u.u = static_cast<uint64_t>(d); 
-        n.d = d;
-        return WriteNumber(n);
-    }
-
-    bool RawNumber(const Ch* str, SizeType len, bool) {
-        WriteBuffer(kNumberType, str, len * sizeof(Ch));
-        return true;
-    }
-
-    bool String(const Ch* str, SizeType len, bool) {
-        WriteBuffer(kStringType, str, len * sizeof(Ch));
-        return true;
-    }
-
-    bool StartObject() { return true; }
-    bool Key(const Ch* str, SizeType len, bool copy) { return String(str, len, copy); }
-    bool EndObject(SizeType memberCount) { 
-        uint64_t h = Hash(0, kObjectType);
-        uint64_t* kv = stack_.template Pop<uint64_t>(memberCount * 2);
-        for (SizeType i = 0; i < memberCount; i++)
-            h ^= Hash(kv[i * 2], kv[i * 2 + 1]);  // Use xor to achieve member order insensitive
-        *stack_.template Push<uint64_t>() = h;
-        return true;
-    }
-    
-    bool StartArray() { return true; }
-    bool EndArray(SizeType elementCount) { 
-        uint64_t h = Hash(0, kArrayType);
-        uint64_t* e = stack_.template Pop<uint64_t>(elementCount);
-        for (SizeType i = 0; i < elementCount; i++)
-            h = Hash(h, e[i]); // Use hash to achieve element order sensitive
-        *stack_.template Push<uint64_t>() = h;
-        return true;
-    }
-
-    bool IsValid() const { return stack_.GetSize() == sizeof(uint64_t); }
-
-    uint64_t GetHashCode() const {
-        RAPIDJSON_ASSERT(IsValid());
-        return *stack_.template Top<uint64_t>();
-    }
-
-private:
-    static const size_t kDefaultSize = 256;
-    struct Number {
-        union U {
-            uint64_t u;
-            int64_t i;
-        }u;
-        double d;
-    };
-
-    bool WriteType(Type type) { return WriteBuffer(type, 0, 0); }
-    
-    bool WriteNumber(const Number& n) { return WriteBuffer(kNumberType, &n, sizeof(n)); }
-    
-    bool WriteBuffer(Type type, const void* data, size_t len) {
-        // FNV-1a from http://isthe.com/chongo/tech/comp/fnv/
-        uint64_t h = Hash(RAPIDJSON_UINT64_C2(0x84222325, 0xcbf29ce4), type);
-        const unsigned char* d = static_cast<const unsigned char*>(data);
-        for (size_t i = 0; i < len; i++)
-            h = Hash(h, d[i]);
-        *stack_.template Push<uint64_t>() = h;
-        return true;
-    }
-
-    static uint64_t Hash(uint64_t h, uint64_t d) {
-        static const uint64_t kPrime = RAPIDJSON_UINT64_C2(0x00000100, 0x000001b3);
-        h ^= d;
-        h *= kPrime;
-        return h;
-    }
-
-    Stack<Allocator> stack_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// SchemaValidationContext
-
-template <typename SchemaDocumentType>
-struct SchemaValidationContext {
-    typedef Schema<SchemaDocumentType> SchemaType;
-    typedef ISchemaStateFactory<SchemaType> SchemaValidatorFactoryType;
-    typedef IValidationErrorHandler<SchemaType> ErrorHandlerType;
-    typedef typename SchemaType::ValueType ValueType;
-    typedef typename ValueType::Ch Ch;
-
-    enum PatternValidatorType {
-        kPatternValidatorOnly,
-        kPatternValidatorWithProperty,
-        kPatternValidatorWithAdditionalProperty
-    };
-
-    SchemaValidationContext(SchemaValidatorFactoryType& f, ErrorHandlerType& eh, const SchemaType* s) :
-        factory(f),
-        error_handler(eh),
-        schema(s),
-        valueSchema(),
-        invalidKeyword(),
-        invalidCode(),
-        hasher(),
-        arrayElementHashCodes(),
-        validators(),
-        validatorCount(),
-        patternPropertiesValidators(),
-        patternPropertiesValidatorCount(),
-        patternPropertiesSchemas(),
-        patternPropertiesSchemaCount(),
-        valuePatternValidatorType(kPatternValidatorOnly),
-        propertyExist(),
-        inArray(false),
-        valueUniqueness(false),
-        arrayUniqueness(false)
-    {
-    }
-
-    ~SchemaValidationContext() {
-        if (hasher)
-            factory.DestroryHasher(hasher);
-        if (validators) {
-            for (SizeType i = 0; i < validatorCount; i++)
-                factory.DestroySchemaValidator(validators[i]);
-            factory.FreeState(validators);
-        }
-        if (patternPropertiesValidators) {
-            for (SizeType i = 0; i < patternPropertiesValidatorCount; i++)
-                factory.DestroySchemaValidator(patternPropertiesValidators[i]);
-            factory.FreeState(patternPropertiesValidators);
-        }
-        if (patternPropertiesSchemas)
-            factory.FreeState(patternPropertiesSchemas);
-        if (propertyExist)
-            factory.FreeState(propertyExist);
-    }
-
-    SchemaValidatorFactoryType& factory;
-    ErrorHandlerType& error_handler;
-    const SchemaType* schema;
-    const SchemaType* valueSchema;
-    const Ch* invalidKeyword;
-    ValidateErrorCode invalidCode;
-    void* hasher; // Only validator access
-    void* arrayElementHashCodes; // Only validator access this
-    ISchemaValidator** validators;
-    SizeType validatorCount;
-    ISchemaValidator** patternPropertiesValidators;
-    SizeType patternPropertiesValidatorCount;
-    const SchemaType** patternPropertiesSchemas;
-    SizeType patternPropertiesSchemaCount;
-    PatternValidatorType valuePatternValidatorType;
-    PatternValidatorType objectPatternValidatorType;
-    SizeType arrayElementIndex;
-    bool* propertyExist;
-    bool inArray;
-    bool valueUniqueness;
-    bool arrayUniqueness;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Schema
-
-template <typename SchemaDocumentType>
-class Schema {
-public:
-    typedef typename SchemaDocumentType::ValueType ValueType;
-    typedef typename SchemaDocumentType::AllocatorType AllocatorType;
-    typedef typename SchemaDocumentType::PointerType PointerType;
-    typedef typename ValueType::EncodingType EncodingType;
-    typedef typename EncodingType::Ch Ch;
-    typedef SchemaValidationContext<SchemaDocumentType> Context;
-    typedef Schema<SchemaDocumentType> SchemaType;
-    typedef GenericValue<EncodingType, AllocatorType> SValue;
-    typedef IValidationErrorHandler<Schema> ErrorHandler;
-    friend class GenericSchemaDocument<ValueType, AllocatorType>;
-
-    Schema(SchemaDocumentType* schemaDocument, const PointerType& p, const ValueType& value, const ValueType& document, AllocatorType* allocator) :
-        allocator_(allocator),
-        uri_(schemaDocument->GetURI(), *allocator),
-        pointer_(p, allocator),
-        typeless_(schemaDocument->GetTypeless()),
-        enum_(),
-        enumCount_(),
-        not_(),
-        type_((1 << kTotalSchemaType) - 1), // typeless
-        validatorCount_(),
-        notValidatorIndex_(),
-        properties_(),
-        additionalPropertiesSchema_(),
-        patternProperties_(),
-        patternPropertyCount_(),
-        propertyCount_(),
-        minProperties_(),
-        maxProperties_(SizeType(~0)),
-        additionalProperties_(true),
-        hasDependencies_(),
-        hasRequired_(),
-        hasSchemaDependencies_(),
-        additionalItemsSchema_(),
-        itemsList_(),
-        itemsTuple_(),
-        itemsTupleCount_(),
-        minItems_(),
-        maxItems_(SizeType(~0)),
-        additionalItems_(true),
-        uniqueItems_(false),
-        pattern_(),
-        minLength_(0),
-        maxLength_(~SizeType(0)),
-        exclusiveMinimum_(false),
-        exclusiveMaximum_(false),
-        defaultValueLength_(0)
-    {
-        typedef typename ValueType::ConstValueIterator ConstValueIterator;
-        typedef typename ValueType::ConstMemberIterator ConstMemberIterator;
-
-        if (!value.IsObject())
-            return;
-
-        if (const ValueType* v = GetMember(value, GetTypeString())) {
-            type_ = 0;
-            if (v->IsString())
-                AddType(*v);
-            else if (v->IsArray())
-                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr)
-                    AddType(*itr);
-        }
-
-        if (const ValueType* v = GetMember(value, GetEnumString())) {
-            if (v->IsArray() && v->Size() > 0) {
-                enum_ = static_cast<uint64_t*>(allocator_->Malloc(sizeof(uint64_t) * v->Size()));
-                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) {
-                    typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
-                    char buffer[256u + 24];
-                    MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer));
-                    EnumHasherType h(&hasherAllocator, 256);
-                    itr->Accept(h);
-                    enum_[enumCount_++] = h.GetHashCode();
-                }
-            }
-        }
-
-        if (schemaDocument) {
-            AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document);
-            AssignIfExist(anyOf_, *schemaDocument, p, value, GetAnyOfString(), document);
-            AssignIfExist(oneOf_, *schemaDocument, p, value, GetOneOfString(), document);
-
-            if (const ValueType* v = GetMember(value, GetNotString())) {
-            schemaDocument->CreateSchema(&not_, p.Append(GetNotString(), allocator_), *v, document);
-            notValidatorIndex_ = validatorCount_;
-            validatorCount_++;
-            }
-        }
-
-        // Object
-
-        const ValueType* properties = GetMember(value, GetPropertiesString());
-        const ValueType* required = GetMember(value, GetRequiredString());
-        const ValueType* dependencies = GetMember(value, GetDependenciesString());
-        {
-            // Gather properties from properties/required/dependencies
-            SValue allProperties(kArrayType);
-
-            if (properties && properties->IsObject())
-                for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr)
-                    AddUniqueElement(allProperties, itr->name);
-            
-            if (required && required->IsArray())
-                for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
-                    if (itr->IsString())
-                        AddUniqueElement(allProperties, *itr);
-
-            if (dependencies && dependencies->IsObject())
-                for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
-                    AddUniqueElement(allProperties, itr->name);
-                    if (itr->value.IsArray())
-                        for (ConstValueIterator i = itr->value.Begin(); i != itr->value.End(); ++i)
-                            if (i->IsString())
-                                AddUniqueElement(allProperties, *i);
-                }
-
-            if (allProperties.Size() > 0) {
-                propertyCount_ = allProperties.Size();
-                properties_ = static_cast<Property*>(allocator_->Malloc(sizeof(Property) * propertyCount_));
-                for (SizeType i = 0; i < propertyCount_; i++) {
-                    new (&properties_[i]) Property();
-                    properties_[i].name = allProperties[i];
-                    properties_[i].schema = typeless_;
-                }
-            }
-        }
-
-        if (properties && properties->IsObject()) {
-            PointerType q = p.Append(GetPropertiesString(), allocator_);
-            for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr) {
-                SizeType index;
-                if (FindPropertyIndex(itr->name, &index))
-                    schemaDocument->CreateSchema(&properties_[index].schema, q.Append(itr->name, allocator_), itr->value, document);
-            }
-        }
-
-        if (const ValueType* v = GetMember(value, GetPatternPropertiesString())) {
-            PointerType q = p.Append(GetPatternPropertiesString(), allocator_);
-            patternProperties_ = static_cast<PatternProperty*>(allocator_->Malloc(sizeof(PatternProperty) * v->MemberCount()));
-            patternPropertyCount_ = 0;
-
-            for (ConstMemberIterator itr = v->MemberBegin(); itr != v->MemberEnd(); ++itr) {
-                new (&patternProperties_[patternPropertyCount_]) PatternProperty();
-                patternProperties_[patternPropertyCount_].pattern = CreatePattern(itr->name);
-                schemaDocument->CreateSchema(&patternProperties_[patternPropertyCount_].schema, q.Append(itr->name, allocator_), itr->value, document);
-                patternPropertyCount_++;
-            }
-        }
-
-        if (required && required->IsArray())
-            for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
-                if (itr->IsString()) {
-                    SizeType index;
-                    if (FindPropertyIndex(*itr, &index)) {
-                        properties_[index].required = true;
-                        hasRequired_ = true;
-                    }
-                }
-
-        if (dependencies && dependencies->IsObject()) {
-            PointerType q = p.Append(GetDependenciesString(), allocator_);
-            hasDependencies_ = true;
-            for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
-                SizeType sourceIndex;
-                if (FindPropertyIndex(itr->name, &sourceIndex)) {
-                    if (itr->value.IsArray()) {
-                        properties_[sourceIndex].dependencies = static_cast<bool*>(allocator_->Malloc(sizeof(bool) * propertyCount_));
-                        std::memset(properties_[sourceIndex].dependencies, 0, sizeof(bool)* propertyCount_);
-                        for (ConstValueIterator targetItr = itr->value.Begin(); targetItr != itr->value.End(); ++targetItr) {
-                            SizeType targetIndex;
-                            if (FindPropertyIndex(*targetItr, &targetIndex))
-                                properties_[sourceIndex].dependencies[targetIndex] = true;
-                        }
-                    }
-                    else if (itr->value.IsObject()) {
-                        hasSchemaDependencies_ = true;
-                        schemaDocument->CreateSchema(&properties_[sourceIndex].dependenciesSchema, q.Append(itr->name, allocator_), itr->value, document);
-                        properties_[sourceIndex].dependenciesValidatorIndex = validatorCount_;
-                        validatorCount_++;
-                    }
-                }
-            }
-        }
-
-        if (const ValueType* v = GetMember(value, GetAdditionalPropertiesString())) {
-            if (v->IsBool())
-                additionalProperties_ = v->GetBool();
-            else if (v->IsObject())
-                schemaDocument->CreateSchema(&additionalPropertiesSchema_, p.Append(GetAdditionalPropertiesString(), allocator_), *v, document);
-        }
-
-        AssignIfExist(minProperties_, value, GetMinPropertiesString());
-        AssignIfExist(maxProperties_, value, GetMaxPropertiesString());
-
-        // Array
-        if (const ValueType* v = GetMember(value, GetItemsString())) {
-            PointerType q = p.Append(GetItemsString(), allocator_);
-            if (v->IsObject()) // List validation
-                schemaDocument->CreateSchema(&itemsList_, q, *v, document);
-            else if (v->IsArray()) { // Tuple validation
-                itemsTuple_ = static_cast<const Schema**>(allocator_->Malloc(sizeof(const Schema*) * v->Size()));
-                SizeType index = 0;
-                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr, index++)
-                    schemaDocument->CreateSchema(&itemsTuple_[itemsTupleCount_++], q.Append(index, allocator_), *itr, document);
-            }
-        }
-
-        AssignIfExist(minItems_, value, GetMinItemsString());
-        AssignIfExist(maxItems_, value, GetMaxItemsString());
-
-        if (const ValueType* v = GetMember(value, GetAdditionalItemsString())) {
-            if (v->IsBool())
-                additionalItems_ = v->GetBool();
-            else if (v->IsObject())
-                schemaDocument->CreateSchema(&additionalItemsSchema_, p.Append(GetAdditionalItemsString(), allocator_), *v, document);
-        }
-
-        AssignIfExist(uniqueItems_, value, GetUniqueItemsString());
-
-        // String
-        AssignIfExist(minLength_, value, GetMinLengthString());
-        AssignIfExist(maxLength_, value, GetMaxLengthString());
-
-        if (const ValueType* v = GetMember(value, GetPatternString()))
-            pattern_ = CreatePattern(*v);
-
-        // Number
-        if (const ValueType* v = GetMember(value, GetMinimumString()))
-            if (v->IsNumber())
-                minimum_.CopyFrom(*v, *allocator_);
-
-        if (const ValueType* v = GetMember(value, GetMaximumString()))
-            if (v->IsNumber())
-                maximum_.CopyFrom(*v, *allocator_);
-
-        AssignIfExist(exclusiveMinimum_, value, GetExclusiveMinimumString());
-        AssignIfExist(exclusiveMaximum_, value, GetExclusiveMaximumString());
-
-        if (const ValueType* v = GetMember(value, GetMultipleOfString()))
-            if (v->IsNumber() && v->GetDouble() > 0.0)
-                multipleOf_.CopyFrom(*v, *allocator_);
-
-        // Default
-        if (const ValueType* v = GetMember(value, GetDefaultValueString()))
-            if (v->IsString())
-                defaultValueLength_ = v->GetStringLength();
-
-    }
-
-    ~Schema() {
-        AllocatorType::Free(enum_);
-        if (properties_) {
-            for (SizeType i = 0; i < propertyCount_; i++)
-                properties_[i].~Property();
-            AllocatorType::Free(properties_);
-        }
-        if (patternProperties_) {
-            for (SizeType i = 0; i < patternPropertyCount_; i++)
-                patternProperties_[i].~PatternProperty();
-            AllocatorType::Free(patternProperties_);
-        }
-        AllocatorType::Free(itemsTuple_);
-#if RAPIDJSON_SCHEMA_HAS_REGEX
-        if (pattern_) {
-            pattern_->~RegexType();
-            AllocatorType::Free(pattern_);
-        }
-#endif
-    }
-
-    const SValue& GetURI() const {
-        return uri_;
-    }
-
-    const PointerType& GetPointer() const {
-        return pointer_;
-    }
-
-    bool BeginValue(Context& context) const {
-        if (context.inArray) {
-            if (uniqueItems_)
-                context.valueUniqueness = true;
-
-            if (itemsList_)
-                context.valueSchema = itemsList_;
-            else if (itemsTuple_) {
-                if (context.arrayElementIndex < itemsTupleCount_)
-                    context.valueSchema = itemsTuple_[context.arrayElementIndex];
-                else if (additionalItemsSchema_)
-                    context.valueSchema = additionalItemsSchema_;
-                else if (additionalItems_)
-                    context.valueSchema = typeless_;
-                else {
-                    context.error_handler.DisallowedItem(context.arrayElementIndex);
-                    // Must set valueSchema for when kValidateContinueOnErrorFlag is set, else reports spurious type error
-                    context.valueSchema = typeless_;
-                    // Must bump arrayElementIndex for when kValidateContinueOnErrorFlag is set
-                    context.arrayElementIndex++;
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAdditionalItems);
-                }
-            }
-            else
-                context.valueSchema = typeless_;
-
-            context.arrayElementIndex++;
-        }
-        return true;
-    }
-
-    RAPIDJSON_FORCEINLINE bool EndValue(Context& context) const {
-        // Only check pattern properties if we have validators
-        if (context.patternPropertiesValidatorCount > 0) {
-            bool otherValid = false;
-            SizeType count = context.patternPropertiesValidatorCount;
-            if (context.objectPatternValidatorType != Context::kPatternValidatorOnly)
-                otherValid = context.patternPropertiesValidators[--count]->IsValid();
-
-            bool patternValid = true;
-            for (SizeType i = 0; i < count; i++)
-                if (!context.patternPropertiesValidators[i]->IsValid()) {
-                    patternValid = false;
-                    break;
-                }
-
-            if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) {
-                if (!patternValid) {
-                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPatternProperties);
-                }
-            }
-            else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) {
-                if (!patternValid || !otherValid) {
-                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPatternProperties);
-                }
-            }
-            else if (!patternValid && !otherValid) { // kPatternValidatorWithAdditionalProperty)
-                context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
-                RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPatternProperties);
-            }
-        }
-
-        // For enums only check if we have a hasher
-        if (enum_ && context.hasher) {
-            const uint64_t h = context.factory.GetHashCode(context.hasher);
-            for (SizeType i = 0; i < enumCount_; i++)
-                if (enum_[i] == h)
-                    goto foundEnum;
-            context.error_handler.DisallowedValue(kValidateErrorEnum);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorEnum);
-            foundEnum:;
-        }
-
-    // Only check allOf etc if we have validators
-        if (context.validatorCount > 0) {
-            if (allOf_.schemas)
-                for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++)
-                    if (!context.validators[i]->IsValid()) {
-                        context.error_handler.NotAllOf(&context.validators[allOf_.begin], allOf_.count);
-                        RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAllOf);
-                    }
-
-            if (anyOf_.schemas) {
-                for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++)
-                    if (context.validators[i]->IsValid())
-                        goto foundAny;
-                context.error_handler.NoneOf(&context.validators[anyOf_.begin], anyOf_.count);
-                RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAnyOf);
-                foundAny:;
-            }
-
-            if (oneOf_.schemas) {
-                bool oneValid = false;
-                for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
-                    if (context.validators[i]->IsValid()) {
-                        if (oneValid) {
-                            context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count, true);
-                            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorOneOfMatch);
-                        } else
-                            oneValid = true;
-                    }
-                if (!oneValid) {
-                    context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count, false);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorOneOf);
-                }
-            }
-
-            if (not_ && context.validators[notValidatorIndex_]->IsValid()) {
-                context.error_handler.Disallowed();
-                RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorNot);
-            }
-        }
-
-        return true;
-    }
-
-    bool Null(Context& context) const {
-        if (!(type_ & (1 << kNullSchemaType))) {
-            DisallowedType(context, GetNullString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
-        }
-        return CreateParallelValidator(context);
-    }
-    
-    bool Bool(Context& context, bool) const {
-        if (!(type_ & (1 << kBooleanSchemaType))) {
-            DisallowedType(context, GetBooleanString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
-        }
-        return CreateParallelValidator(context);
-    }
-
-    bool Int(Context& context, int i) const {
-        if (!CheckInt(context, i))
-            return false;
-        return CreateParallelValidator(context);
-    }
-
-    bool Uint(Context& context, unsigned u) const {
-        if (!CheckUint(context, u))
-            return false;
-        return CreateParallelValidator(context);
-    }
-
-    bool Int64(Context& context, int64_t i) const {
-        if (!CheckInt(context, i))
-            return false;
-        return CreateParallelValidator(context);
-    }
-
-    bool Uint64(Context& context, uint64_t u) const {
-        if (!CheckUint(context, u))
-            return false;
-        return CreateParallelValidator(context);
-    }
-
-    bool Double(Context& context, double d) const {
-        if (!(type_ & (1 << kNumberSchemaType))) {
-            DisallowedType(context, GetNumberString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
-        }
-
-        if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
-            return false;
-
-        if (!maximum_.IsNull() && !CheckDoubleMaximum(context, d))
-            return false;
-        
-        if (!multipleOf_.IsNull() && !CheckDoubleMultipleOf(context, d))
-            return false;
-        
-        return CreateParallelValidator(context);
-    }
-    
-    bool String(Context& context, const Ch* str, SizeType length, bool) const {
-        if (!(type_ & (1 << kStringSchemaType))) {
-            DisallowedType(context, GetStringString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
-        }
-
-        if (minLength_ != 0 || maxLength_ != SizeType(~0)) {
-            SizeType count;
-            if (internal::CountStringCodePoint<EncodingType>(str, length, &count)) {
-                if (count < minLength_) {
-                    context.error_handler.TooShort(str, length, minLength_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMinLength);
-                }
-                if (count > maxLength_) {
-                    context.error_handler.TooLong(str, length, maxLength_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMaxLength);
-                }
-            }
-        }
-
-        if (pattern_ && !IsPatternMatch(pattern_, str, length)) {
-            context.error_handler.DoesNotMatch(str, length);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPattern);
-        }
-
-        return CreateParallelValidator(context);
-    }
-
-    bool StartObject(Context& context) const {
-        if (!(type_ & (1 << kObjectSchemaType))) {
-            DisallowedType(context, GetObjectString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
-        }
-
-        if (hasDependencies_ || hasRequired_) {
-            context.propertyExist = static_cast<bool*>(context.factory.MallocState(sizeof(bool) * propertyCount_));
-            std::memset(context.propertyExist, 0, sizeof(bool) * propertyCount_);
-        }
-
-        if (patternProperties_) { // pre-allocate schema array
-            SizeType count = patternPropertyCount_ + 1; // extra for valuePatternValidatorType
-            context.patternPropertiesSchemas = static_cast<const SchemaType**>(context.factory.MallocState(sizeof(const SchemaType*) * count));
-            context.patternPropertiesSchemaCount = 0;
-            std::memset(context.patternPropertiesSchemas, 0, sizeof(SchemaType*) * count);
-        }
-
-        return CreateParallelValidator(context);
-    }
-    
-    bool Key(Context& context, const Ch* str, SizeType len, bool) const {
-        if (patternProperties_) {
-            context.patternPropertiesSchemaCount = 0;
-            for (SizeType i = 0; i < patternPropertyCount_; i++)
-                if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len)) {
-                    context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema;
-                    context.valueSchema = typeless_;
-                }
-        }
-
-        SizeType index  = 0;
-        if (FindPropertyIndex(ValueType(str, len).Move(), &index)) {
-            if (context.patternPropertiesSchemaCount > 0) {
-                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema;
-                context.valueSchema = typeless_;
-                context.valuePatternValidatorType = Context::kPatternValidatorWithProperty;
-            }
-            else
-                context.valueSchema = properties_[index].schema;
-
-            if (context.propertyExist)
-                context.propertyExist[index] = true;
-
-            return true;
-        }
-
-        if (additionalPropertiesSchema_) {
-            if (context.patternPropertiesSchemaCount > 0) {
-                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_;
-                context.valueSchema = typeless_;
-                context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty;
-            }
-            else
-                context.valueSchema = additionalPropertiesSchema_;
-            return true;
-        }
-        else if (additionalProperties_) {
-            context.valueSchema = typeless_;
-            return true;
-        }
-
-        if (context.patternPropertiesSchemaCount == 0) { // patternProperties are not additional properties
-            // Must set valueSchema for when kValidateContinueOnErrorFlag is set, else reports spurious type error
-            context.valueSchema = typeless_;
-            context.error_handler.DisallowedProperty(str, len);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAdditionalProperties);
-        }
-
-        return true;
-    }
-
-    bool EndObject(Context& context, SizeType memberCount) const {
-        if (hasRequired_) {
-            context.error_handler.StartMissingProperties();
-            for (SizeType index = 0; index < propertyCount_; index++)
-                if (properties_[index].required && !context.propertyExist[index])
-                    if (properties_[index].schema->defaultValueLength_ == 0 )
-                        context.error_handler.AddMissingProperty(properties_[index].name);
-            if (context.error_handler.EndMissingProperties())
-                RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorRequired);
-        }
-
-        if (memberCount < minProperties_) {
-            context.error_handler.TooFewProperties(memberCount, minProperties_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMinProperties);
-        }
-
-        if (memberCount > maxProperties_) {
-            context.error_handler.TooManyProperties(memberCount, maxProperties_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMaxProperties);
-        }
-
-        if (hasDependencies_) {
-            context.error_handler.StartDependencyErrors();
-            for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++) {
-                const Property& source = properties_[sourceIndex];
-                if (context.propertyExist[sourceIndex]) {
-                    if (source.dependencies) {
-                        context.error_handler.StartMissingDependentProperties();
-                        for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
-                            if (source.dependencies[targetIndex] && !context.propertyExist[targetIndex])
-                                context.error_handler.AddMissingDependentProperty(properties_[targetIndex].name);
-                        context.error_handler.EndMissingDependentProperties(source.name);
-                    }
-                    else if (source.dependenciesSchema) {
-                        ISchemaValidator* dependenciesValidator = context.validators[source.dependenciesValidatorIndex];
-                        if (!dependenciesValidator->IsValid())
-                            context.error_handler.AddDependencySchemaError(source.name, dependenciesValidator);
-                    }
-                }
-            }
-            if (context.error_handler.EndDependencyErrors())
-                RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorDependencies);  
-        }
-
-        return true;
-    }
-
-    bool StartArray(Context& context) const {
-        context.arrayElementIndex = 0;
-        context.inArray = true;  // Ensure we note that we are in an array
-
-        if (!(type_ & (1 << kArraySchemaType))) {
-            DisallowedType(context, GetArrayString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
-        }
-
-        return CreateParallelValidator(context);
-    }
-
-    bool EndArray(Context& context, SizeType elementCount) const {
-        context.inArray = false;
-        
-        if (elementCount < minItems_) {
-            context.error_handler.TooFewItems(elementCount, minItems_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMinItems);
-        }
-        
-        if (elementCount > maxItems_) {
-            context.error_handler.TooManyItems(elementCount, maxItems_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMaxItems);
-        }
-
-        return true;
-    }
-
-    static const ValueType& GetValidateErrorKeyword(ValidateErrorCode validateErrorCode) {
-        switch (validateErrorCode) {
-            case kValidateErrorMultipleOf:              return GetMultipleOfString();
-            case kValidateErrorMaximum:                 return GetMaximumString();
-            case kValidateErrorExclusiveMaximum:        return GetMaximumString(); // Same
-            case kValidateErrorMinimum:                 return GetMinimumString();
-            case kValidateErrorExclusiveMinimum:        return GetMinimumString(); // Same
-
-            case kValidateErrorMaxLength:               return GetMaxLengthString();
-            case kValidateErrorMinLength:               return GetMinLengthString();
-            case kValidateErrorPattern:                 return GetPatternString();
-
-            case kValidateErrorMaxItems:                return GetMaxItemsString();
-            case kValidateErrorMinItems:                return GetMinItemsString();
-            case kValidateErrorUniqueItems:             return GetUniqueItemsString();
-            case kValidateErrorAdditionalItems:         return GetAdditionalItemsString();
-
-            case kValidateErrorMaxProperties:           return GetMaxPropertiesString();
-            case kValidateErrorMinProperties:           return GetMinPropertiesString();
-            case kValidateErrorRequired:                return GetRequiredString();
-            case kValidateErrorAdditionalProperties:    return GetAdditionalPropertiesString();
-            case kValidateErrorPatternProperties:       return GetPatternPropertiesString();
-            case kValidateErrorDependencies:            return GetDependenciesString();
-
-            case kValidateErrorEnum:                    return GetEnumString();
-            case kValidateErrorType:                    return GetTypeString();
-
-            case kValidateErrorOneOf:                   return GetOneOfString();
-            case kValidateErrorOneOfMatch:              return GetOneOfString(); // Same
-            case kValidateErrorAllOf:                   return GetAllOfString();
-            case kValidateErrorAnyOf:                   return GetAnyOfString();
-            case kValidateErrorNot:                     return GetNotString();
-
-            default:                                    return GetNullString();
-        }
-    }
-
-
-    // Generate functions for string literal according to Ch
-#define RAPIDJSON_STRING_(name, ...) \
-    static const ValueType& Get##name##String() {\
-        static const Ch s[] = { __VA_ARGS__, '\0' };\
-        static const ValueType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1));\
-        return v;\
-    }
-
-    RAPIDJSON_STRING_(Null, 'n', 'u', 'l', 'l')
-    RAPIDJSON_STRING_(Boolean, 'b', 'o', 'o', 'l', 'e', 'a', 'n')
-    RAPIDJSON_STRING_(Object, 'o', 'b', 'j', 'e', 'c', 't')
-    RAPIDJSON_STRING_(Array, 'a', 'r', 'r', 'a', 'y')
-    RAPIDJSON_STRING_(String, 's', 't', 'r', 'i', 'n', 'g')
-    RAPIDJSON_STRING_(Number, 'n', 'u', 'm', 'b', 'e', 'r')
-    RAPIDJSON_STRING_(Integer, 'i', 'n', 't', 'e', 'g', 'e', 'r')
-    RAPIDJSON_STRING_(Type, 't', 'y', 'p', 'e')
-    RAPIDJSON_STRING_(Enum, 'e', 'n', 'u', 'm')
-    RAPIDJSON_STRING_(AllOf, 'a', 'l', 'l', 'O', 'f')
-    RAPIDJSON_STRING_(AnyOf, 'a', 'n', 'y', 'O', 'f')
-    RAPIDJSON_STRING_(OneOf, 'o', 'n', 'e', 'O', 'f')
-    RAPIDJSON_STRING_(Not, 'n', 'o', 't')
-    RAPIDJSON_STRING_(Properties, 'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-    RAPIDJSON_STRING_(Required, 'r', 'e', 'q', 'u', 'i', 'r', 'e', 'd')
-    RAPIDJSON_STRING_(Dependencies, 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 'c', 'i', 'e', 's')
-    RAPIDJSON_STRING_(PatternProperties, 'p', 'a', 't', 't', 'e', 'r', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-    RAPIDJSON_STRING_(AdditionalProperties, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-    RAPIDJSON_STRING_(MinProperties, 'm', 'i', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-    RAPIDJSON_STRING_(MaxProperties, 'm', 'a', 'x', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-    RAPIDJSON_STRING_(Items, 'i', 't', 'e', 'm', 's')
-    RAPIDJSON_STRING_(MinItems, 'm', 'i', 'n', 'I', 't', 'e', 'm', 's')
-    RAPIDJSON_STRING_(MaxItems, 'm', 'a', 'x', 'I', 't', 'e', 'm', 's')
-    RAPIDJSON_STRING_(AdditionalItems, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'I', 't', 'e', 'm', 's')
-    RAPIDJSON_STRING_(UniqueItems, 'u', 'n', 'i', 'q', 'u', 'e', 'I', 't', 'e', 'm', 's')
-    RAPIDJSON_STRING_(MinLength, 'm', 'i', 'n', 'L', 'e', 'n', 'g', 't', 'h')
-    RAPIDJSON_STRING_(MaxLength, 'm', 'a', 'x', 'L', 'e', 'n', 'g', 't', 'h')
-    RAPIDJSON_STRING_(Pattern, 'p', 'a', 't', 't', 'e', 'r', 'n')
-    RAPIDJSON_STRING_(Minimum, 'm', 'i', 'n', 'i', 'm', 'u', 'm')
-    RAPIDJSON_STRING_(Maximum, 'm', 'a', 'x', 'i', 'm', 'u', 'm')
-    RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm')
-    RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm')
-    RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f')
-    RAPIDJSON_STRING_(DefaultValue, 'd', 'e', 'f', 'a', 'u', 'l', 't')
-
-#undef RAPIDJSON_STRING_
-
-private:
-    enum SchemaValueType {
-        kNullSchemaType,
-        kBooleanSchemaType,
-        kObjectSchemaType,
-        kArraySchemaType,
-        kStringSchemaType,
-        kNumberSchemaType,
-        kIntegerSchemaType,
-        kTotalSchemaType
-    };
-
-#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
-        typedef internal::GenericRegex<EncodingType, AllocatorType> RegexType;
-#elif RAPIDJSON_SCHEMA_USE_STDREGEX
-        typedef std::basic_regex<Ch> RegexType;
-#else
-        typedef char RegexType;
-#endif
-
-    struct SchemaArray {
-        SchemaArray() : schemas(), count() {}
-        ~SchemaArray() { AllocatorType::Free(schemas); }
-        const SchemaType** schemas;
-        SizeType begin; // begin index of context.validators
-        SizeType count;
-    };
-
-    template <typename V1, typename V2>
-    void AddUniqueElement(V1& a, const V2& v) {
-        for (typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
-            if (*itr == v)
-                return;
-        V1 c(v, *allocator_);
-        a.PushBack(c, *allocator_);
-    }
-
-    static const ValueType* GetMember(const ValueType& value, const ValueType& name) {
-        typename ValueType::ConstMemberIterator itr = value.FindMember(name);
-        return itr != value.MemberEnd() ? &(itr->value) : 0;
-    }
-
-    static void AssignIfExist(bool& out, const ValueType& value, const ValueType& name) {
-        if (const ValueType* v = GetMember(value, name))
-            if (v->IsBool())
-                out = v->GetBool();
-    }
-
-    static void AssignIfExist(SizeType& out, const ValueType& value, const ValueType& name) {
-        if (const ValueType* v = GetMember(value, name))
-            if (v->IsUint64() && v->GetUint64() <= SizeType(~0))
-                out = static_cast<SizeType>(v->GetUint64());
-    }
-
-    void AssignIfExist(SchemaArray& out, SchemaDocumentType& schemaDocument, const PointerType& p, const ValueType& value, const ValueType& name, const ValueType& document) {
-        if (const ValueType* v = GetMember(value, name)) {
-            if (v->IsArray() && v->Size() > 0) {
-                PointerType q = p.Append(name, allocator_);
-                out.count = v->Size();
-                out.schemas = static_cast<const Schema**>(allocator_->Malloc(out.count * sizeof(const Schema*)));
-                memset(out.schemas, 0, sizeof(Schema*)* out.count);
-                for (SizeType i = 0; i < out.count; i++)
-                    schemaDocument.CreateSchema(&out.schemas[i], q.Append(i, allocator_), (*v)[i], document);
-                out.begin = validatorCount_;
-                validatorCount_ += out.count;
-            }
-        }
-    }
-
-#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
-    template <typename ValueType>
-    RegexType* CreatePattern(const ValueType& value) {
-        if (value.IsString()) {
-            RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), allocator_);
-            if (!r->IsValid()) {
-                r->~RegexType();
-                AllocatorType::Free(r);
-                r = 0;
-            }
-            return r;
-        }
-        return 0;
-    }
-
-    static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType) {
-        GenericRegexSearch<RegexType> rs(*pattern);
-        return rs.Search(str);
-    }
-#elif RAPIDJSON_SCHEMA_USE_STDREGEX
-    template <typename ValueType>
-    RegexType* CreatePattern(const ValueType& value) {
-        if (value.IsString()) {
-            RegexType *r = static_cast<RegexType*>(allocator_->Malloc(sizeof(RegexType)));
-            try {
-                return new (r) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
-            }
-            catch (const std::regex_error&) {
-                AllocatorType::Free(r);
-            }
-        }
-        return 0;
-    }
-
-    static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType length) {
-        std::match_results<const Ch*> r;
-        return std::regex_search(str, str + length, r, *pattern);
-    }
-#else
-    template <typename ValueType>
-    RegexType* CreatePattern(const ValueType&) { return 0; }
-
-    static bool IsPatternMatch(const RegexType*, const Ch *, SizeType) { return true; }
-#endif // RAPIDJSON_SCHEMA_USE_STDREGEX
-
-    void AddType(const ValueType& type) {
-        if      (type == GetNullString()   ) type_ |= 1 << kNullSchemaType;
-        else if (type == GetBooleanString()) type_ |= 1 << kBooleanSchemaType;
-        else if (type == GetObjectString() ) type_ |= 1 << kObjectSchemaType;
-        else if (type == GetArrayString()  ) type_ |= 1 << kArraySchemaType;
-        else if (type == GetStringString() ) type_ |= 1 << kStringSchemaType;
-        else if (type == GetIntegerString()) type_ |= 1 << kIntegerSchemaType;
-        else if (type == GetNumberString() ) type_ |= (1 << kNumberSchemaType) | (1 << kIntegerSchemaType);
-    }
-
-    bool CreateParallelValidator(Context& context) const {
-        if (enum_ || context.arrayUniqueness)
-            context.hasher = context.factory.CreateHasher();
-
-        if (validatorCount_) {
-            RAPIDJSON_ASSERT(context.validators == 0);
-            context.validators = static_cast<ISchemaValidator**>(context.factory.MallocState(sizeof(ISchemaValidator*) * validatorCount_));
-            context.validatorCount = validatorCount_;
-
-            // Always return after first failure for these sub-validators
-            if (allOf_.schemas)
-                CreateSchemaValidators(context, allOf_, false);
-
-            if (anyOf_.schemas)
-                CreateSchemaValidators(context, anyOf_, false);
-            
-            if (oneOf_.schemas)
-                CreateSchemaValidators(context, oneOf_, false);
-            
-            if (not_)
-                context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_, false);
-
-            if (hasSchemaDependencies_) {
-                for (SizeType i = 0; i < propertyCount_; i++)
-                    if (properties_[i].dependenciesSchema)
-                        context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema, false);
-            }
-        }
-
-        return true;
-    }
-
-    void CreateSchemaValidators(Context& context, const SchemaArray& schemas, const bool inheritContinueOnErrors) const {
-        for (SizeType i = 0; i < schemas.count; i++)
-            context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i], inheritContinueOnErrors);
-    }
-
-    // O(n)
-    bool FindPropertyIndex(const ValueType& name, SizeType* outIndex) const {
-        SizeType len = name.GetStringLength();
-        const Ch* str = name.GetString();
-        for (SizeType index = 0; index < propertyCount_; index++)
-            if (properties_[index].name.GetStringLength() == len && 
-                (std::memcmp(properties_[index].name.GetString(), str, sizeof(Ch) * len) == 0))
-            {
-                *outIndex = index;
-                return true;
-            }
-        return false;
-    }
-
-    bool CheckInt(Context& context, int64_t i) const {
-        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
-            DisallowedType(context, GetIntegerString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
-        }
-
-        if (!minimum_.IsNull()) {
-            if (minimum_.IsInt64()) {
-                if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64()) {
-                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum);
-                }
-            }
-            else if (minimum_.IsUint64()) {
-                context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
-                RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum); // i <= max(int64_t) < minimum.GetUint64()
-            }
-            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
-                return false;
-        }
-
-        if (!maximum_.IsNull()) {
-            if (maximum_.IsInt64()) {
-                if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64()) {
-                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum);
-                }
-            }
-            else if (maximum_.IsUint64()) { }
-                /* do nothing */ // i <= max(int64_t) < maximum_.GetUint64()
-            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
-                return false;
-        }
-
-        if (!multipleOf_.IsNull()) {
-            if (multipleOf_.IsUint64()) {
-                if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0) {
-                    context.error_handler.NotMultipleOf(i, multipleOf_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMultipleOf);
-                }
-            }
-            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
-                return false;
-        }
-
-        return true;
-    }
-
-    bool CheckUint(Context& context, uint64_t i) const {
-        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
-            DisallowedType(context, GetIntegerString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
-        }
-
-        if (!minimum_.IsNull()) {
-            if (minimum_.IsUint64()) {
-                if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64()) {
-                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum);
-                }
-            }
-            else if (minimum_.IsInt64())
-                /* do nothing */; // i >= 0 > minimum.Getint64()
-            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
-                return false;
-        }
-
-        if (!maximum_.IsNull()) {
-            if (maximum_.IsUint64()) {
-                if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64()) {
-                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum);
-                }
-            }
-            else if (maximum_.IsInt64()) {
-                context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
-                RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum); // i >= 0 > maximum_
-            }
-            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
-                return false;
-        }
-
-        if (!multipleOf_.IsNull()) {
-            if (multipleOf_.IsUint64()) {
-                if (i % multipleOf_.GetUint64() != 0) {
-                    context.error_handler.NotMultipleOf(i, multipleOf_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMultipleOf);
-                }
-            }
-            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
-                return false;
-        }
-
-        return true;
-    }
-
-    bool CheckDoubleMinimum(Context& context, double d) const {
-        if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble()) {
-            context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum);
-        }
-        return true;
-    }
-
-    bool CheckDoubleMaximum(Context& context, double d) const {
-        if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble()) {
-            context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum);
-        }
-        return true;
-    }
-
-    bool CheckDoubleMultipleOf(Context& context, double d) const {
-        double a = std::abs(d), b = std::abs(multipleOf_.GetDouble());
-        double q = std::floor(a / b);
-        double r = a - q * b;
-        if (r > 0.0) {
-            context.error_handler.NotMultipleOf(d, multipleOf_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMultipleOf);
-        }
-        return true;
-    }
-
-    void DisallowedType(Context& context, const ValueType& actualType) const {
-        ErrorHandler& eh = context.error_handler;
-        eh.StartDisallowedType();
-
-        if (type_ & (1 << kNullSchemaType)) eh.AddExpectedType(GetNullString());
-        if (type_ & (1 << kBooleanSchemaType)) eh.AddExpectedType(GetBooleanString());
-        if (type_ & (1 << kObjectSchemaType)) eh.AddExpectedType(GetObjectString());
-        if (type_ & (1 << kArraySchemaType)) eh.AddExpectedType(GetArrayString());
-        if (type_ & (1 << kStringSchemaType)) eh.AddExpectedType(GetStringString());
-
-        if (type_ & (1 << kNumberSchemaType)) eh.AddExpectedType(GetNumberString());
-        else if (type_ & (1 << kIntegerSchemaType)) eh.AddExpectedType(GetIntegerString());
-
-        eh.EndDisallowedType(actualType);
-    }
-
-    struct Property {
-        Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {}
-        ~Property() { AllocatorType::Free(dependencies); }
-        SValue name;
-        const SchemaType* schema;
-        const SchemaType* dependenciesSchema;
-        SizeType dependenciesValidatorIndex;
-        bool* dependencies;
-        bool required;
-    };
-
-    struct PatternProperty {
-        PatternProperty() : schema(), pattern() {}
-        ~PatternProperty() { 
-            if (pattern) {
-                pattern->~RegexType();
-                AllocatorType::Free(pattern);
-            }
-        }
-        const SchemaType* schema;
-        RegexType* pattern;
-    };
-
-    AllocatorType* allocator_;
-    SValue uri_;
-    PointerType pointer_;
-    const SchemaType* typeless_;
-    uint64_t* enum_;
-    SizeType enumCount_;
-    SchemaArray allOf_;
-    SchemaArray anyOf_;
-    SchemaArray oneOf_;
-    const SchemaType* not_;
-    unsigned type_; // bitmask of kSchemaType
-    SizeType validatorCount_;
-    SizeType notValidatorIndex_;
-
-    Property* properties_;
-    const SchemaType* additionalPropertiesSchema_;
-    PatternProperty* patternProperties_;
-    SizeType patternPropertyCount_;
-    SizeType propertyCount_;
-    SizeType minProperties_;
-    SizeType maxProperties_;
-    bool additionalProperties_;
-    bool hasDependencies_;
-    bool hasRequired_;
-    bool hasSchemaDependencies_;
-
-    const SchemaType* additionalItemsSchema_;
-    const SchemaType* itemsList_;
-    const SchemaType** itemsTuple_;
-    SizeType itemsTupleCount_;
-    SizeType minItems_;
-    SizeType maxItems_;
-    bool additionalItems_;
-    bool uniqueItems_;
-
-    RegexType* pattern_;
-    SizeType minLength_;
-    SizeType maxLength_;
-
-    SValue minimum_;
-    SValue maximum_;
-    SValue multipleOf_;
-    bool exclusiveMinimum_;
-    bool exclusiveMaximum_;
-    
-    SizeType defaultValueLength_;
-};
-
-template<typename Stack, typename Ch>
-struct TokenHelper {
-    RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) {
-        *documentStack.template Push<Ch>() = '/';
-        char buffer[21];
-        size_t length = static_cast<size_t>((sizeof(SizeType) == 4 ? u32toa(index, buffer) : u64toa(index, buffer)) - buffer);
-        for (size_t i = 0; i < length; i++)
-            *documentStack.template Push<Ch>() = static_cast<Ch>(buffer[i]);
-    }
-};
-
-// Partial specialized version for char to prevent buffer copying.
-template <typename Stack>
-struct TokenHelper<Stack, char> {
-    RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) {
-        if (sizeof(SizeType) == 4) {
-            char *buffer = documentStack.template Push<char>(1 + 10); // '/' + uint
-            *buffer++ = '/';
-            const char* end = internal::u32toa(index, buffer);
-             documentStack.template Pop<char>(static_cast<size_t>(10 - (end - buffer)));
-        }
-        else {
-            char *buffer = documentStack.template Push<char>(1 + 20); // '/' + uint64
-            *buffer++ = '/';
-            const char* end = internal::u64toa(index, buffer);
-            documentStack.template Pop<char>(static_cast<size_t>(20 - (end - buffer)));
-        }
-    }
-};
-
-} // namespace internal
-
-///////////////////////////////////////////////////////////////////////////////
-// IGenericRemoteSchemaDocumentProvider
-
-template <typename SchemaDocumentType>
-class IGenericRemoteSchemaDocumentProvider {
-public:
-    typedef typename SchemaDocumentType::Ch Ch;
-
-    virtual ~IGenericRemoteSchemaDocumentProvider() {}
-    virtual const SchemaDocumentType* GetRemoteDocument(const Ch* uri, SizeType length) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericSchemaDocument
-
-//! JSON schema document.
-/*!
-    A JSON schema document is a compiled version of a JSON schema.
-    It is basically a tree of internal::Schema.
-
-    \note This is an immutable class (i.e. its instance cannot be modified after construction).
-    \tparam ValueT Type of JSON value (e.g. \c Value ), which also determine the encoding.
-    \tparam Allocator Allocator type for allocating memory of this document.
-*/
-template <typename ValueT, typename Allocator = CrtAllocator>
-class GenericSchemaDocument {
-public:
-    typedef ValueT ValueType;
-    typedef IGenericRemoteSchemaDocumentProvider<GenericSchemaDocument> IRemoteSchemaDocumentProviderType;
-    typedef Allocator AllocatorType;
-    typedef typename ValueType::EncodingType EncodingType;
-    typedef typename EncodingType::Ch Ch;
-    typedef internal::Schema<GenericSchemaDocument> SchemaType;
-    typedef GenericPointer<ValueType, Allocator> PointerType;
-    typedef GenericValue<EncodingType, Allocator> URIType;
-    friend class internal::Schema<GenericSchemaDocument>;
-    template <typename, typename, typename>
-    friend class GenericSchemaValidator;
-
-    //! Constructor.
-    /*!
-        Compile a JSON document into schema document.
-
-        \param document A JSON document as source.
-        \param uri The base URI of this schema document for purposes of violation reporting.
-        \param uriLength Length of \c name, in code points.
-        \param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null.
-        \param allocator An optional allocator instance for allocating memory. Can be null.
-    */
-    explicit GenericSchemaDocument(const ValueType& document, const Ch* uri = 0, SizeType uriLength = 0,
-        IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) :
-        remoteProvider_(remoteProvider),
-        allocator_(allocator),
-        ownAllocator_(),
-        root_(),
-        typeless_(),
-        schemaMap_(allocator, kInitialSchemaMapSize),
-        schemaRef_(allocator, kInitialSchemaRefSize)
-    {
-        if (!allocator_)
-            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-
-        Ch noUri[1] = {0};
-        uri_.SetString(uri ? uri : noUri, uriLength, *allocator_);
-
-        typeless_ = static_cast<SchemaType*>(allocator_->Malloc(sizeof(SchemaType)));
-        new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_);
-
-        // Generate root schema, it will call CreateSchema() to create sub-schemas,
-        // And call AddRefSchema() if there are $ref.
-        CreateSchemaRecursive(&root_, PointerType(), document, document);
-
-        // Resolve $ref
-        while (!schemaRef_.Empty()) {
-            SchemaRefEntry* refEntry = schemaRef_.template Pop<SchemaRefEntry>(1);
-            if (const SchemaType* s = GetSchema(refEntry->target)) {
-                if (refEntry->schema)
-                    *refEntry->schema = s;
-
-                // Create entry in map if not exist
-                if (!GetSchema(refEntry->source)) {
-                    new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(refEntry->source, const_cast<SchemaType*>(s), false, allocator_);
-                }
-            }
-            else if (refEntry->schema)
-                *refEntry->schema = typeless_;
-
-            refEntry->~SchemaRefEntry();
-        }
-
-        RAPIDJSON_ASSERT(root_ != 0);
-
-        schemaRef_.ShrinkToFit(); // Deallocate all memory for ref
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move constructor in C++11
-    GenericSchemaDocument(GenericSchemaDocument&& rhs) RAPIDJSON_NOEXCEPT :
-        remoteProvider_(rhs.remoteProvider_),
-        allocator_(rhs.allocator_),
-        ownAllocator_(rhs.ownAllocator_),
-        root_(rhs.root_),
-        typeless_(rhs.typeless_),
-        schemaMap_(std::move(rhs.schemaMap_)),
-        schemaRef_(std::move(rhs.schemaRef_)),
-        uri_(std::move(rhs.uri_))
-    {
-        rhs.remoteProvider_ = 0;
-        rhs.allocator_ = 0;
-        rhs.ownAllocator_ = 0;
-        rhs.typeless_ = 0;
-    }
-#endif
-
-    //! Destructor
-    ~GenericSchemaDocument() {
-        while (!schemaMap_.Empty())
-            schemaMap_.template Pop<SchemaEntry>(1)->~SchemaEntry();
-
-        if (typeless_) {
-            typeless_->~SchemaType();
-            Allocator::Free(typeless_);
-        }
-
-        RAPIDJSON_DELETE(ownAllocator_);
-    }
-
-    const URIType& GetURI() const { return uri_; }
-
-    //! Get the root schema.
-    const SchemaType& GetRoot() const { return *root_; }
-
-private:
-    //! Prohibit copying
-    GenericSchemaDocument(const GenericSchemaDocument&);
-    //! Prohibit assignment
-    GenericSchemaDocument& operator=(const GenericSchemaDocument&);
-
-    struct SchemaRefEntry {
-        SchemaRefEntry(const PointerType& s, const PointerType& t, const SchemaType** outSchema, Allocator *allocator) : source(s, allocator), target(t, allocator), schema(outSchema) {}
-        PointerType source;
-        PointerType target;
-        const SchemaType** schema;
-    };
-
-    struct SchemaEntry {
-        SchemaEntry(const PointerType& p, SchemaType* s, bool o, Allocator* allocator) : pointer(p, allocator), schema(s), owned(o) {}
-        ~SchemaEntry() {
-            if (owned) {
-                schema->~SchemaType();
-                Allocator::Free(schema);
-            }
-        }
-        PointerType pointer;
-        SchemaType* schema;
-        bool owned;
-    };
-
-    void CreateSchemaRecursive(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) {
-        if (schema)
-            *schema = typeless_;
-
-        if (v.GetType() == kObjectType) {
-            const SchemaType* s = GetSchema(pointer);
-            if (!s)
-                CreateSchema(schema, pointer, v, document);
-
-            for (typename ValueType::ConstMemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr)
-                CreateSchemaRecursive(0, pointer.Append(itr->name, allocator_), itr->value, document);
-        }
-        else if (v.GetType() == kArrayType)
-            for (SizeType i = 0; i < v.Size(); i++)
-                CreateSchemaRecursive(0, pointer.Append(i, allocator_), v[i], document);
-    }
-
-    void CreateSchema(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) {
-        RAPIDJSON_ASSERT(pointer.IsValid());
-        if (v.IsObject()) {
-            if (!HandleRefSchema(pointer, schema, v, document)) {
-                SchemaType* s = new (allocator_->Malloc(sizeof(SchemaType))) SchemaType(this, pointer, v, document, allocator_);
-                new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(pointer, s, true, allocator_);
-                if (schema)
-                    *schema = s;
-            }
-        }
-    }
-
-    bool HandleRefSchema(const PointerType& source, const SchemaType** schema, const ValueType& v, const ValueType& document) {
-        static const Ch kRefString[] = { '$', 'r', 'e', 'f', '\0' };
-        static const ValueType kRefValue(kRefString, 4);
-
-        typename ValueType::ConstMemberIterator itr = v.FindMember(kRefValue);
-        if (itr == v.MemberEnd())
-            return false;
-
-        if (itr->value.IsString()) {
-            SizeType len = itr->value.GetStringLength();
-            if (len > 0) {
-                const Ch* s = itr->value.GetString();
-                SizeType i = 0;
-                while (i < len && s[i] != '#') // Find the first #
-                    i++;
-
-                if (i > 0) { // Remote reference, resolve immediately
-                    if (remoteProvider_) {
-                        if (const GenericSchemaDocument* remoteDocument = remoteProvider_->GetRemoteDocument(s, i)) {
-                            PointerType pointer(&s[i], len - i, allocator_);
-                            if (pointer.IsValid()) {
-                                if (const SchemaType* sc = remoteDocument->GetSchema(pointer)) {
-                                    if (schema)
-                                        *schema = sc;
-                                    new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(source, const_cast<SchemaType*>(sc), false, allocator_);
-                                    return true;
-                                }
-                            }
-                        }
-                    }
-                }
-                else if (s[i] == '#') { // Local reference, defer resolution
-                    PointerType pointer(&s[i], len - i, allocator_);
-                    if (pointer.IsValid()) {
-                        if (const ValueType* nv = pointer.Get(document))
-                            if (HandleRefSchema(source, schema, *nv, document))
-                                return true;
-
-                        new (schemaRef_.template Push<SchemaRefEntry>()) SchemaRefEntry(source, pointer, schema, allocator_);
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-
-    const SchemaType* GetSchema(const PointerType& pointer) const {
-        for (const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
-            if (pointer == target->pointer)
-                return target->schema;
-        return 0;
-    }
-
-    PointerType GetPointer(const SchemaType* schema) const {
-        for (const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
-            if (schema == target->schema)
-                return target->pointer;
-        return PointerType();
-    }
-
-    const SchemaType* GetTypeless() const { return typeless_; }
-
-    static const size_t kInitialSchemaMapSize = 64;
-    static const size_t kInitialSchemaRefSize = 64;
-
-    IRemoteSchemaDocumentProviderType* remoteProvider_;
-    Allocator *allocator_;
-    Allocator *ownAllocator_;
-    const SchemaType* root_;                //!< Root schema.
-    SchemaType* typeless_;
-    internal::Stack<Allocator> schemaMap_;  // Stores created Pointer -> Schemas
-    internal::Stack<Allocator> schemaRef_;  // Stores Pointer from $ref and schema which holds the $ref
-    URIType uri_;
-};
-
-//! GenericSchemaDocument using Value type.
-typedef GenericSchemaDocument<Value> SchemaDocument;
-//! IGenericRemoteSchemaDocumentProvider using SchemaDocument.
-typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericSchemaValidator
-
-//! JSON Schema Validator.
-/*!
-    A SAX style JSON schema validator.
-    It uses a \c GenericSchemaDocument to validate SAX events.
-    It delegates the incoming SAX events to an output handler.
-    The default output handler does nothing.
-    It can be reused multiple times by calling \c Reset().
-
-    \tparam SchemaDocumentType Type of schema document.
-    \tparam OutputHandler Type of output handler. Default handler does nothing.
-    \tparam StateAllocator Allocator for storing the internal validation states.
-*/
-template <
-    typename SchemaDocumentType,
-    typename OutputHandler = BaseReaderHandler<typename SchemaDocumentType::SchemaType::EncodingType>,
-    typename StateAllocator = CrtAllocator>
-class GenericSchemaValidator :
-    public internal::ISchemaStateFactory<typename SchemaDocumentType::SchemaType>, 
-    public internal::ISchemaValidator,
-    public internal::IValidationErrorHandler<typename SchemaDocumentType::SchemaType> {
-public:
-    typedef typename SchemaDocumentType::SchemaType SchemaType;
-    typedef typename SchemaDocumentType::PointerType PointerType;
-    typedef typename SchemaType::EncodingType EncodingType;
-    typedef typename SchemaType::SValue SValue;
-    typedef typename EncodingType::Ch Ch;
-    typedef GenericStringRef<Ch> StringRefType;
-    typedef GenericValue<EncodingType, StateAllocator> ValueType;
-
-    //! Constructor without output handler.
-    /*!
-        \param schemaDocument The schema document to conform to.
-        \param allocator Optional allocator for storing internal validation states.
-        \param schemaStackCapacity Optional initial capacity of schema path stack.
-        \param documentStackCapacity Optional initial capacity of document path stack.
-    */
-    GenericSchemaValidator(
-        const SchemaDocumentType& schemaDocument,
-        StateAllocator* allocator = 0, 
-        size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
-        size_t documentStackCapacity = kDefaultDocumentStackCapacity)
-        :
-        schemaDocument_(&schemaDocument),
-        root_(schemaDocument.GetRoot()),
-        stateAllocator_(allocator),
-        ownStateAllocator_(0),
-        schemaStack_(allocator, schemaStackCapacity),
-        documentStack_(allocator, documentStackCapacity),
-        outputHandler_(0),
-        error_(kObjectType),
-        currentError_(),
-        missingDependents_(),
-        valid_(true),
-        flags_(kValidateDefaultFlags)
-#if RAPIDJSON_SCHEMA_VERBOSE
-        , depth_(0)
-#endif
-    {
-    }
-
-    //! Constructor with output handler.
-    /*!
-        \param schemaDocument The schema document to conform to.
-        \param allocator Optional allocator for storing internal validation states.
-        \param schemaStackCapacity Optional initial capacity of schema path stack.
-        \param documentStackCapacity Optional initial capacity of document path stack.
-    */
-    GenericSchemaValidator(
-        const SchemaDocumentType& schemaDocument,
-        OutputHandler& outputHandler,
-        StateAllocator* allocator = 0, 
-        size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
-        size_t documentStackCapacity = kDefaultDocumentStackCapacity)
-        :
-        schemaDocument_(&schemaDocument),
-        root_(schemaDocument.GetRoot()),
-        stateAllocator_(allocator),
-        ownStateAllocator_(0),
-        schemaStack_(allocator, schemaStackCapacity),
-        documentStack_(allocator, documentStackCapacity),
-        outputHandler_(&outputHandler),
-        error_(kObjectType),
-        currentError_(),
-        missingDependents_(),
-        valid_(true),
-        flags_(kValidateDefaultFlags)
-#if RAPIDJSON_SCHEMA_VERBOSE
-        , depth_(0)
-#endif
-    {
-    }
-
-    //! Destructor.
-    ~GenericSchemaValidator() {
-        Reset();
-        RAPIDJSON_DELETE(ownStateAllocator_);
-    }
-
-    //! Reset the internal states.
-    void Reset() {
-        while (!schemaStack_.Empty())
-            PopSchema();
-        documentStack_.Clear();
-        ResetError();
-    }
-
-    //! Reset the error state.
-    void ResetError() {
-        error_.SetObject();
-        currentError_.SetNull();
-        missingDependents_.SetNull();
-        valid_ = true;
-    }
-
-    //! Implementation of ISchemaValidator
-    void SetValidateFlags(unsigned flags) {
-        flags_ = flags;
-    }
-    virtual unsigned GetValidateFlags() const {
-        return flags_;
-    }
-
-    //! Checks whether the current state is valid.
-    // Implementation of ISchemaValidator
-    virtual bool IsValid() const {
-        if (!valid_) return false;
-        if (GetContinueOnErrors() && !error_.ObjectEmpty()) return false;
-        return true;
-    }
-
-    //! Gets the error object.
-    ValueType& GetError() { return error_; }
-    const ValueType& GetError() const { return error_; }
-
-    //! Gets the JSON pointer pointed to the invalid schema.
-    //  If reporting all errors, the stack will be empty.
-    PointerType GetInvalidSchemaPointer() const {
-        return schemaStack_.Empty() ? PointerType() : CurrentSchema().GetPointer();
-    }
-
-    //! Gets the keyword of invalid schema.
-    //  If reporting all errors, the stack will be empty, so return "errors".
-    const Ch* GetInvalidSchemaKeyword() const {
-        if (!schemaStack_.Empty()) return CurrentContext().invalidKeyword;
-        if (GetContinueOnErrors() && !error_.ObjectEmpty()) return (const Ch*)GetErrorsString();
-        return 0;
-    }
-
-    //! Gets the error code of invalid schema.
-    //  If reporting all errors, the stack will be empty, so return kValidateErrors.
-    ValidateErrorCode GetInvalidSchemaCode() const {
-        if (!schemaStack_.Empty()) return CurrentContext().invalidCode;
-        if (GetContinueOnErrors() && !error_.ObjectEmpty()) return kValidateErrors;
-        return kValidateErrorNone;
-    }
-
-    //! Gets the JSON pointer pointed to the invalid value.
-    //  If reporting all errors, the stack will be empty.
-    PointerType GetInvalidDocumentPointer() const {
-        if (documentStack_.Empty()) {
-            return PointerType();
-        }
-        else {
-            return PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
-        }
-    }
-
-    void NotMultipleOf(int64_t actual, const SValue& expected) {
-        AddNumberError(kValidateErrorMultipleOf, ValueType(actual).Move(), expected);
-    }
-    void NotMultipleOf(uint64_t actual, const SValue& expected) {
-        AddNumberError(kValidateErrorMultipleOf, ValueType(actual).Move(), expected);
-    }
-    void NotMultipleOf(double actual, const SValue& expected) {
-        AddNumberError(kValidateErrorMultipleOf, ValueType(actual).Move(), expected);
-    }
-    void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) {
-        AddNumberError(exclusive ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum, ValueType(actual).Move(), expected,
-            exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
-    }
-    void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) {
-        AddNumberError(exclusive ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum, ValueType(actual).Move(), expected,
-            exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
-    }
-    void AboveMaximum(double actual, const SValue& expected, bool exclusive) {
-        AddNumberError(exclusive ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum, ValueType(actual).Move(), expected,
-            exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
-    }
-    void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) {
-        AddNumberError(exclusive ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum, ValueType(actual).Move(), expected,
-            exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
-    }
-    void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) {
-        AddNumberError(exclusive ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum, ValueType(actual).Move(), expected,
-            exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
-    }
-    void BelowMinimum(double actual, const SValue& expected, bool exclusive) {
-        AddNumberError(exclusive ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum, ValueType(actual).Move(), expected,
-            exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
-    }
-
-    void TooLong(const Ch* str, SizeType length, SizeType expected) {
-        AddNumberError(kValidateErrorMaxLength,
-            ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
-    }
-    void TooShort(const Ch* str, SizeType length, SizeType expected) {
-        AddNumberError(kValidateErrorMinLength,
-            ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
-    }
-    void DoesNotMatch(const Ch* str, SizeType length) {
-        currentError_.SetObject();
-        currentError_.AddMember(GetActualString(), ValueType(str, length, GetStateAllocator()).Move(), GetStateAllocator());
-        AddCurrentError(kValidateErrorPattern);
-    }
-
-    void DisallowedItem(SizeType index) {
-        currentError_.SetObject();
-        currentError_.AddMember(GetDisallowedString(), ValueType(index).Move(), GetStateAllocator());
-        AddCurrentError(kValidateErrorAdditionalItems, true);
-    }
-    void TooFewItems(SizeType actualCount, SizeType expectedCount) {
-        AddNumberError(kValidateErrorMinItems,
-            ValueType(actualCount).Move(), SValue(expectedCount).Move());
-    }
-    void TooManyItems(SizeType actualCount, SizeType expectedCount) {
-        AddNumberError(kValidateErrorMaxItems,
-            ValueType(actualCount).Move(), SValue(expectedCount).Move());
-    }
-    void DuplicateItems(SizeType index1, SizeType index2) {
-        ValueType duplicates(kArrayType);
-        duplicates.PushBack(index1, GetStateAllocator());
-        duplicates.PushBack(index2, GetStateAllocator());
-        currentError_.SetObject();
-        currentError_.AddMember(GetDuplicatesString(), duplicates, GetStateAllocator());
-        AddCurrentError(kValidateErrorUniqueItems, true);
-    }
-
-    void TooManyProperties(SizeType actualCount, SizeType expectedCount) {
-        AddNumberError(kValidateErrorMaxProperties,
-            ValueType(actualCount).Move(), SValue(expectedCount).Move());
-    }
-    void TooFewProperties(SizeType actualCount, SizeType expectedCount) {
-        AddNumberError(kValidateErrorMinProperties,
-            ValueType(actualCount).Move(), SValue(expectedCount).Move());
-    }
-    void StartMissingProperties() {
-        currentError_.SetArray();
-    }
-    void AddMissingProperty(const SValue& name) {
-        currentError_.PushBack(ValueType(name, GetStateAllocator()).Move(), GetStateAllocator());
-    }
-    bool EndMissingProperties() {
-        if (currentError_.Empty())
-            return false;
-        ValueType error(kObjectType);
-        error.AddMember(GetMissingString(), currentError_, GetStateAllocator());
-        currentError_ = error;
-        AddCurrentError(kValidateErrorRequired);
-        return true;
-    }
-    void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) {
-        for (SizeType i = 0; i < count; ++i)
-            MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
-    }
-    void DisallowedProperty(const Ch* name, SizeType length) {
-        currentError_.SetObject();
-        currentError_.AddMember(GetDisallowedString(), ValueType(name, length, GetStateAllocator()).Move(), GetStateAllocator());
-        AddCurrentError(kValidateErrorAdditionalProperties, true);
-    }
-
-    void StartDependencyErrors() {
-        currentError_.SetObject();
-    }
-    void StartMissingDependentProperties() {
-        missingDependents_.SetArray();
-    }
-    void AddMissingDependentProperty(const SValue& targetName) {
-        missingDependents_.PushBack(ValueType(targetName, GetStateAllocator()).Move(), GetStateAllocator());
-    }
-    void EndMissingDependentProperties(const SValue& sourceName) {
-        if (!missingDependents_.Empty()) {
-            // Create equivalent 'required' error
-            ValueType error(kObjectType);
-            ValidateErrorCode code = kValidateErrorRequired;
-            error.AddMember(GetMissingString(), missingDependents_.Move(), GetStateAllocator());
-            AddErrorCode(error, code);
-            AddErrorInstanceLocation(error, false);
-            // When appending to a pointer ensure its allocator is used
-            PointerType schemaRef = GetInvalidSchemaPointer().Append(SchemaType::GetValidateErrorKeyword(kValidateErrorDependencies), &GetInvalidSchemaPointer().GetAllocator());
-            AddErrorSchemaLocation(error, schemaRef.Append(sourceName.GetString(), sourceName.GetStringLength(), &GetInvalidSchemaPointer().GetAllocator()));
-            ValueType wrapper(kObjectType);
-            wrapper.AddMember(ValueType(SchemaType::GetValidateErrorKeyword(code), GetStateAllocator()).Move(), error, GetStateAllocator());
-            currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(), wrapper, GetStateAllocator());
-        }
-    }
-    void AddDependencySchemaError(const SValue& sourceName, ISchemaValidator* subvalidator) {
-        currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
-            static_cast<GenericSchemaValidator*>(subvalidator)->GetError(), GetStateAllocator());
-    }
-    bool EndDependencyErrors() {
-        if (currentError_.ObjectEmpty())
-            return false;
-        ValueType error(kObjectType);
-        error.AddMember(GetErrorsString(), currentError_, GetStateAllocator());
-        currentError_ = error;
-        AddCurrentError(kValidateErrorDependencies);
-        return true;
-    }
-
-    void DisallowedValue(const ValidateErrorCode code = kValidateErrorEnum) {
-        currentError_.SetObject();
-        AddCurrentError(code);
-    }
-    void StartDisallowedType() {
-        currentError_.SetArray();
-    }
-    void AddExpectedType(const typename SchemaType::ValueType& expectedType) {
-        currentError_.PushBack(ValueType(expectedType, GetStateAllocator()).Move(), GetStateAllocator());
-    }
-    void EndDisallowedType(const typename SchemaType::ValueType& actualType) {
-        ValueType error(kObjectType);
-        error.AddMember(GetExpectedString(), currentError_, GetStateAllocator());
-        error.AddMember(GetActualString(), ValueType(actualType, GetStateAllocator()).Move(), GetStateAllocator());
-        currentError_ = error;
-        AddCurrentError(kValidateErrorType);
-    }
-    void NotAllOf(ISchemaValidator** subvalidators, SizeType count) {
-        // Treat allOf like oneOf and anyOf to match https://rapidjson.org/md_doc_schema.html#allOf-anyOf-oneOf
-        AddErrorArray(kValidateErrorAllOf, subvalidators, count);
-        //for (SizeType i = 0; i < count; ++i) {
-        //    MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
-        //}
-    }
-    void NoneOf(ISchemaValidator** subvalidators, SizeType count) {
-        AddErrorArray(kValidateErrorAnyOf, subvalidators, count);
-    }
-    void NotOneOf(ISchemaValidator** subvalidators, SizeType count, bool matched = false) {
-        AddErrorArray(matched ? kValidateErrorOneOfMatch : kValidateErrorOneOf, subvalidators, count);
-    }
-    void Disallowed() {
-        currentError_.SetObject();
-        AddCurrentError(kValidateErrorNot);
-    }
-
-#define RAPIDJSON_STRING_(name, ...) \
-    static const StringRefType& Get##name##String() {\
-        static const Ch s[] = { __VA_ARGS__, '\0' };\
-        static const StringRefType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1)); \
-        return v;\
-    }
-
-    RAPIDJSON_STRING_(InstanceRef, 'i', 'n', 's', 't', 'a', 'n', 'c', 'e', 'R', 'e', 'f')
-    RAPIDJSON_STRING_(SchemaRef, 's', 'c', 'h', 'e', 'm', 'a', 'R', 'e', 'f')
-    RAPIDJSON_STRING_(Expected, 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd')
-    RAPIDJSON_STRING_(Actual, 'a', 'c', 't', 'u', 'a', 'l')
-    RAPIDJSON_STRING_(Disallowed, 'd', 'i', 's', 'a', 'l', 'l', 'o', 'w', 'e', 'd')
-    RAPIDJSON_STRING_(Missing, 'm', 'i', 's', 's', 'i', 'n', 'g')
-    RAPIDJSON_STRING_(Errors, 'e', 'r', 'r', 'o', 'r', 's')
-    RAPIDJSON_STRING_(ErrorCode, 'e', 'r', 'r', 'o', 'r', 'C', 'o', 'd', 'e')
-    RAPIDJSON_STRING_(ErrorMessage, 'e', 'r', 'r', 'o', 'r', 'M', 'e', 's', 's', 'a', 'g', 'e')
-    RAPIDJSON_STRING_(Duplicates, 'd', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e', 's')
-
-#undef RAPIDJSON_STRING_
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \
-RAPIDJSON_MULTILINEMACRO_BEGIN\
-    *documentStack_.template Push<Ch>() = '\0';\
-    documentStack_.template Pop<Ch>(1);\
-    internal::PrintInvalidDocument(documentStack_.template Bottom<Ch>());\
-RAPIDJSON_MULTILINEMACRO_END
-#else
-#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_()
-#endif
-
-#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_(method, arg1)\
-    if (!valid_) return false; \
-    if ((!BeginValue() && !GetContinueOnErrors()) || (!CurrentSchema().method arg1 && !GetContinueOnErrors())) {\
-        RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_();\
-        return valid_ = false;\
-    }
-
-#define RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2)\
-    for (Context* context = schemaStack_.template Bottom<Context>(); context != schemaStack_.template End<Context>(); context++) {\
-        if (context->hasher)\
-            static_cast<HasherType*>(context->hasher)->method arg2;\
-        if (context->validators)\
-            for (SizeType i_ = 0; i_ < context->validatorCount; i_++)\
-                static_cast<GenericSchemaValidator*>(context->validators[i_])->method arg2;\
-        if (context->patternPropertiesValidators)\
-            for (SizeType i_ = 0; i_ < context->patternPropertiesValidatorCount; i_++)\
-                static_cast<GenericSchemaValidator*>(context->patternPropertiesValidators[i_])->method arg2;\
-    }
-
-#define RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\
-    valid_ = (EndValue() || GetContinueOnErrors()) && (!outputHandler_ || outputHandler_->method arg2);\
-    return valid_;
-
-#define RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \
-    RAPIDJSON_SCHEMA_HANDLE_BEGIN_   (method, arg1);\
-    RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\
-    RAPIDJSON_SCHEMA_HANDLE_END_     (method, arg2)
-
-    bool Null()             { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null,   (CurrentContext()), ( )); }
-    bool Bool(bool b)       { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool,   (CurrentContext(), b), (b)); }
-    bool Int(int i)         { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int,    (CurrentContext(), i), (i)); }
-    bool Uint(unsigned u)   { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint,   (CurrentContext(), u), (u)); }
-    bool Int64(int64_t i)   { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int64,  (CurrentContext(), i), (i)); }
-    bool Uint64(uint64_t u) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint64, (CurrentContext(), u), (u)); }
-    bool Double(double d)   { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Double, (CurrentContext(), d), (d)); }
-    bool RawNumber(const Ch* str, SizeType length, bool copy)
-                                    { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); }
-    bool String(const Ch* str, SizeType length, bool copy)
-                                    { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); }
-
-    bool StartObject() {
-        RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartObject, (CurrentContext()));
-        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartObject, ());
-        return valid_ = !outputHandler_ || outputHandler_->StartObject();
-    }
-    
-    bool Key(const Ch* str, SizeType len, bool copy) {
-        if (!valid_) return false;
-        AppendToken(str, len);
-        if (!CurrentSchema().Key(CurrentContext(), str, len, copy) && !GetContinueOnErrors()) return valid_ = false;
-        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy));
-        return valid_ = !outputHandler_ || outputHandler_->Key(str, len, copy);
-    }
-    
-    bool EndObject(SizeType memberCount) {
-        if (!valid_) return false;
-        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndObject, (memberCount));
-        if (!CurrentSchema().EndObject(CurrentContext(), memberCount) && !GetContinueOnErrors()) return valid_ = false;
-        RAPIDJSON_SCHEMA_HANDLE_END_(EndObject, (memberCount));
-    }
-
-    bool StartArray() {
-        RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartArray, (CurrentContext()));
-        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartArray, ());
-        return valid_ = !outputHandler_ || outputHandler_->StartArray();
-    }
-    
-    bool EndArray(SizeType elementCount) {
-        if (!valid_) return false;
-        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndArray, (elementCount));
-        if (!CurrentSchema().EndArray(CurrentContext(), elementCount) && !GetContinueOnErrors()) return valid_ = false;
-        RAPIDJSON_SCHEMA_HANDLE_END_(EndArray, (elementCount));
-    }
-
-#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_
-#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_
-#undef RAPIDJSON_SCHEMA_HANDLE_PARALLEL_
-#undef RAPIDJSON_SCHEMA_HANDLE_VALUE_
-
-    // Implementation of ISchemaStateFactory<SchemaType>
-    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root, const bool inheritContinueOnErrors) {
-        ISchemaValidator* sv = new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root, documentStack_.template Bottom<char>(), documentStack_.GetSize(),
-#if RAPIDJSON_SCHEMA_VERBOSE
-        depth_ + 1,
-#endif
-        &GetStateAllocator());
-        sv->SetValidateFlags(inheritContinueOnErrors ? GetValidateFlags() : GetValidateFlags() & ~(unsigned)kValidateContinueOnErrorFlag);
-        return sv;
-    }
-
-    virtual void DestroySchemaValidator(ISchemaValidator* validator) {
-        GenericSchemaValidator* v = static_cast<GenericSchemaValidator*>(validator);
-        v->~GenericSchemaValidator();
-        StateAllocator::Free(v);
-    }
-
-    virtual void* CreateHasher() {
-        return new (GetStateAllocator().Malloc(sizeof(HasherType))) HasherType(&GetStateAllocator());
-    }
-
-    virtual uint64_t GetHashCode(void* hasher) {
-        return static_cast<HasherType*>(hasher)->GetHashCode();
-    }
-
-    virtual void DestroryHasher(void* hasher) {
-        HasherType* h = static_cast<HasherType*>(hasher);
-        h->~HasherType();
-        StateAllocator::Free(h);
-    }
-
-    virtual void* MallocState(size_t size) {
-        return GetStateAllocator().Malloc(size);
-    }
-
-    virtual void FreeState(void* p) {
-        StateAllocator::Free(p);
-    }
-
-private:
-    typedef typename SchemaType::Context Context;
-    typedef GenericValue<UTF8<>, StateAllocator> HashCodeArray;
-    typedef internal::Hasher<EncodingType, StateAllocator> HasherType;
-
-    GenericSchemaValidator( 
-        const SchemaDocumentType& schemaDocument,
-        const SchemaType& root,
-        const char* basePath, size_t basePathSize,
-#if RAPIDJSON_SCHEMA_VERBOSE
-        unsigned depth,
-#endif
-        StateAllocator* allocator = 0,
-        size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
-        size_t documentStackCapacity = kDefaultDocumentStackCapacity)
-        :
-        schemaDocument_(&schemaDocument),
-        root_(root),
-        stateAllocator_(allocator),
-        ownStateAllocator_(0),
-        schemaStack_(allocator, schemaStackCapacity),
-        documentStack_(allocator, documentStackCapacity),
-        outputHandler_(0),
-        error_(kObjectType),
-        currentError_(),
-        missingDependents_(),
-        valid_(true),
-        flags_(kValidateDefaultFlags)
-#if RAPIDJSON_SCHEMA_VERBOSE
-        , depth_(depth)
-#endif
-    {
-        if (basePath && basePathSize)
-            memcpy(documentStack_.template Push<char>(basePathSize), basePath, basePathSize);
-    }
-
-    StateAllocator& GetStateAllocator() {
-        if (!stateAllocator_)
-            stateAllocator_ = ownStateAllocator_ = RAPIDJSON_NEW(StateAllocator)();
-        return *stateAllocator_;
-    }
-
-    bool GetContinueOnErrors() const {
-        return flags_ & kValidateContinueOnErrorFlag;
-    }
-
-    bool BeginValue() {
-        if (schemaStack_.Empty())
-            PushSchema(root_);
-        else {
-            if (CurrentContext().inArray)
-                internal::TokenHelper<internal::Stack<StateAllocator>, Ch>::AppendIndexToken(documentStack_, CurrentContext().arrayElementIndex);
-
-            if (!CurrentSchema().BeginValue(CurrentContext()) && !GetContinueOnErrors())
-                return false;
-
-            SizeType count = CurrentContext().patternPropertiesSchemaCount;
-            const SchemaType** sa = CurrentContext().patternPropertiesSchemas;
-            typename Context::PatternValidatorType patternValidatorType = CurrentContext().valuePatternValidatorType;
-            bool valueUniqueness = CurrentContext().valueUniqueness;
-            RAPIDJSON_ASSERT(CurrentContext().valueSchema);
-            PushSchema(*CurrentContext().valueSchema);
-
-            if (count > 0) {
-                CurrentContext().objectPatternValidatorType = patternValidatorType;
-                ISchemaValidator**& va = CurrentContext().patternPropertiesValidators;
-                SizeType& validatorCount = CurrentContext().patternPropertiesValidatorCount;
-                va = static_cast<ISchemaValidator**>(MallocState(sizeof(ISchemaValidator*) * count));
-                for (SizeType i = 0; i < count; i++)
-                    va[validatorCount++] = CreateSchemaValidator(*sa[i], true);  // Inherit continueOnError
-            }
-
-            CurrentContext().arrayUniqueness = valueUniqueness;
-        }
-        return true;
-    }
-
-    bool EndValue() {
-        if (!CurrentSchema().EndValue(CurrentContext()) && !GetContinueOnErrors())
-            return false;
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-        GenericStringBuffer<EncodingType> sb;
-        schemaDocument_->GetPointer(&CurrentSchema()).Stringify(sb);
-
-        *documentStack_.template Push<Ch>() = '\0';
-        documentStack_.template Pop<Ch>(1);
-        internal::PrintValidatorPointers(depth_, sb.GetString(), documentStack_.template Bottom<Ch>());
-#endif
-        void* hasher = CurrentContext().hasher;
-        uint64_t h = hasher && CurrentContext().arrayUniqueness ? static_cast<HasherType*>(hasher)->GetHashCode() : 0;
-        
-        PopSchema();
-
-        if (!schemaStack_.Empty()) {
-            Context& context = CurrentContext();
-            // Only check uniqueness if there is a hasher
-            if (hasher && context.valueUniqueness) {
-                HashCodeArray* a = static_cast<HashCodeArray*>(context.arrayElementHashCodes);
-                if (!a)
-                    CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType);
-                for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr)
-                    if (itr->GetUint64() == h) {
-                        DuplicateItems(static_cast<SizeType>(itr - a->Begin()), a->Size());
-                        // Cleanup before returning if continuing
-                        if (GetContinueOnErrors()) {
-                            a->PushBack(h, GetStateAllocator());
-                            while (!documentStack_.Empty() && *documentStack_.template Pop<Ch>(1) != '/');
-                        }
-                        RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorUniqueItems);
-                    }
-                a->PushBack(h, GetStateAllocator());
-            }
-        }
-
-        // Remove the last token of document pointer
-        while (!documentStack_.Empty() && *documentStack_.template Pop<Ch>(1) != '/')
-            ;
-
-        return true;
-    }
-
-    void AppendToken(const Ch* str, SizeType len) {
-        documentStack_.template Reserve<Ch>(1 + len * 2); // worst case all characters are escaped as two characters
-        *documentStack_.template PushUnsafe<Ch>() = '/';
-        for (SizeType i = 0; i < len; i++) {
-            if (str[i] == '~') {
-                *documentStack_.template PushUnsafe<Ch>() = '~';
-                *documentStack_.template PushUnsafe<Ch>() = '0';
-            }
-            else if (str[i] == '/') {
-                *documentStack_.template PushUnsafe<Ch>() = '~';
-                *documentStack_.template PushUnsafe<Ch>() = '1';
-            }
-            else
-                *documentStack_.template PushUnsafe<Ch>() = str[i];
-        }
-    }
-
-    RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push<Context>()) Context(*this, *this, &schema); }
-    
-    RAPIDJSON_FORCEINLINE void PopSchema() {
-        Context* c = schemaStack_.template Pop<Context>(1);
-        if (HashCodeArray* a = static_cast<HashCodeArray*>(c->arrayElementHashCodes)) {
-            a->~HashCodeArray();
-            StateAllocator::Free(a);
-        }
-        c->~Context();
-    }
-
-    void AddErrorInstanceLocation(ValueType& result, bool parent) {
-        GenericStringBuffer<EncodingType> sb;
-        PointerType instancePointer = GetInvalidDocumentPointer();
-        ((parent && instancePointer.GetTokenCount() > 0)
-         ? PointerType(instancePointer.GetTokens(), instancePointer.GetTokenCount() - 1)
-         : instancePointer).StringifyUriFragment(sb);
-        ValueType instanceRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
-                              GetStateAllocator());
-        result.AddMember(GetInstanceRefString(), instanceRef, GetStateAllocator());
-    }
-
-    void AddErrorSchemaLocation(ValueType& result, PointerType schema = PointerType()) {
-        GenericStringBuffer<EncodingType> sb;
-        SizeType len = CurrentSchema().GetURI().GetStringLength();
-        if (len) memcpy(sb.Push(len), CurrentSchema().GetURI().GetString(), len * sizeof(Ch));
-        if (schema.GetTokenCount()) schema.StringifyUriFragment(sb);
-        else GetInvalidSchemaPointer().StringifyUriFragment(sb);
-        ValueType schemaRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
-            GetStateAllocator());
-        result.AddMember(GetSchemaRefString(), schemaRef, GetStateAllocator());
-    }
-
-    void AddErrorCode(ValueType& result, const ValidateErrorCode code) {
-        result.AddMember(GetErrorCodeString(), code, GetStateAllocator());
-    }
-
-    void AddError(ValueType& keyword, ValueType& error) {
-        typename ValueType::MemberIterator member = error_.FindMember(keyword);
-        if (member == error_.MemberEnd())
-            error_.AddMember(keyword, error, GetStateAllocator());
-        else {
-            if (member->value.IsObject()) {
-                ValueType errors(kArrayType);
-                errors.PushBack(member->value, GetStateAllocator());
-                member->value = errors;
-            }
-            member->value.PushBack(error, GetStateAllocator());
-        }
-    }
-
-    void AddCurrentError(const ValidateErrorCode code, bool parent = false) {
-        AddErrorCode(currentError_, code);
-        AddErrorInstanceLocation(currentError_, parent);
-        AddErrorSchemaLocation(currentError_);
-        AddError(ValueType(SchemaType::GetValidateErrorKeyword(code), GetStateAllocator(), false).Move(), currentError_);
-    }
-
-    void MergeError(ValueType& other) {
-        for (typename ValueType::MemberIterator it = other.MemberBegin(), end = other.MemberEnd(); it != end; ++it) {
-            AddError(it->name, it->value);
-        }
-    }
-
-    void AddNumberError(const ValidateErrorCode code, ValueType& actual, const SValue& expected,
-        const typename SchemaType::ValueType& (*exclusive)() = 0) {
-        currentError_.SetObject();
-        currentError_.AddMember(GetActualString(), actual, GetStateAllocator());
-        currentError_.AddMember(GetExpectedString(), ValueType(expected, GetStateAllocator()).Move(), GetStateAllocator());
-        if (exclusive)
-            currentError_.AddMember(ValueType(exclusive(), GetStateAllocator()).Move(), true, GetStateAllocator());
-        AddCurrentError(code);
-    }
-
-    void AddErrorArray(const ValidateErrorCode code,
-        ISchemaValidator** subvalidators, SizeType count) {
-        ValueType errors(kArrayType);
-        for (SizeType i = 0; i < count; ++i)
-            errors.PushBack(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError(), GetStateAllocator());
-        currentError_.SetObject();
-        currentError_.AddMember(GetErrorsString(), errors, GetStateAllocator());
-        AddCurrentError(code);
-    }
-
-    const SchemaType& CurrentSchema() const { return *schemaStack_.template Top<Context>()->schema; }
-    Context& CurrentContext() { return *schemaStack_.template Top<Context>(); }
-    const Context& CurrentContext() const { return *schemaStack_.template Top<Context>(); }
-
-    static const size_t kDefaultSchemaStackCapacity = 1024;
-    static const size_t kDefaultDocumentStackCapacity = 256;
-    const SchemaDocumentType* schemaDocument_;
-    const SchemaType& root_;
-    StateAllocator* stateAllocator_;
-    StateAllocator* ownStateAllocator_;
-    internal::Stack<StateAllocator> schemaStack_;    //!< stack to store the current path of schema (BaseSchemaType *)
-    internal::Stack<StateAllocator> documentStack_;  //!< stack to store the current path of validating document (Ch)
-    OutputHandler* outputHandler_;
-    ValueType error_;
-    ValueType currentError_;
-    ValueType missingDependents_;
-    bool valid_;
-    unsigned flags_;
-#if RAPIDJSON_SCHEMA_VERBOSE
-    unsigned depth_;
-#endif
-};
-
-typedef GenericSchemaValidator<SchemaDocument> SchemaValidator;
-
-///////////////////////////////////////////////////////////////////////////////
-// SchemaValidatingReader
-
-//! A helper class for parsing with validation.
-/*!
-    This helper class is a functor, designed as a parameter of \ref GenericDocument::Populate().
-
-    \tparam parseFlags Combination of \ref ParseFlag.
-    \tparam InputStream Type of input stream, implementing Stream concept.
-    \tparam SourceEncoding Encoding of the input stream.
-    \tparam SchemaDocumentType Type of schema document.
-    \tparam StackAllocator Allocator type for stack.
-*/
-template <
-    unsigned parseFlags,
-    typename InputStream,
-    typename SourceEncoding,
-    typename SchemaDocumentType = SchemaDocument,
-    typename StackAllocator = CrtAllocator>
-class SchemaValidatingReader {
-public:
-    typedef typename SchemaDocumentType::PointerType PointerType;
-    typedef typename InputStream::Ch Ch;
-    typedef GenericValue<SourceEncoding, StackAllocator> ValueType;
-
-    //! Constructor
-    /*!
-        \param is Input stream.
-        \param sd Schema document.
-    */
-    SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), invalidSchemaCode_(kValidateErrorNone), error_(kObjectType), isValid_(true) {}
-
-    template <typename Handler>
-    bool operator()(Handler& handler) {
-        GenericReader<SourceEncoding, typename SchemaDocumentType::EncodingType, StackAllocator> reader;
-        GenericSchemaValidator<SchemaDocumentType, Handler> validator(sd_, handler);
-        parseResult_ = reader.template Parse<parseFlags>(is_, validator);
-
-        isValid_ = validator.IsValid();
-        if (isValid_) {
-            invalidSchemaPointer_ = PointerType();
-            invalidSchemaKeyword_ = 0;
-            invalidDocumentPointer_ = PointerType();
-            error_.SetObject();
-        }
-        else {
-            invalidSchemaPointer_ = validator.GetInvalidSchemaPointer();
-            invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword();
-            invalidSchemaCode_ = validator.GetInvalidSchemaCode();
-            invalidDocumentPointer_ = validator.GetInvalidDocumentPointer();
-            error_.CopyFrom(validator.GetError(), allocator_);
-        }
-
-        return parseResult_;
-    }
-
-    const ParseResult& GetParseResult() const { return parseResult_; }
-    bool IsValid() const { return isValid_; }
-    const PointerType& GetInvalidSchemaPointer() const { return invalidSchemaPointer_; }
-    const Ch* GetInvalidSchemaKeyword() const { return invalidSchemaKeyword_; }
-    const PointerType& GetInvalidDocumentPointer() const { return invalidDocumentPointer_; }
-    const ValueType& GetError() const { return error_; }
-    ValidateErrorCode GetInvalidSchemaCode() const { return invalidSchemaCode_; }
-
-private:
-    InputStream& is_;
-    const SchemaDocumentType& sd_;
-
-    ParseResult parseResult_;
-    PointerType invalidSchemaPointer_;
-    const Ch* invalidSchemaKeyword_;
-    PointerType invalidDocumentPointer_;
-    ValidateErrorCode invalidSchemaCode_;
-    StackAllocator allocator_;
-    ValueType error_;
-    bool isValid_;
-};
-
-RAPIDJSON_NAMESPACE_END
-RAPIDJSON_DIAG_POP
-
-#endif // RAPIDJSON_SCHEMA_H_
diff --git a/thirdparty/rapidjson/stream.h b/thirdparty/rapidjson/stream.h
deleted file mode 100644
index 1fd7091..0000000
--- a/thirdparty/rapidjson/stream.h
+++ /dev/null
@@ -1,223 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#include "rapidjson.h"
-
-#ifndef RAPIDJSON_STREAM_H_
-#define RAPIDJSON_STREAM_H_
-
-#include "encodings.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-//  Stream
-
-/*! \class rapidjson::Stream
-    \brief Concept for reading and writing characters.
-
-    For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().
-
-    For write-only stream, only need to implement Put() and Flush().
-
-\code
-concept Stream {
-    typename Ch;    //!< Character type of the stream.
-
-    //! Read the current character from stream without moving the read cursor.
-    Ch Peek() const;
-
-    //! Read the current character from stream and moving the read cursor to next character.
-    Ch Take();
-
-    //! Get the current read cursor.
-    //! \return Number of characters read from start.
-    size_t Tell();
-
-    //! Begin writing operation at the current read pointer.
-    //! \return The begin writer pointer.
-    Ch* PutBegin();
-
-    //! Write a character.
-    void Put(Ch c);
-
-    //! Flush the buffer.
-    void Flush();
-
-    //! End the writing operation.
-    //! \param begin The begin write pointer returned by PutBegin().
-    //! \return Number of characters written.
-    size_t PutEnd(Ch* begin);
-}
-\endcode
-*/
-
-//! Provides additional information for stream.
-/*!
-    By using traits pattern, this type provides a default configuration for stream.
-    For custom stream, this type can be specialized for other configuration.
-    See TEST(Reader, CustomStringStream) in readertest.cpp for example.
-*/
-template<typename Stream>
-struct StreamTraits {
-    //! Whether to make local copy of stream for optimization during parsing.
-    /*!
-        By default, for safety, streams do not use local copy optimization.
-        Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
-    */
-    enum { copyOptimization = 0 };
-};
-
-//! Reserve n characters for writing to a stream.
-template<typename Stream>
-inline void PutReserve(Stream& stream, size_t count) {
-    (void)stream;
-    (void)count;
-}
-
-//! Write character to a stream, presuming buffer is reserved.
-template<typename Stream>
-inline void PutUnsafe(Stream& stream, typename Stream::Ch c) {
-    stream.Put(c);
-}
-
-//! Put N copies of a character to a stream.
-template<typename Stream, typename Ch>
-inline void PutN(Stream& stream, Ch c, size_t n) {
-    PutReserve(stream, n);
-    for (size_t i = 0; i < n; i++)
-        PutUnsafe(stream, c);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericStreamWrapper
-
-//! A Stream Wrapper
-/*! \tThis string stream is a wrapper for any stream by just forwarding any
-    \treceived message to the origin stream.
-    \note implements Stream concept
-*/
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
-#endif
-
-template <typename InputStream, typename Encoding = UTF8<> >
-class GenericStreamWrapper {
-public:
-    typedef typename Encoding::Ch Ch;
-    GenericStreamWrapper(InputStream& is): is_(is) {}
-
-    Ch Peek() const { return is_.Peek(); }
-    Ch Take() { return is_.Take(); }
-    size_t Tell() { return is_.Tell(); }
-    Ch* PutBegin() { return is_.PutBegin(); }
-    void Put(Ch ch) { is_.Put(ch); }
-    void Flush() { is_.Flush(); }
-    size_t PutEnd(Ch* ch) { return is_.PutEnd(ch); }
-
-    // wrapper for MemoryStream
-    const Ch* Peek4() const { return is_.Peek4(); }
-
-    // wrapper for AutoUTFInputStream
-    UTFType GetType() const { return is_.GetType(); }
-    bool HasBOM() const { return is_.HasBOM(); }
-
-protected:
-    InputStream& is_;
-};
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-RAPIDJSON_DIAG_POP
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// StringStream
-
-//! Read-only string stream.
-/*! \note implements Stream concept
-*/
-template <typename Encoding>
-struct GenericStringStream {
-    typedef typename Encoding::Ch Ch;
-
-    GenericStringStream(const Ch *src) : src_(src), head_(src) {}
-
-    Ch Peek() const { return *src_; }
-    Ch Take() { return *src_++; }
-    size_t Tell() const { return static_cast<size_t>(src_ - head_); }
-
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-    const Ch* src_;     //!< Current read position.
-    const Ch* head_;    //!< Original head of the string.
-};
-
-template <typename Encoding>
-struct StreamTraits<GenericStringStream<Encoding> > {
-    enum { copyOptimization = 1 };
-};
-
-//! String stream with UTF8 encoding.
-typedef GenericStringStream<UTF8<> > StringStream;
-
-///////////////////////////////////////////////////////////////////////////////
-// InsituStringStream
-
-//! A read-write string stream.
-/*! This string stream is particularly designed for in-situ parsing.
-    \note implements Stream concept
-*/
-template <typename Encoding>
-struct GenericInsituStringStream {
-    typedef typename Encoding::Ch Ch;
-
-    GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
-
-    // Read
-    Ch Peek() { return *src_; }
-    Ch Take() { return *src_++; }
-    size_t Tell() { return static_cast<size_t>(src_ - head_); }
-
-    // Write
-    void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
-
-    Ch* PutBegin() { return dst_ = src_; }
-    size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
-    void Flush() {}
-
-    Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
-    void Pop(size_t count) { dst_ -= count; }
-
-    Ch* src_;
-    Ch* dst_;
-    Ch* head_;
-};
-
-template <typename Encoding>
-struct StreamTraits<GenericInsituStringStream<Encoding> > {
-    enum { copyOptimization = 1 };
-};
-
-//! Insitu string stream with UTF8 encoding.
-typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_STREAM_H_
diff --git a/thirdparty/rapidjson/stringbuffer.h b/thirdparty/rapidjson/stringbuffer.h
deleted file mode 100644
index 82ad3ca..0000000
--- a/thirdparty/rapidjson/stringbuffer.h
+++ /dev/null
@@ -1,121 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_STRINGBUFFER_H_
-#define RAPIDJSON_STRINGBUFFER_H_
-
-#include "stream.h"
-#include "internal/stack.h"
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-#include <utility> // std::move
-#endif
-
-#include "internal/stack.h"
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Represents an in-memory output stream.
-/*!
-    \tparam Encoding Encoding of the stream.
-    \tparam Allocator type for allocating memory buffer.
-    \note implements Stream concept
-*/
-template <typename Encoding, typename Allocator = CrtAllocator>
-class GenericStringBuffer {
-public:
-    typedef typename Encoding::Ch Ch;
-
-    GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {}
-    GenericStringBuffer& operator=(GenericStringBuffer&& rhs) {
-        if (&rhs != this)
-            stack_ = std::move(rhs.stack_);
-        return *this;
-    }
-#endif
-
-    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
-    void PutUnsafe(Ch c) { *stack_.template PushUnsafe<Ch>() = c; }
-    void Flush() {}
-
-    void Clear() { stack_.Clear(); }
-    void ShrinkToFit() {
-        // Push and pop a null terminator. This is safe.
-        *stack_.template Push<Ch>() = '\0';
-        stack_.ShrinkToFit();
-        stack_.template Pop<Ch>(1);
-    }
-
-    void Reserve(size_t count) { stack_.template Reserve<Ch>(count); }
-    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
-    Ch* PushUnsafe(size_t count) { return stack_.template PushUnsafe<Ch>(count); }
-    void Pop(size_t count) { stack_.template Pop<Ch>(count); }
-
-    const Ch* GetString() const {
-        // Push and pop a null terminator. This is safe.
-        *stack_.template Push<Ch>() = '\0';
-        stack_.template Pop<Ch>(1);
-
-        return stack_.template Bottom<Ch>();
-    }
-
-    //! Get the size of string in bytes in the string buffer.
-    size_t GetSize() const { return stack_.GetSize(); }
-
-    //! Get the length of string in Ch in the string buffer.
-    size_t GetLength() const { return stack_.GetSize() / sizeof(Ch); }
-
-    static const size_t kDefaultCapacity = 256;
-    mutable internal::Stack<Allocator> stack_;
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    GenericStringBuffer(const GenericStringBuffer&);
-    GenericStringBuffer& operator=(const GenericStringBuffer&);
-};
-
-//! String buffer with UTF8 encoding
-typedef GenericStringBuffer<UTF8<> > StringBuffer;
-
-template<typename Encoding, typename Allocator>
-inline void PutReserve(GenericStringBuffer<Encoding, Allocator>& stream, size_t count) {
-    stream.Reserve(count);
-}
-
-template<typename Encoding, typename Allocator>
-inline void PutUnsafe(GenericStringBuffer<Encoding, Allocator>& stream, typename Encoding::Ch c) {
-    stream.PutUnsafe(c);
-}
-
-//! Implement specialized version of PutN() with memset() for better performance.
-template<>
-inline void PutN(GenericStringBuffer<UTF8<> >& stream, char c, size_t n) {
-    std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_STRINGBUFFER_H_
diff --git a/thirdparty/rapidjson/writer.h b/thirdparty/rapidjson/writer.h
deleted file mode 100644
index 8b38921..0000000
--- a/thirdparty/rapidjson/writer.h
+++ /dev/null
@@ -1,710 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_WRITER_H_
-#define RAPIDJSON_WRITER_H_
-
-#include "stream.h"
-#include "internal/clzll.h"
-#include "internal/meta.h"
-#include "internal/stack.h"
-#include "internal/strfunc.h"
-#include "internal/dtoa.h"
-#include "internal/itoa.h"
-#include "stringbuffer.h"
-#include <new>      // placement new
-
-#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
-#include <intrin.h>
-#pragma intrinsic(_BitScanForward)
-#endif
-#ifdef RAPIDJSON_SSE42
-#include <nmmintrin.h>
-#elif defined(RAPIDJSON_SSE2)
-#include <emmintrin.h>
-#elif defined(RAPIDJSON_NEON)
-#include <arm_neon.h>
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-RAPIDJSON_DIAG_OFF(unreachable-code)
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// WriteFlag
-
-/*! \def RAPIDJSON_WRITE_DEFAULT_FLAGS 
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-defined kWriteDefaultFlags definition.
-
-    User can define this as any \c WriteFlag combinations.
-*/
-#ifndef RAPIDJSON_WRITE_DEFAULT_FLAGS
-#define RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags
-#endif
-
-//! Combination of writeFlags
-enum WriteFlag {
-    kWriteNoFlags = 0,              //!< No flags are set.
-    kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings.
-    kWriteNanAndInfFlag = 2,        //!< Allow writing of Infinity, -Infinity and NaN.
-    kWriteDefaultFlags = RAPIDJSON_WRITE_DEFAULT_FLAGS  //!< Default write flags. Can be customized by defining RAPIDJSON_WRITE_DEFAULT_FLAGS
-};
-
-//! JSON writer
-/*! Writer implements the concept Handler.
-    It generates JSON text by events to an output os.
-
-    User may programmatically calls the functions of a writer to generate JSON text.
-
-    On the other side, a writer can also be passed to objects that generates events, 
-
-    for example Reader::Parse() and Document::Accept().
-
-    \tparam OutputStream Type of output stream.
-    \tparam SourceEncoding Encoding of source string.
-    \tparam TargetEncoding Encoding of output stream.
-    \tparam StackAllocator Type of allocator for allocating memory of stack.
-    \note implements Handler concept
-*/
-template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
-class Writer {
-public:
-    typedef typename SourceEncoding::Ch Ch;
-
-    static const int kDefaultMaxDecimalPlaces = 324;
-
-    //! Constructor
-    /*! \param os Output stream.
-        \param stackAllocator User supplied allocator. If it is null, it will create a private one.
-        \param levelDepth Initial capacity of stack.
-    */
-    explicit
-    Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) : 
-        os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
-
-    explicit
-    Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
-        os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    Writer(Writer&& rhs) :
-        os_(rhs.os_), level_stack_(std::move(rhs.level_stack_)), maxDecimalPlaces_(rhs.maxDecimalPlaces_), hasRoot_(rhs.hasRoot_) {
-        rhs.os_ = 0;
-    }
-#endif
-
-    //! Reset the writer with a new stream.
-    /*!
-        This function reset the writer with a new stream and default settings,
-        in order to make a Writer object reusable for output multiple JSONs.
-
-        \param os New output stream.
-        \code
-        Writer<OutputStream> writer(os1);
-        writer.StartObject();
-        // ...
-        writer.EndObject();
-
-        writer.Reset(os2);
-        writer.StartObject();
-        // ...
-        writer.EndObject();
-        \endcode
-    */
-    void Reset(OutputStream& os) {
-        os_ = &os;
-        hasRoot_ = false;
-        level_stack_.Clear();
-    }
-
-    //! Checks whether the output is a complete JSON.
-    /*!
-        A complete JSON has a complete root object or array.
-    */
-    bool IsComplete() const {
-        return hasRoot_ && level_stack_.Empty();
-    }
-
-    int GetMaxDecimalPlaces() const {
-        return maxDecimalPlaces_;
-    }
-
-    //! Sets the maximum number of decimal places for double output.
-    /*!
-        This setting truncates the output with specified number of decimal places.
-
-        For example, 
-
-        \code
-        writer.SetMaxDecimalPlaces(3);
-        writer.StartArray();
-        writer.Double(0.12345);                 // "0.123"
-        writer.Double(0.0001);                  // "0.0"
-        writer.Double(1.234567890123456e30);    // "1.234567890123456e30" (do not truncate significand for positive exponent)
-        writer.Double(1.23e-4);                 // "0.0"                  (do truncate significand for negative exponent)
-        writer.EndArray();
-        \endcode
-
-        The default setting does not truncate any decimal places. You can restore to this setting by calling
-        \code
-        writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces);
-        \endcode
-    */
-    void SetMaxDecimalPlaces(int maxDecimalPlaces) {
-        maxDecimalPlaces_ = maxDecimalPlaces;
-    }
-
-    /*!@name Implementation of Handler
-        \see Handler
-    */
-    //@{
-
-    bool Null()                 { Prefix(kNullType);   return EndValue(WriteNull()); }
-    bool Bool(bool b)           { Prefix(b ? kTrueType : kFalseType); return EndValue(WriteBool(b)); }
-    bool Int(int i)             { Prefix(kNumberType); return EndValue(WriteInt(i)); }
-    bool Uint(unsigned u)       { Prefix(kNumberType); return EndValue(WriteUint(u)); }
-    bool Int64(int64_t i64)     { Prefix(kNumberType); return EndValue(WriteInt64(i64)); }
-    bool Uint64(uint64_t u64)   { Prefix(kNumberType); return EndValue(WriteUint64(u64)); }
-
-    //! Writes the given \c double value to the stream
-    /*!
-        \param d The value to be written.
-        \return Whether it is succeed.
-    */
-    bool Double(double d)       { Prefix(kNumberType); return EndValue(WriteDouble(d)); }
-
-    bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
-        RAPIDJSON_ASSERT(str != 0);
-        (void)copy;
-        Prefix(kNumberType);
-        return EndValue(WriteString(str, length));
-    }
-
-    bool String(const Ch* str, SizeType length, bool copy = false) {
-        RAPIDJSON_ASSERT(str != 0);
-        (void)copy;
-        Prefix(kStringType);
-        return EndValue(WriteString(str, length));
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool String(const std::basic_string<Ch>& str) {
-        return String(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool StartObject() {
-        Prefix(kObjectType);
-        new (level_stack_.template Push<Level>()) Level(false);
-        return WriteStartObject();
-    }
-
-    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool Key(const std::basic_string<Ch>& str)
-    {
-      return Key(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool EndObject(SizeType memberCount = 0) {
-        (void)memberCount;
-        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object
-        RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray); // currently inside an Array, not Object
-        RAPIDJSON_ASSERT(0 == level_stack_.template Top<Level>()->valueCount % 2); // Object has a Key without a Value
-        level_stack_.template Pop<Level>(1);
-        return EndValue(WriteEndObject());
-    }
-
-    bool StartArray() {
-        Prefix(kArrayType);
-        new (level_stack_.template Push<Level>()) Level(true);
-        return WriteStartArray();
-    }
-
-    bool EndArray(SizeType elementCount = 0) {
-        (void)elementCount;
-        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
-        RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
-        level_stack_.template Pop<Level>(1);
-        return EndValue(WriteEndArray());
-    }
-    //@}
-
-    /*! @name Convenience extensions */
-    //@{
-
-    //! Simpler but slower overload.
-    bool String(const Ch* const& str) { return String(str, internal::StrLen(str)); }
-    bool Key(const Ch* const& str) { return Key(str, internal::StrLen(str)); }
-    
-    //@}
-
-    //! Write a raw JSON value.
-    /*!
-        For user to write a stringified JSON as a value.
-
-        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
-        \param length Length of the json.
-        \param type Type of the root of json.
-    */
-    bool RawValue(const Ch* json, size_t length, Type type) {
-        RAPIDJSON_ASSERT(json != 0);
-        Prefix(type);
-        return EndValue(WriteRawValue(json, length));
-    }
-
-    //! Flush the output stream.
-    /*!
-        Allows the user to flush the output stream immediately.
-     */
-    void Flush() {
-        os_->Flush();
-    }
-
-    static const size_t kDefaultLevelDepth = 32;
-
-protected:
-    //! Information for each nested level
-    struct Level {
-        Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
-        size_t valueCount;  //!< number of values in this level
-        bool inArray;       //!< true if in array, otherwise in object
-    };
-
-    bool WriteNull()  {
-        PutReserve(*os_, 4);
-        PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true;
-    }
-
-    bool WriteBool(bool b)  {
-        if (b) {
-            PutReserve(*os_, 4);
-            PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e');
-        }
-        else {
-            PutReserve(*os_, 5);
-            PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e');
-        }
-        return true;
-    }
-
-    bool WriteInt(int i) {
-        char buffer[11];
-        const char* end = internal::i32toa(i, buffer);
-        PutReserve(*os_, static_cast<size_t>(end - buffer));
-        for (const char* p = buffer; p != end; ++p)
-            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-        return true;
-    }
-
-    bool WriteUint(unsigned u) {
-        char buffer[10];
-        const char* end = internal::u32toa(u, buffer);
-        PutReserve(*os_, static_cast<size_t>(end - buffer));
-        for (const char* p = buffer; p != end; ++p)
-            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-        return true;
-    }
-
-    bool WriteInt64(int64_t i64) {
-        char buffer[21];
-        const char* end = internal::i64toa(i64, buffer);
-        PutReserve(*os_, static_cast<size_t>(end - buffer));
-        for (const char* p = buffer; p != end; ++p)
-            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-        return true;
-    }
-
-    bool WriteUint64(uint64_t u64) {
-        char buffer[20];
-        char* end = internal::u64toa(u64, buffer);
-        PutReserve(*os_, static_cast<size_t>(end - buffer));
-        for (char* p = buffer; p != end; ++p)
-            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-        return true;
-    }
-
-    bool WriteDouble(double d) {
-        if (internal::Double(d).IsNanOrInf()) {
-            if (!(writeFlags & kWriteNanAndInfFlag))
-                return false;
-            if (internal::Double(d).IsNan()) {
-                PutReserve(*os_, 3);
-                PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
-                return true;
-            }
-            if (internal::Double(d).Sign()) {
-                PutReserve(*os_, 9);
-                PutUnsafe(*os_, '-');
-            }
-            else
-                PutReserve(*os_, 8);
-            PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
-            PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
-            return true;
-        }
-
-        char buffer[25];
-        char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
-        PutReserve(*os_, static_cast<size_t>(end - buffer));
-        for (char* p = buffer; p != end; ++p)
-            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-        return true;
-    }
-
-    bool WriteString(const Ch* str, SizeType length)  {
-        static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-        static const char escape[256] = {
-#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-            //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
-            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
-            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
-              0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
-            Z16, Z16,                                                                       // 30~4F
-              0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
-            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
-#undef Z16
-        };
-
-        if (TargetEncoding::supportUnicode)
-            PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
-        else
-            PutReserve(*os_, 2 + length * 12);  // "\uxxxx\uyyyy..."
-
-        PutUnsafe(*os_, '\"');
-        GenericStringStream<SourceEncoding> is(str);
-        while (ScanWriteUnescapedString(is, length)) {
-            const Ch c = is.Peek();
-            if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80) {
-                // Unicode escaping
-                unsigned codepoint;
-                if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
-                    return false;
-                PutUnsafe(*os_, '\\');
-                PutUnsafe(*os_, 'u');
-                if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) {
-                    PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
-                    PutUnsafe(*os_, hexDigits[(codepoint >>  8) & 15]);
-                    PutUnsafe(*os_, hexDigits[(codepoint >>  4) & 15]);
-                    PutUnsafe(*os_, hexDigits[(codepoint      ) & 15]);
-                }
-                else {
-                    RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
-                    // Surrogate pair
-                    unsigned s = codepoint - 0x010000;
-                    unsigned lead = (s >> 10) + 0xD800;
-                    unsigned trail = (s & 0x3FF) + 0xDC00;
-                    PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
-                    PutUnsafe(*os_, hexDigits[(lead >>  8) & 15]);
-                    PutUnsafe(*os_, hexDigits[(lead >>  4) & 15]);
-                    PutUnsafe(*os_, hexDigits[(lead      ) & 15]);
-                    PutUnsafe(*os_, '\\');
-                    PutUnsafe(*os_, 'u');
-                    PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
-                    PutUnsafe(*os_, hexDigits[(trail >>  8) & 15]);
-                    PutUnsafe(*os_, hexDigits[(trail >>  4) & 15]);
-                    PutUnsafe(*os_, hexDigits[(trail      ) & 15]);                    
-                }
-            }
-            else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)]))  {
-                is.Take();
-                PutUnsafe(*os_, '\\');
-                PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(escape[static_cast<unsigned char>(c)]));
-                if (escape[static_cast<unsigned char>(c)] == 'u') {
-                    PutUnsafe(*os_, '0');
-                    PutUnsafe(*os_, '0');
-                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
-                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
-                }
-            }
-            else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
-                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
-                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
-                return false;
-        }
-        PutUnsafe(*os_, '\"');
-        return true;
-    }
-
-    bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding>& is, size_t length) {
-        return RAPIDJSON_LIKELY(is.Tell() < length);
-    }
-
-    bool WriteStartObject() { os_->Put('{'); return true; }
-    bool WriteEndObject()   { os_->Put('}'); return true; }
-    bool WriteStartArray()  { os_->Put('['); return true; }
-    bool WriteEndArray()    { os_->Put(']'); return true; }
-
-    bool WriteRawValue(const Ch* json, size_t length) {
-        PutReserve(*os_, length);
-        GenericStringStream<SourceEncoding> is(json);
-        while (RAPIDJSON_LIKELY(is.Tell() < length)) {
-            RAPIDJSON_ASSERT(is.Peek() != '\0');
-            if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
-                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
-                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
-                return false;
-        }
-        return true;
-    }
-
-    void Prefix(Type type) {
-        (void)type;
-        if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0)) { // this value is not at root
-            Level* level = level_stack_.template Top<Level>();
-            if (level->valueCount > 0) {
-                if (level->inArray) 
-                    os_->Put(','); // add comma if it is not the first element in array
-                else  // in object
-                    os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
-            }
-            if (!level->inArray && level->valueCount % 2 == 0)
-                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
-            level->valueCount++;
-        }
-        else {
-            RAPIDJSON_ASSERT(!hasRoot_);    // Should only has one and only one root.
-            hasRoot_ = true;
-        }
-    }
-
-    // Flush the value if it is the top level one.
-    bool EndValue(bool ret) {
-        if (RAPIDJSON_UNLIKELY(level_stack_.Empty()))   // end of json text
-            Flush();
-        return ret;
-    }
-
-    OutputStream* os_;
-    internal::Stack<StackAllocator> level_stack_;
-    int maxDecimalPlaces_;
-    bool hasRoot_;
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    Writer(const Writer&);
-    Writer& operator=(const Writer&);
-};
-
-// Full specialization for StringStream to prevent memory copying
-
-template<>
-inline bool Writer<StringBuffer>::WriteInt(int i) {
-    char *buffer = os_->Push(11);
-    const char* end = internal::i32toa(i, buffer);
-    os_->Pop(static_cast<size_t>(11 - (end - buffer)));
-    return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteUint(unsigned u) {
-    char *buffer = os_->Push(10);
-    const char* end = internal::u32toa(u, buffer);
-    os_->Pop(static_cast<size_t>(10 - (end - buffer)));
-    return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {
-    char *buffer = os_->Push(21);
-    const char* end = internal::i64toa(i64, buffer);
-    os_->Pop(static_cast<size_t>(21 - (end - buffer)));
-    return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {
-    char *buffer = os_->Push(20);
-    const char* end = internal::u64toa(u, buffer);
-    os_->Pop(static_cast<size_t>(20 - (end - buffer)));
-    return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteDouble(double d) {
-    if (internal::Double(d).IsNanOrInf()) {
-        // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
-        if (!(kWriteDefaultFlags & kWriteNanAndInfFlag))
-            return false;
-        if (internal::Double(d).IsNan()) {
-            PutReserve(*os_, 3);
-            PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
-            return true;
-        }
-        if (internal::Double(d).Sign()) {
-            PutReserve(*os_, 9);
-            PutUnsafe(*os_, '-');
-        }
-        else
-            PutReserve(*os_, 8);
-        PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
-        PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
-        return true;
-    }
-    
-    char *buffer = os_->Push(25);
-    char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
-    os_->Pop(static_cast<size_t>(25 - (end - buffer)));
-    return true;
-}
-
-#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
-template<>
-inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length) {
-    if (length < 16)
-        return RAPIDJSON_LIKELY(is.Tell() < length);
-
-    if (!RAPIDJSON_LIKELY(is.Tell() < length))
-        return false;
-
-    const char* p = is.src_;
-    const char* end = is.head_ + length;
-    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-    const char* endAligned = reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
-    if (nextAligned > end)
-        return true;
-
-    while (p != nextAligned)
-        if (*p < 0x20 || *p == '\"' || *p == '\\') {
-            is.src_ = p;
-            return RAPIDJSON_LIKELY(is.Tell() < length);
-        }
-        else
-            os_->PutUnsafe(*p++);
-
-    // The rest of string using SIMD
-    static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
-    static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
-    static const char space[16]  = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
-    const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
-    const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
-    const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
-
-    for (; p != endAligned; p += 16) {
-        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-        const __m128i t1 = _mm_cmpeq_epi8(s, dq);
-        const __m128i t2 = _mm_cmpeq_epi8(s, bs);
-        const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
-        const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
-        unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
-        if (RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
-            SizeType len;
-#ifdef _MSC_VER         // Find the index of first escaped
-            unsigned long offset;
-            _BitScanForward(&offset, r);
-            len = offset;
-#else
-            len = static_cast<SizeType>(__builtin_ffs(r) - 1);
-#endif
-            char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
-            for (size_t i = 0; i < len; i++)
-                q[i] = p[i];
-
-            p += len;
-            break;
-        }
-        _mm_storeu_si128(reinterpret_cast<__m128i *>(os_->PushUnsafe(16)), s);
-    }
-
-    is.src_ = p;
-    return RAPIDJSON_LIKELY(is.Tell() < length);
-}
-#elif defined(RAPIDJSON_NEON)
-template<>
-inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length) {
-    if (length < 16)
-        return RAPIDJSON_LIKELY(is.Tell() < length);
-
-    if (!RAPIDJSON_LIKELY(is.Tell() < length))
-        return false;
-
-    const char* p = is.src_;
-    const char* end = is.head_ + length;
-    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-    const char* endAligned = reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
-    if (nextAligned > end)
-        return true;
-
-    while (p != nextAligned)
-        if (*p < 0x20 || *p == '\"' || *p == '\\') {
-            is.src_ = p;
-            return RAPIDJSON_LIKELY(is.Tell() < length);
-        }
-        else
-            os_->PutUnsafe(*p++);
-
-    // The rest of string using SIMD
-    const uint8x16_t s0 = vmovq_n_u8('"');
-    const uint8x16_t s1 = vmovq_n_u8('\\');
-    const uint8x16_t s2 = vmovq_n_u8('\b');
-    const uint8x16_t s3 = vmovq_n_u8(32);
-
-    for (; p != endAligned; p += 16) {
-        const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
-        uint8x16_t x = vceqq_u8(s, s0);
-        x = vorrq_u8(x, vceqq_u8(s, s1));
-        x = vorrq_u8(x, vceqq_u8(s, s2));
-        x = vorrq_u8(x, vcltq_u8(s, s3));
-
-        x = vrev64q_u8(x);                     // Rev in 64
-        uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
-        uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
-
-        SizeType len = 0;
-        bool escaped = false;
-        if (low == 0) {
-            if (high != 0) {
-                uint32_t lz = internal::clzll(high);
-                len = 8 + (lz >> 3);
-                escaped = true;
-            }
-        } else {
-            uint32_t lz = internal::clzll(low);
-            len = lz >> 3;
-            escaped = true;
-        }
-        if (RAPIDJSON_UNLIKELY(escaped)) {   // some of characters is escaped
-            char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
-            for (size_t i = 0; i < len; i++)
-                q[i] = p[i];
-
-            p += len;
-            break;
-        }
-        vst1q_u8(reinterpret_cast<uint8_t *>(os_->PushUnsafe(16)), s);
-    }
-
-    is.src_ = p;
-    return RAPIDJSON_LIKELY(is.Tell() < length);
-}
-#endif // RAPIDJSON_NEON
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(_MSC_VER) || defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/thirdparty/yyjson/yyjson.c b/thirdparty/yyjson/yyjson.c
deleted file mode 100644
index abaa716..0000000
--- a/thirdparty/yyjson/yyjson.c
+++ /dev/null
@@ -1,8004 +0,0 @@
-/*==============================================================================
- * Created by Yaoyuan on 2019/3/9.
- * Copyright (C) 2019 Yaoyuan <ibireme@gmail.com>.
- *
- * Released under the MIT License:
- * https://github.com/ibireme/yyjson/blob/master/LICENSE
- *============================================================================*/
-
-#include "yyjson.h"
-#include <stdio.h>
-#include <math.h>
-
-
-
-/*==============================================================================
- * Compile Hint Begin
- *============================================================================*/
-
-/* warning suppress begin */
-#if defined(__clang__)
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wunused-function"
-#   pragma clang diagnostic ignored "-Wunused-parameter"
-#   pragma clang diagnostic ignored "-Wunused-label"
-#   pragma clang diagnostic ignored "-Wunused-macros"
-#elif defined(__GNUC__)
-#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#   pragma GCC diagnostic push
-#   endif
-#   pragma GCC diagnostic ignored "-Wunused-function"
-#   pragma GCC diagnostic ignored "-Wunused-parameter"
-#   pragma GCC diagnostic ignored "-Wunused-label"
-#   pragma GCC diagnostic ignored "-Wunused-macros"
-#elif defined(_MSC_VER)
-#   pragma warning(push)
-#   pragma warning(disable:4100) /* unreferenced formal parameter */
-#   pragma warning(disable:4102) /* unreferenced label */
-#   pragma warning(disable:4127) /* conditional expression is constant */
-#   pragma warning(disable:4706) /* assignment within conditional expression */
-#endif
-
-
-
-/*==============================================================================
- * Version
- *============================================================================*/
-
-yyjson_api uint32_t yyjson_version(void) {
-    return YYJSON_VERSION_HEX;
-}
-
-
-
-/*==============================================================================
- * Flags
- *============================================================================*/
-
-/* gcc version check */
-#if defined(__GNUC__)
-#   if defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#       define yyjson_gcc_available(major, minor, patch) \
-            ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) \
-            >= (major * 10000 + minor * 100 + patch))
-#   elif defined(__GNUC_MINOR__)
-#       define yyjson_gcc_available(major, minor, patch) \
-            ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100) \
-            >= (major * 10000 + minor * 100 + patch))
-#   else
-#       define yyjson_gcc_available(major, minor, patch) \
-            ((__GNUC__ * 10000) >= (major * 10000 + minor * 100 + patch))
-#   endif
-#else
-#       define yyjson_gcc_available(major, minor, patch) 0
-#endif
-
-/* real gcc check */
-#if !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__ICC) && \
-    defined(__GNUC__) && defined(__GNUC_MINOR__)
-#   define YYJSON_IS_REAL_GCC 1
-#else
-#   define YYJSON_IS_REAL_GCC 0
-#endif
-
-/* msvc intrinsic */
-#if YYJSON_MSC_VER >= 1400
-#   include <intrin.h>
-#   if defined(_M_AMD64) || defined(_M_ARM64)
-#       define MSC_HAS_BIT_SCAN_64 1
-#       pragma intrinsic(_BitScanForward64)
-#       pragma intrinsic(_BitScanReverse64)
-#   else
-#       define MSC_HAS_BIT_SCAN_64 0
-#   endif
-#   if defined(_M_AMD64) || defined(_M_ARM64) || \
-        defined(_M_IX86) || defined(_M_ARM)
-#       define MSC_HAS_BIT_SCAN 1
-#       pragma intrinsic(_BitScanForward)
-#       pragma intrinsic(_BitScanReverse)
-#   else
-#       define MSC_HAS_BIT_SCAN 0
-#   endif
-#   if defined(_M_AMD64)
-#       define MSC_HAS_UMUL128 1
-#       pragma intrinsic(_umul128)
-#   else
-#       define MSC_HAS_UMUL128 0
-#   endif
-#else
-#   define MSC_HAS_BIT_SCAN_64 0
-#   define MSC_HAS_BIT_SCAN 0
-#   define MSC_HAS_UMUL128 0
-#endif
-
-/* gcc builtin */
-#if yyjson_has_builtin(__builtin_clzll) || yyjson_gcc_available(3, 4, 0)
-#   define GCC_HAS_CLZLL 1
-#else
-#   define GCC_HAS_CLZLL 0
-#endif
-
-#if yyjson_has_builtin(__builtin_ctzll) || yyjson_gcc_available(3, 4, 0)
-#   define GCC_HAS_CTZLL 1
-#else
-#   define GCC_HAS_CTZLL 0
-#endif
-
-/* int128 type */
-#if defined(__SIZEOF_INT128__) && (__SIZEOF_INT128__ == 16) && \
-    (defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER))
-#    define YYJSON_HAS_INT128 1
-#else
-#    define YYJSON_HAS_INT128 0
-#endif
-
-/* IEEE 754 floating-point binary representation */
-#if defined(__STDC_IEC_559__) || defined(__STDC_IEC_60559_BFP__)
-#   define YYJSON_HAS_IEEE_754 1
-#elif (FLT_RADIX == 2) && (DBL_MANT_DIG == 53) && (DBL_DIG == 15) && \
-     (DBL_MIN_EXP == -1021) && (DBL_MAX_EXP == 1024) && \
-     (DBL_MIN_10_EXP == -307) && (DBL_MAX_10_EXP == 308)
-#   define YYJSON_HAS_IEEE_754 1
-#else
-#   define YYJSON_HAS_IEEE_754 0
-#endif
-
-/*
- Correct rounding in double number computations.
- 
- On the x86 architecture, some compilers may use x87 FPU instructions for
- floating-point arithmetic. The x87 FPU loads all floating point number as
- 80-bit double-extended precision internally, then rounds the result to original
- precision, which may produce inaccurate results. For a more detailed
- explanation, see the paper: https://arxiv.org/abs/cs/0701192
- 
- Here are some examples of double precision calculation error:
- 
-     2877.0 / 1e6   == 0.002877,  but x87 returns 0.0028770000000000002
-     43683.0 * 1e21 == 4.3683e25, but x87 returns 4.3683000000000004e25
- 
- Here are some examples of compiler flags to generate x87 instructions on x86:
- 
-     clang -m32 -mno-sse
-     gcc/icc -m32 -mfpmath=387
-     msvc /arch:SSE or /arch:IA32
- 
- If we are sure that there's no similar error described above, we can define the
- YYJSON_DOUBLE_MATH_CORRECT as 1 to enable the fast path calculation. This is
- not an accurate detection, it's just try to avoid the error at compile-time.
- An accurate detection can be done at run-time:
- 
-     bool is_double_math_correct(void) {
-         volatile double r = 43683.0;
-         r *= 1e21;
-         return r == 4.3683e25;
-     }
- 
- See also: utils.h in https://github.com/google/double-conversion/
- */
-#if !defined(FLT_EVAL_METHOD) && defined(__FLT_EVAL_METHOD__)
-#    define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
-#endif
-
-#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0 && FLT_EVAL_METHOD != 1
-#    define YYJSON_DOUBLE_MATH_CORRECT 0
-#elif defined(i386) || defined(__i386) || defined(__i386__) || \
-    defined(_X86_) || defined(__X86__) || defined(_M_IX86) || \
-    defined(__I86__) || defined(__IA32__) || defined(__THW_INTEL)
-#   if (defined(_MSC_VER) && defined(_M_IX86_FP) && _M_IX86_FP == 2) || \
-        (defined(__SSE2_MATH__) && __SSE2_MATH__)
-#       define YYJSON_DOUBLE_MATH_CORRECT 1
-#   else
-#       define YYJSON_DOUBLE_MATH_CORRECT 0
-#   endif
-#elif defined(__x86_64) || defined(__x86_64__) || \
-    defined(__amd64) || defined(__amd64__) || \
-    defined(_M_AMD64) || defined(_M_X64) || \
-    defined(__ia64) || defined(_IA64) || defined(__IA64__) ||  \
-    defined(__ia64__) || defined(_M_IA64) || defined(__itanium__) || \
-    defined(__arm64) || defined(__arm64__) || \
-    defined(__aarch64__) || defined(_M_ARM64) || \
-    defined(__arm) || defined(__arm__) || defined(_ARM_) || \
-    defined(_ARM) || defined(_M_ARM) || defined(__TARGET_ARCH_ARM) || \
-    defined(mips) || defined(__mips) || defined(__mips__) || \
-    defined(MIPS) || defined(_MIPS_) || defined(__MIPS__) || \
-    defined(_ARCH_PPC64) || defined(__PPC64__) || \
-    defined(__ppc64__) || defined(__powerpc64__) || \
-    defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) || \
-    defined(__ppc__) || defined(__ppc) || defined(__PPC__) || \
-    defined(__sparcv9) || defined(__sparc_v9__) || \
-    defined(__sparc) || defined(__sparc__) || defined(__sparc64__) || \
-    defined(__alpha) || defined(__alpha__) || defined(_M_ALPHA) || \
-    defined(__or1k__) || defined(__OR1K__) || defined(OR1K) || \
-    defined(__hppa) || defined(__hppa__) || defined(__HPPA__) || \
-    defined(__riscv) || defined(__riscv__) || \
-    defined(__s390__) || defined(__avr32__) || defined(__SH4__) || \
-    defined(__e2k__) || defined(__arc__) || defined(__ARC64__) || \
-    defined(__loongarch__) || defined(__nios2__) || defined(__ghs) || \
-    defined(__microblaze__) || defined(__XTENSA__) || \
-    defined(__EMSCRIPTEN__) || defined(__wasm__)
-#   define YYJSON_DOUBLE_MATH_CORRECT 1
-#else
-#   define YYJSON_DOUBLE_MATH_CORRECT 0 /* unknown, disable fast path */
-#endif
-
-/*
- Microsoft Visual C++ 6.0 doesn't support converting number from u64 to f64:
- error C2520: conversion from unsigned __int64 to double not implemented.
- */
-#ifndef YYJSON_U64_TO_F64_NO_IMPL
-#   if (0 < YYJSON_MSC_VER) && (YYJSON_MSC_VER <= 1200)
-#       define YYJSON_U64_TO_F64_NO_IMPL 1
-#   else
-#       define YYJSON_U64_TO_F64_NO_IMPL 0
-#   endif
-#endif
-
-/* endian */
-#if yyjson_has_include(<sys/types.h>)
-#    include <sys/types.h>
-#endif
-
-#if yyjson_has_include(<endian.h>)
-#    include <endian.h>
-#elif yyjson_has_include(<machine/endian.h>)
-#    include <machine/endian.h>
-#elif yyjson_has_include(<sys/endian.h>)
-#    include <sys/endian.h>
-#endif
-
-#define YYJSON_BIG_ENDIAN       4321
-#define YYJSON_LITTLE_ENDIAN    1234
-
-#if defined(__BYTE_ORDER__) && __BYTE_ORDER__
-#   if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#       define YYJSON_ENDIAN YYJSON_BIG_ENDIAN
-#   elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#       define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN
-#   endif
-
-#elif defined(__BYTE_ORDER) && __BYTE_ORDER
-#   if __BYTE_ORDER == __BIG_ENDIAN
-#       define YYJSON_ENDIAN YYJSON_BIG_ENDIAN
-#   elif __BYTE_ORDER == __LITTLE_ENDIAN
-#       define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN
-#   endif
-
-#elif defined(BYTE_ORDER) && BYTE_ORDER
-#   if BYTE_ORDER == BIG_ENDIAN
-#       define YYJSON_ENDIAN YYJSON_BIG_ENDIAN
-#   elif BYTE_ORDER == LITTLE_ENDIAN
-#       define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN
-#   endif
-
-#elif (defined(__LITTLE_ENDIAN__) && __LITTLE_ENDIAN__ == 1) || \
-    defined(__i386) || defined(__i386__) || \
-    defined(_X86_) || defined(__X86__) || \
-    defined(_M_IX86) || defined(__THW_INTEL__) || \
-    defined(__x86_64) || defined(__x86_64__) || \
-    defined(__amd64) || defined(__amd64__) || \
-    defined(_M_AMD64) || defined(_M_X64) || \
-    defined(__ia64) || defined(_IA64) || defined(__IA64__) ||  \
-    defined(__ia64__) || defined(_M_IA64) || defined(__itanium__) || \
-    defined(__ARMEL__) || defined(__THUMBEL__) || defined(__AARCH64EL__) || \
-    defined(__alpha) || defined(__alpha__) || defined(_M_ALPHA) || \
-    defined(__riscv) || defined(__riscv__) || \
-    defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__) || \
-    defined(__EMSCRIPTEN__) || defined(__wasm__)
-#   define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN
-
-#elif (defined(__BIG_ENDIAN__) && __BIG_ENDIAN__ == 1) || \
-    defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) || \
-    defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__) || \
-    defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
-    defined(__ppc) || defined(__ppc__) || \
-    defined(__sparc) || defined(__sparc__) || defined(__sparc64__) || \
-    defined(__or1k__) || defined(__OR1K__)
-#   define YYJSON_ENDIAN YYJSON_BIG_ENDIAN
-
-#else
-#   define YYJSON_ENDIAN 0 /* unknown endian, detect at run-time */
-#endif
-
-/*
- Unaligned memory access detection.
- 
- Some architectures cannot perform unaligned memory accesse, or unaligned memory
- accesses can have a large performance penalty. Modern compilers can make some
- optimizations for unaligned access. For example: https://godbolt.org/z/Ejo3Pa
- 
-    typedef struct { char c[2] } vec2;
-    void copy_vec2(vec2 *dst, vec2 *src) {
-        *dst = *src;
-    }
- 
- Compiler may generate `load/store` or `move` instruction if target architecture
- supports unaligned access, otherwise it may generate `call memcpy` instruction.
- 
- We want to avoid `memcpy` calls, so we should disable unaligned access by
- define `YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS` as 1 on these architectures.
- */
-#ifndef YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-#   if defined(i386) || defined(__i386) || defined(__i386__) || \
-        defined(__i486__) || defined(__i586__) || defined(__i686__) || \
-        defined(_X86_) || defined(__X86__) || defined(_M_IX86) || \
-        defined(__I86__) || defined(__IA32__) || \
-        defined(__THW_INTEL) || defined(__THW_INTEL__) || \
-        defined(__x86_64) || defined(__x86_64__) || \
-        defined(__amd64) || defined(__amd64__) || \
-        defined(_M_AMD64) || defined(_M_X64)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 0 /* x86 */
-
-#   elif defined(__ia64) || defined(_IA64) || defined(__IA64__) ||  \
-        defined(__ia64__) || defined(_M_IA64) || defined(__itanium__)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* Itanium */
-
-#   elif defined(__arm64) || defined(__arm64__) || \
-        defined(__AARCH64EL__) || defined(__AARCH64EB__) || \
-        defined(__aarch64__) || defined(_M_ARM64)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 0 /* ARM64 */
-
-#   elif defined(__ARM_ARCH_4__) || defined(__ARM_ARCH_4T__) || \
-        defined(__ARM_ARCH_5TEJ__) || defined(__ARM_ARCH_5TE__) || \
-        defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_6KZ__) || \
-        defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6K__)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* ARM */
-
-#   elif defined(__ppc64__) || defined(__PPC64__) || \
-        defined(__powerpc64__) || defined(_ARCH_PPC64) || \
-        defined(__ppc) || defined(__ppc__) || defined(__PPC__) || \
-        defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) || \
-        defined(_ARCH_PPC) || defined(_M_PPC) || \
-        defined(__PPCGECKO__) || defined(__PPCBROADWAY__) || defined(_XENON)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 0 /* PowerPC */
-
-#   else
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 0 /* Unknown */
-#   endif
-
-#endif
-
-/*
- Estimated initial ratio of the JSON data (data_size / value_count).
- For example:
-    
-    data:        {"id":12345678,"name":"Harry"}
-    data_size:   30
-    value_count: 5
-    ratio:       6
-    
- yyjson uses dynamic memory with a growth factor of 1.5 when reading and writing
- JSON, the ratios below are used to determine the initial memory size.
- 
- A too large ratio will waste memory, and a too small ratio will cause multiple
- memory growths and degrade performance. Currently these ratios are generated
- with some commonly used JSON datasets.
- */
-#define YYJSON_READER_ESTIMATED_PRETTY_RATIO 16
-#define YYJSON_READER_ESTIMATED_MINIFY_RATIO 6
-#define YYJSON_WRITER_ESTIMATED_PRETTY_RATIO 32
-#define YYJSON_WRITER_ESTIMATED_MINIFY_RATIO 18
-
-/* Default value for compile-time options. */
-#ifndef YYJSON_DISABLE_READER
-#define YYJSON_DISABLE_READER 0
-#endif
-#ifndef YYJSON_DISABLE_WRITER
-#define YYJSON_DISABLE_WRITER 0
-#endif
-#ifndef YYJSON_DISABLE_FAST_FP_CONV
-#define YYJSON_DISABLE_FAST_FP_CONV 0
-#endif
-#ifndef YYJSON_DISABLE_NON_STANDARD
-#define YYJSON_DISABLE_NON_STANDARD 0
-#endif
-
-
-
-/*==============================================================================
- * Macros
- *============================================================================*/
-
-/* Macros used for loop unrolling and other purpose. */
-#define repeat2(x)  { x x }
-#define repeat3(x)  { x x x }
-#define repeat4(x)  { x x x x }
-#define repeat8(x)  { x x x x x x x x }
-#define repeat16(x) { x x x x x x x x x x x x x x x x }
-
-#define repeat2_incr(x)  { x(0) x(1) }
-#define repeat4_incr(x)  { x(0) x(1) x(2) x(3) }
-#define repeat8_incr(x)  { x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) }
-#define repeat16_incr(x) { x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) \
-                           x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) }
-#define repeat_in_1_18(x) { x(1) x(2) x(3) x(4) x(5) x(6) x(7) \
-                            x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) \
-                            x(16) x(17) x(18) }
-
-/* Macros used to provide branch prediction information for compiler. */
-#undef  likely
-#define likely(x)       yyjson_likely(x)
-#undef  unlikely
-#define unlikely(x)     yyjson_unlikely(x)
-
-/* Macros used to provide inline information for compiler. */
-#undef  static_inline
-#define static_inline   static yyjson_inline
-#undef  static_noinline
-#define static_noinline static yyjson_noinline
-
-/* Macros for min and max. */
-#undef  yyjson_min
-#define yyjson_min(x, y) ((x) < (y) ? (x) : (y))
-#undef  yyjson_max
-#define yyjson_max(x, y) ((x) > (y) ? (x) : (y))
-
-/* Used to write u64 literal for C89 which doesn't support "ULL" suffix. */
-#undef  U64
-#define U64(hi, lo) ((((u64)hi##UL) << 32U) + lo##UL)
-
-
-
-/*==============================================================================
- * Integer Constants
- *============================================================================*/
-
-/* U64 constant values */
-#undef  U64_MAX
-#define U64_MAX         U64(0xFFFFFFFF, 0xFFFFFFFF)
-#undef  I64_MAX
-#define I64_MAX         U64(0x7FFFFFFF, 0xFFFFFFFF)
-#undef  USIZE_MAX
-#define USIZE_MAX       ((usize)(~(usize)0))
-
-/* Maximum number of digits for reading u64 safety. */
-#undef  U64_SAFE_DIG
-#define U64_SAFE_DIG    19
-
-
-
-/*==============================================================================
- * IEEE-754 Double Number Constants
- *============================================================================*/
-
-/* Inf raw value (positive) */
-#define F64_RAW_INF U64(0x7FF00000, 0x00000000)
-
-/* NaN raw value (positive, without payload) */
-#define F64_RAW_NAN U64(0x7FF80000, 0x00000000)
-
-/* double number bits */
-#define F64_BITS 64
-
-/* double number exponent part bits */
-#define F64_EXP_BITS 11
-
-/* double number significand part bits */
-#define F64_SIG_BITS 52
-
-/* double number significand part bits (with 1 hidden bit) */
-#define F64_SIG_FULL_BITS 53
-
-/* double number significand bit mask */
-#define F64_SIG_MASK U64(0x000FFFFF, 0xFFFFFFFF)
-
-/* double number exponent bit mask */
-#define F64_EXP_MASK U64(0x7FF00000, 0x00000000)
-
-/* double number exponent bias */
-#define F64_EXP_BIAS 1023
-
-/* double number significant digits count in decimal */
-#define F64_DEC_DIG 17
-
-/* max significant digits count in decimal when reading double number */
-#define F64_MAX_DEC_DIG 768
-
-/* maximum decimal power of double number (1.7976931348623157e308) */
-#define F64_MAX_DEC_EXP 308
-
-/* minimum decimal power of double number (4.9406564584124654e-324) */
-#define F64_MIN_DEC_EXP (-324)
-
-/* maximum binary power of double number */
-#define F64_MAX_BIN_EXP 1024
-
-/* minimum binary power of double number */
-#define F64_MIN_BIN_EXP (-1021)
-
-
-
-/*==============================================================================
- * Types
- *============================================================================*/
-
-/** Type define for primitive types. */
-typedef float       f32;
-typedef double      f64;
-typedef int8_t      i8;
-typedef uint8_t     u8;
-typedef int16_t     i16;
-typedef uint16_t    u16;
-typedef int32_t     i32;
-typedef uint32_t    u32;
-typedef int64_t     i64;
-typedef uint64_t    u64;
-typedef size_t      usize;
-
-/** 128-bit integer, used by floating-point number reader and writer. */
-#if YYJSON_HAS_INT128
-__extension__ typedef __int128          i128;
-__extension__ typedef unsigned __int128 u128;
-#endif
-
-/** 16/32/64-bit vector */
-typedef struct v16 { char c1, c2; } v16;
-typedef struct v32 { char c1, c2, c3, c4; } v32;
-typedef struct v64 { char c1, c2, c3, c4, c5, c6, c7, c8; } v64;
-
-/** 16/32/64-bit vector union, used for unaligned memory access on modern CPU */
-typedef union v16_uni { v16 v; u16 u; } v16_uni;
-typedef union v32_uni { v32 v; u32 u; } v32_uni;
-typedef union v64_uni { v64 v; u64 u; } v64_uni;
-
-
-
-/*==============================================================================
- * Load/Store Utils
- *============================================================================*/
-
-#define byte_move_idx(x) ((u8 *)dst)[x] = ((u8 *)src)[x];
-
-static_inline void byte_move_2(void *dst, const void *src) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    repeat2_incr(byte_move_idx);
-#else
-    memmove(dst, src, 2);
-#endif
-}
-
-static_inline void byte_move_4(void *dst, const void *src) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    repeat4_incr(byte_move_idx);
-#else
-    memmove(dst, src, 4);
-#endif
-}
-
-static_inline void byte_move_8(void *dst, const void *src) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    repeat8_incr(byte_move_idx);
-#else
-    memmove(dst, src, 8);
-#endif
-}
-
-static_inline void byte_move_16(void *dst, const void *src) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    repeat16_incr(byte_move_idx);
-#else
-    memmove(dst, src, 16);
-#endif
-}
-
-static_inline void byte_copy_2(void *dst, const void *src) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    repeat2_incr(byte_move_idx);
-#else
-    memcpy(dst, src, 2);
-#endif
-}
-
-static_inline void byte_copy_4(void *dst, const void *src) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    repeat4_incr(byte_move_idx);
-#else
-    memcpy(dst, src, 4);
-#endif
-}
-
-static_inline void byte_copy_8(void *dst, const void *src) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    repeat8_incr(byte_move_idx);
-#else
-    memcpy(dst, src, 8);
-#endif
-}
-
-static_inline void byte_copy_16(void *dst, const void *src) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    repeat16_incr(byte_move_idx);
-#else
-    memcpy(dst, src, 16);
-#endif
-}
-
-static_inline bool byte_match_2(void *buf, const char *pat) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    return
-    ((u8 *)buf)[0] == ((const u8 *)pat)[0] &&
-    ((u8 *)buf)[1] == ((const u8 *)pat)[1];
-#else
-    v16_uni u1, u2;
-    u1.v = *(const v16 *)pat;
-    u2.v = *(const v16 *)buf;
-    return u1.u == u2.u;
-#endif
-}
-
-static_inline bool byte_match_4(void *buf, const char *pat) {
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-    return
-    ((u8 *)buf)[0] == ((const u8 *)pat)[0] &&
-    ((u8 *)buf)[1] == ((const u8 *)pat)[1] &&
-    ((u8 *)buf)[2] == ((const u8 *)pat)[2] &&
-    ((u8 *)buf)[3] == ((const u8 *)pat)[3];
-#else
-    v32_uni u1, u2;
-    u1.v = *(const v32 *)pat;
-    u2.v = *(const v32 *)buf;
-    return u1.u == u2.u;
-#endif
-}
-
-static_inline u16 byte_load_2(const void *src) {
-    v16_uni uni;
-    uni.v = *(v16 *)src;
-    return uni.u;
-}
-
-static_inline u32 byte_load_3(const void *src) {
-    v32_uni uni;
-    ((v16_uni *)&uni)->v = *(v16 *)src;
-    uni.v.c3 = ((char *)src)[2];
-    uni.v.c4 = 0;
-    return uni.u;
-}
-
-static_inline u32 byte_load_4(const void *src) {
-    v32_uni uni;
-    uni.v = *(v32 *)src;
-    return uni.u;
-}
-
-#undef byte_move_expr
-
-
-
-/*==============================================================================
- * Number Utils
- * These functions are used to detect and convert NaN and Inf numbers.
- *============================================================================*/
-
-/**
- This union is used to avoid violating the strict aliasing rule in C.
- `memcpy` can be used in both C and C++, but it may reduce performance without
- compiler optimization.
- */
-typedef union { u64 u; f64 f; } f64_uni;
-
-/** Convert raw binary to double. */
-static_inline f64 f64_from_raw(u64 u) {
-#ifndef __cplusplus
-    f64_uni uni;
-    uni.u = u;
-    return uni.f;
-#else
-    f64 f;
-    memcpy(&f, &u, 8);
-    return f;
-#endif
-}
-
-/** Convert double to raw binary. */
-static_inline u64 f64_to_raw(f64 f) {
-#ifndef __cplusplus
-    f64_uni uni;
-    uni.f = f;
-    return uni.u;
-#else
-    u64 u;
-    memcpy(&u, &f, 8);
-    return u;
-#endif
-}
-
-/** Get raw 'infinity' with sign. */
-static_inline u64 f64_raw_get_inf(bool sign) {
-#if YYJSON_HAS_IEEE_754
-    return F64_RAW_INF | ((u64)sign << 63);
-#elif defined(INFINITY)
-    return f64_to_raw(sign ? -INFINITY : INFINITY);
-#else
-    return f64_to_raw(sign ? -HUGE_VAL : HUGE_VAL);
-#endif
-}
-
-/** Get raw 'nan' with sign. */
-static_inline u64 f64_raw_get_nan(bool sign) {
-#if YYJSON_HAS_IEEE_754
-    return F64_RAW_NAN | ((u64)sign << 63);
-#elif defined(NAN)
-    return f64_to_raw(sign ? (f64)-NAN : (f64)NAN);
-#else
-    return f64_to_raw((sign ? -0.0 : 0.0) / 0.0);
-#endif
-}
-
-/**
- Convert normalized u64 (highest bit is 1) to f64.
- 
- Some compiler (such as Microsoft Visual C++ 6.0) do not support converting
- number from u64 to f64. This function will first convert u64 to i64 and then
- to f64, with `to nearest` rounding mode.
- */
-static_inline f64 normalized_u64_to_f64(u64 val) {
-#if YYJSON_U64_TO_F64_NO_IMPL
-    i64 sig = (i64)((val >> 1) | (val & 1));
-    return ((f64)sig) * (f64)2.0;
-#else
-    return (f64)val;
-#endif
-}
-
-
-
-/*==============================================================================
- * Size Utils
- * These functions are used for memory allocation.
- *============================================================================*/
-
-/** Returns whether the size is overflow after increment. */
-static_inline bool size_add_is_overflow(usize size, usize add) {
-    usize val = size + add;
-    return (val < size) | (val < add);
-}
-
-/** Returns whether the size is power of 2 (size should not be 0). */
-static_inline bool size_is_pow2(usize size) {
-    return (size & (size - 1)) == 0;
-}
-
-/** Align size upwards (may overflow). */
-static_inline usize size_align_up(usize size, usize align) {
-    if (size_is_pow2(align)) {
-        return (size + (align - 1)) & ~(align - 1);
-    } else {
-        return size + align - (size + align - 1) % align - 1;
-    }
-}
-
-/** Align size downwards. */
-static_inline usize size_align_down(usize size, usize align) {
-    if (size_is_pow2(align)) {
-        return size & ~(align - 1);
-    } else {
-        return size - (size % align);
-    }
-}
-
-/** Align address upwards (may overflow). */
-static_inline void *mem_align_up(void *mem, usize align) {
-    usize size;
-    memcpy(&size, &mem, sizeof(usize));
-    size = size_align_up(size, align);
-    memcpy(&mem, &size, sizeof(usize));
-    return mem;
-}
-
-/** Align address downwards. */
-static_inline void *mem_align_down(void *mem, usize align) {
-    usize size;
-    memcpy(&size, &mem, sizeof(usize));
-    size = size_align_down(size, align);
-    memcpy(&mem, &size, sizeof(usize));
-    return mem;
-}
-
-
-
-/*==============================================================================
- * Bits Utils
- * These functions are used by the floating-point number reader and writer.
- *============================================================================*/
-
-/** Returns the number of leading 0-bits in value (input should not be 0). */
-static_inline u32 u64_lz_bits(u64 v) {
-#if GCC_HAS_CLZLL
-    return (u32)__builtin_clzll(v);
-#elif MSC_HAS_BIT_SCAN_64
-    unsigned long r;
-    _BitScanReverse64(&r, v);
-    return (u32)63 - (u32)r;
-#elif MSC_HAS_BIT_SCAN
-    unsigned long hi, lo;
-    bool hi_set = _BitScanReverse(&hi, (u32)(v >> 32)) != 0;
-    _BitScanReverse(&lo, (u32)v);
-    hi |= 32;
-    return (u32)63 - (u32)(hi_set ? hi : lo);
-#else
-    /*
-     branchless, use de Bruijn sequences
-     see: https://www.chessprogramming.org/BitScan
-     */
-    const u8 table[64] = {
-        63, 16, 62,  7, 15, 36, 61,  3,  6, 14, 22, 26, 35, 47, 60,  2,
-         9,  5, 28, 11, 13, 21, 42, 19, 25, 31, 34, 40, 46, 52, 59,  1,
-        17,  8, 37,  4, 23, 27, 48, 10, 29, 12, 43, 20, 32, 41, 53, 18,
-        38, 24, 49, 30, 44, 33, 54, 39, 50, 45, 55, 51, 56, 57, 58,  0
-    };
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    v |= v >> 32;
-    return table[(v * U64(0x03F79D71, 0xB4CB0A89)) >> 58];
-#endif
-}
-
-/** Returns the number of trailing 0-bits in value (input should not be 0). */
-static_inline u32 u64_tz_bits(u64 v) {
-#if GCC_HAS_CTZLL
-    return (u32)__builtin_ctzll(v);
-#elif MSC_HAS_BIT_SCAN_64
-    unsigned long r;
-    _BitScanForward64(&r, v);
-    return (u32)r;
-#elif MSC_HAS_BIT_SCAN
-    unsigned long lo, hi;
-    bool lo_set = _BitScanForward(&lo, (u32)(v)) != 0;
-    _BitScanForward(&hi, (u32)(v >> 32));
-    hi += 32;
-    return lo_set ? lo : hi;
-#else
-    /*
-     branchless, use de Bruijn sequences
-     see: https://www.chessprogramming.org/BitScan
-     */
-    const u8 table[64] = {
-         0,  1,  2, 53,  3,  7, 54, 27,  4, 38, 41,  8, 34, 55, 48, 28,
-        62,  5, 39, 46, 44, 42, 22,  9, 24, 35, 59, 56, 49, 18, 29, 11,
-        63, 52,  6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10,
-        51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12
-    };
-    return table[((v & (~v + 1)) * U64(0x022FDD63, 0xCC95386D)) >> 58];
-#endif
-}
-
-
-
-/*==============================================================================
- * 128-bit Integer Utils
- * These functions are used by the floating-point number reader and writer.
- *============================================================================*/
-
-/** Multiplies two 64-bit unsigned integers (a * b),
-    returns the 128-bit result as 'hi' and 'lo'. */
-static_inline void u128_mul(u64 a, u64 b, u64 *hi, u64 *lo) {
-#if YYJSON_HAS_INT128
-    u128 m = (u128)a * b;
-    *hi = (u64)(m >> 64);
-    *lo = (u64)(m);
-#elif MSC_HAS_UMUL128
-    *lo = _umul128(a, b, hi);
-#else
-    u32 a0 = (u32)(a), a1 = (u32)(a >> 32);
-    u32 b0 = (u32)(b), b1 = (u32)(b >> 32);
-    u64 p00 = (u64)a0 * b0, p01 = (u64)a0 * b1;
-    u64 p10 = (u64)a1 * b0, p11 = (u64)a1 * b1;
-    u64 m0 = p01 + (p00 >> 32);
-    u32 m00 = (u32)(m0), m01 = (u32)(m0 >> 32);
-    u64 m1 = p10 + m00;
-    u32 m10 = (u32)(m1), m11 = (u32)(m1 >> 32);
-    *hi = p11 + m01 + m11;
-    *lo = ((u64)m10 << 32) | (u32)p00;
-#endif
-}
-
-/** Multiplies two 64-bit unsigned integers and add a value (a * b + c),
-    returns the 128-bit result as 'hi' and 'lo'. */
-static_inline void u128_mul_add(u64 a, u64 b, u64 c, u64 *hi, u64 *lo) {
-#if YYJSON_HAS_INT128
-    u128 m = (u128)a * b + c;
-    *hi = (u64)(m >> 64);
-    *lo = (u64)(m);
-#else
-    u64 h, l, t;
-    u128_mul(a, b, &h, &l);
-    t = l + c;
-    h += (u64)(((t < l) | (t < c)));
-    *hi = h;
-    *lo = t;
-#endif
-}
-
-
-
-/*==============================================================================
- * File Utils
- * These functions are used to read and write JSON files.
- *============================================================================*/
-
-#define YYJSON_FOPEN_EXT
-#if !defined(_MSC_VER) && defined(__GLIBC__) && defined(__GLIBC_PREREQ)
-#   if __GLIBC_PREREQ(2, 7)
-#       undef YYJSON_FOPEN_EXT
-#       define YYJSON_FOPEN_EXT "e" /* glibc extension to enable O_CLOEXEC */
-#   endif
-#endif
-
-static_inline FILE *fopen_safe(const char *path, const char *mode) {
-#if YYJSON_MSC_VER >= 1400
-    FILE *file = NULL;
-    if (fopen_s(&file, path, mode) != 0) return NULL;
-    return file;
-#else
-    return fopen(path, mode);
-#endif
-}
-
-static_inline FILE *fopen_readonly(const char *path) {
-    return fopen_safe(path, "rb" YYJSON_FOPEN_EXT);
-}
-
-static_inline FILE *fopen_writeonly(const char *path) {
-    return fopen_safe(path, "wb" YYJSON_FOPEN_EXT);
-}
-
-static_inline usize fread_safe(void *buf, usize size, FILE *file) {
-#if YYJSON_MSC_VER >= 1400
-    return fread_s(buf, size, 1, size, file);
-#else
-    return fread(buf, 1, size, file);
-#endif
-}
-
-
-
-/*==============================================================================
- * Default Memory Allocator
- * This is a simple libc memory allocator wrapper.
- *============================================================================*/
-
-static void *default_malloc(void *ctx, usize size) {
-    return malloc(size);
-}
-
-static void *default_realloc(void *ctx, void *ptr, usize size) {
-    return realloc(ptr, size);
-}
-
-static void default_free(void *ctx, void *ptr) {
-    free(ptr);
-}
-
-static const yyjson_alc YYJSON_DEFAULT_ALC = {
-    default_malloc,
-    default_realloc,
-    default_free,
-    NULL
-};
-
-
-
-/*==============================================================================
- * Pool Memory Allocator
- * This is a simple memory allocator that uses linked list memory chunk.
- * The following code will be executed only when the library user creates
- * this allocator manually.
- *============================================================================*/
-
-/** chunk header */
-typedef struct pool_chunk {
-    usize size; /* chunk memory size (include chunk header) */
-    struct pool_chunk *next;
-} pool_chunk;
-
-/** ctx header */
-typedef struct pool_ctx {
-    usize size; /* total memory size (include ctx header) */
-    pool_chunk *free_list;
-} pool_ctx;
-
-static void *pool_malloc(void *ctx_ptr, usize size) {
-    pool_ctx *ctx = (pool_ctx *)ctx_ptr;
-    pool_chunk *next, *prev = NULL, *cur = ctx->free_list;
-    
-    if (unlikely(size == 0 || size >= ctx->size)) return NULL;
-    size = size_align_up(size, sizeof(pool_chunk)) + sizeof(pool_chunk);
-    
-    while (cur) {
-        if (cur->size < size) {
-            /* not enough space, try next chunk */
-            prev = cur;
-            cur = cur->next;
-            continue;
-        }
-        if (cur->size >= size + sizeof(pool_chunk) * 2) {
-            /* too much space, split this chunk */
-            next = (pool_chunk *)(void *)((u8 *)cur + size);
-            next->size = cur->size - size;
-            next->next = cur->next;
-            cur->size = size;
-        } else {
-            /* just enough space, use whole chunk */
-            next = cur->next;
-        }
-        if (prev) prev->next = next;
-        else ctx->free_list = next;
-        return (void *)(cur + 1);
-    }
-    return NULL;
-}
-
-static void pool_free(void *ctx_ptr, void *ptr) {
-    pool_ctx *ctx = (pool_ctx *)ctx_ptr;
-    pool_chunk *cur = ((pool_chunk *)ptr) - 1;
-    pool_chunk *prev = NULL, *next = ctx->free_list;
-    
-    while (next && next < cur) {
-        prev = next;
-        next = next->next;
-    }
-    if (prev) prev->next = cur;
-    else ctx->free_list = cur;
-    cur->next = next;
-    
-    if (next && ((u8 *)cur + cur->size) == (u8 *)next) {
-        /* merge cur to higher chunk */
-        cur->size += next->size;
-        cur->next = next->next;
-    }
-    if (prev && ((u8 *)prev + prev->size) == (u8 *)cur) {
-        /* merge cur to lower chunk */
-        prev->size += cur->size;
-        prev->next = cur->next;
-    }
-}
-
-static void *pool_realloc(void *ctx_ptr, void *ptr, usize size) {
-    pool_ctx *ctx = (pool_ctx *)ctx_ptr;
-    pool_chunk *cur = ((pool_chunk *)ptr) - 1, *prev, *next, *tmp;
-    usize free_size;
-    void *new_ptr;
-    
-    if (unlikely(size == 0 || size >= ctx->size)) return NULL;
-    size = size_align_up(size, sizeof(pool_chunk)) + sizeof(pool_chunk);
-    
-    /* reduce size */
-    if (unlikely(size <= cur->size)) {
-        free_size = cur->size - size;
-        if (free_size >= sizeof(pool_chunk) * 2) {
-            tmp = (pool_chunk *)(void *)((u8 *)cur + cur->size - free_size);
-            tmp->size = free_size;
-            pool_free(ctx_ptr, (void *)(tmp + 1));
-            cur->size -= free_size;
-        }
-        return ptr;
-    }
-    
-    /* find next and prev chunk */
-    prev = NULL;
-    next = ctx->free_list;
-    while (next && next < cur) {
-        prev = next;
-        next = next->next;
-    }
-    
-    /* merge to higher chunk if they are contiguous */
-    if ((u8 *)cur + cur->size == (u8 *)next &&
-        cur->size + next->size >= size) {
-        free_size = cur->size + next->size - size;
-        if (free_size > sizeof(pool_chunk) * 2) {
-            tmp = (pool_chunk *)(void *)((u8 *)cur + size);
-            if (prev) prev->next = tmp;
-            else ctx->free_list = tmp;
-            tmp->next = next->next;
-            tmp->size = free_size;
-            cur->size = size;
-        } else {
-            if (prev) prev->next = next->next;
-            else ctx->free_list = next->next;
-            cur->size += next->size;
-        }
-        return ptr;
-    }
-    
-    /* fallback to malloc and memcpy */
-    new_ptr = pool_malloc(ctx_ptr, size - sizeof(pool_chunk));
-    if (new_ptr) {
-        memcpy(new_ptr, ptr, cur->size - sizeof(pool_chunk));
-        pool_free(ctx_ptr, ptr);
-    }
-    return new_ptr;
-}
-
-bool yyjson_alc_pool_init(yyjson_alc *alc, void *buf, usize size) {
-    pool_chunk *chunk;
-    pool_ctx *ctx;
-    
-    if (unlikely(!alc || size < sizeof(pool_ctx) * 4)) return false;
-    ctx = (pool_ctx *)mem_align_up(buf, sizeof(pool_ctx));
-    if (unlikely(!ctx)) return false;
-    size -= (usize)((u8 *)ctx - (u8 *)buf);
-    size = size_align_down(size, sizeof(pool_ctx));
-    
-    chunk = (pool_chunk *)(ctx + 1);
-    chunk->size = size - sizeof(pool_ctx);
-    chunk->next = NULL;
-    ctx->size = size;
-    ctx->free_list = chunk;
-    
-    alc->malloc = pool_malloc;
-    alc->realloc = pool_realloc;
-    alc->free = pool_free;
-    alc->ctx = (void *)ctx;
-    return true;
-}
-
-
-
-/*==============================================================================
- * JSON document and value
- *============================================================================*/
-
-static_inline void unsafe_yyjson_str_pool_release(yyjson_str_pool *pool,
-                                                  yyjson_alc *alc) {
-    yyjson_str_chunk *chunk = pool->chunks, *next;
-    while (chunk) {
-        next = chunk->next;
-        alc->free(alc->ctx, chunk);
-        chunk = next;
-    }
-}
-
-static_inline void unsafe_yyjson_val_pool_release(yyjson_val_pool *pool,
-                                                  yyjson_alc *alc) {
-    yyjson_val_chunk *chunk = pool->chunks, *next;
-    while (chunk) {
-        next = chunk->next;
-        alc->free(alc->ctx, chunk);
-        chunk = next;
-    }
-}
-
-bool unsafe_yyjson_str_pool_grow(yyjson_str_pool *pool,
-                                 yyjson_alc *alc, usize len) {
-    yyjson_str_chunk *chunk;
-    usize size = len + sizeof(yyjson_str_chunk);
-    size = yyjson_max(pool->chunk_size, size);
-    chunk = (yyjson_str_chunk *)alc->malloc(alc->ctx, size);
-    if (yyjson_unlikely(!chunk)) return false;
-    
-    chunk->next = pool->chunks;
-    pool->chunks = chunk;
-    pool->cur = (char *)chunk + sizeof(yyjson_str_chunk);
-    pool->end = (char *)chunk + size;
-    
-    size = yyjson_min(pool->chunk_size * 2, pool->chunk_size_max);
-    pool->chunk_size = size;
-    return true;
-}
-
-bool unsafe_yyjson_val_pool_grow(yyjson_val_pool *pool,
-                                 yyjson_alc *alc, usize count) {
-    yyjson_val_chunk *chunk;
-    usize size;
-    
-    if (count >= USIZE_MAX / sizeof(yyjson_mut_val) - 16) return false;
-    size = (count + 1) * sizeof(yyjson_mut_val);
-    size = yyjson_max(pool->chunk_size, size);
-    chunk = (yyjson_val_chunk *)alc->malloc(alc->ctx, size);
-    if (yyjson_unlikely(!chunk)) return false;
-    
-    chunk->next = pool->chunks;
-    pool->chunks = chunk;
-    pool->cur = (yyjson_mut_val *)(void *)((u8 *)chunk
-                                           + sizeof(yyjson_mut_val));
-    pool->end = (yyjson_mut_val *)(void *)((u8 *)chunk + size);
-    
-    size = yyjson_min(pool->chunk_size * 2, pool->chunk_size_max);
-    pool->chunk_size = size;
-    return true;
-}
-
-void yyjson_mut_doc_free(yyjson_mut_doc *doc) {
-    if (doc) {
-        yyjson_alc alc = doc->alc;
-        unsafe_yyjson_str_pool_release(&doc->str_pool, &alc);
-        unsafe_yyjson_val_pool_release(&doc->val_pool, &alc);
-        alc.free(alc.ctx, doc);
-    }
-}
-
-yyjson_mut_doc *yyjson_mut_doc_new(const yyjson_alc *alc) {
-    yyjson_mut_doc *doc;
-    if (!alc) alc = &YYJSON_DEFAULT_ALC;
-    doc = (yyjson_mut_doc *)alc->malloc(alc->ctx, sizeof(yyjson_mut_doc));
-    if (!doc) return NULL;
-    memset(doc, 0, sizeof(yyjson_mut_doc));
-    
-    doc->alc = *alc;
-    doc->str_pool.chunk_size = 0x100;
-    doc->str_pool.chunk_size_max = 0x10000000;
-    doc->val_pool.chunk_size = 0x10 * sizeof(yyjson_mut_val);
-    doc->val_pool.chunk_size_max = 0x1000000 * sizeof(yyjson_mut_val);
-    return doc;
-}
-
-yyjson_api yyjson_mut_doc *yyjson_doc_mut_copy(yyjson_doc *doc,
-                                               const yyjson_alc *alc) {
-    yyjson_mut_doc *m_doc;
-    yyjson_mut_val *m_val;
-    
-    if (!doc || !doc->root) return NULL;
-    m_doc = yyjson_mut_doc_new(alc);
-    if (!m_doc) return NULL;
-    m_val = yyjson_val_mut_copy(m_doc, doc->root);
-    if (!m_val) {
-        yyjson_mut_doc_free(m_doc);
-        return NULL;
-    }
-    yyjson_mut_doc_set_root(m_doc, m_val);
-    return m_doc;
-}
-
-yyjson_api yyjson_mut_doc *yyjson_mut_doc_mut_copy(yyjson_mut_doc *doc,
-                                                   const yyjson_alc *alc) {
-    yyjson_mut_doc *m_doc;
-    yyjson_mut_val *m_val;
-    
-    if (!doc || !doc->root) return NULL;
-    m_doc = yyjson_mut_doc_new(alc);
-    if (!m_doc) return NULL;
-    m_val = yyjson_mut_val_mut_copy(m_doc, doc->root);
-    if (!m_val) {
-        yyjson_mut_doc_free(m_doc);
-        return NULL;
-    }
-    yyjson_mut_doc_set_root(m_doc, m_val);
-    return m_doc;
-}
-
-yyjson_api yyjson_mut_val *yyjson_val_mut_copy(yyjson_mut_doc *m_doc,
-                                               yyjson_val *i_vals) {
-    /*
-     The immutable object or array stores all sub-values in a contiguous memory,
-     We copy them to another contiguous memory as mutable values,
-     then reconnect the mutable values with the original relationship.
-     */
-    
-    usize i_vals_len;
-    yyjson_mut_val *m_vals, *m_val;
-    yyjson_val *i_val, *i_end;
-    
-    if (!m_doc || !i_vals) return NULL;
-    i_end = unsafe_yyjson_get_next(i_vals);
-    i_vals_len = (usize)(unsafe_yyjson_get_next(i_vals) - i_vals);
-    m_vals = unsafe_yyjson_mut_val(m_doc, i_vals_len);
-    if (!m_vals) return NULL;
-    i_val = i_vals;
-    m_val = m_vals;
-    
-    for (; i_val < i_end; i_val++, m_val++) {
-        yyjson_type type = unsafe_yyjson_get_type(i_val);
-        m_val->tag = i_val->tag;
-        m_val->uni.u64 = i_val->uni.u64;
-        if (type == YYJSON_TYPE_STR || type == YYJSON_TYPE_RAW) {
-            const char *str = i_val->uni.str;
-            usize str_len = unsafe_yyjson_get_len(i_val);
-            m_val->uni.str = unsafe_yyjson_mut_strncpy(m_doc, str, str_len);
-            if (!m_val->uni.str) return NULL;
-        } else if (type == YYJSON_TYPE_ARR) {
-            usize len = unsafe_yyjson_get_len(i_val);
-            if (len > 0) {
-                yyjson_val *ii_val = i_val + 1, *ii_next;
-                yyjson_mut_val *mm_val = m_val + 1, *mm_ctn = m_val, *mm_next;
-                while (len-- > 1) {
-                    ii_next = unsafe_yyjson_get_next(ii_val);
-                    mm_next = mm_val + (ii_next - ii_val);
-                    mm_val->next = mm_next;
-                    ii_val = ii_next;
-                    mm_val = mm_next;
-                }
-                mm_val->next = mm_ctn + 1;
-                mm_ctn->uni.ptr = mm_val;
-            }
-        } else if (type == YYJSON_TYPE_OBJ) {
-            usize len = unsafe_yyjson_get_len(i_val);
-            if (len > 0) {
-                yyjson_val *ii_key = i_val + 1, *ii_nextkey;
-                yyjson_mut_val *mm_key = m_val + 1, *mm_ctn = m_val;
-                yyjson_mut_val *mm_nextkey;
-                while (len-- > 1) {
-                    ii_nextkey = unsafe_yyjson_get_next(ii_key + 1);
-                    mm_nextkey = mm_key + (ii_nextkey - ii_key);
-                    mm_key->next = mm_key + 1;
-                    mm_key->next->next = mm_nextkey;
-                    ii_key = ii_nextkey;
-                    mm_key = mm_nextkey;
-                }
-                mm_key->next = mm_key + 1;
-                mm_key->next->next = mm_ctn + 1;
-                mm_ctn->uni.ptr = mm_key;
-            }
-        }
-    }
-    
-    return m_vals;
-}
-
-static yyjson_mut_val *unsafe_yyjson_mut_val_mut_copy(yyjson_mut_doc *m_doc,
-                                                      yyjson_mut_val *m_vals) {
-    /*
-     The mutable object or array stores all sub-values in a circular linked
-     list, so we can traverse them in the same loop. The traversal starts from
-     the last item, continues with the first item in a list, and ends with the
-     second to last item, which needs to be linked to the last item to close the
-     circle.
-     */
-    
-    yyjson_mut_val *m_val = unsafe_yyjson_mut_val(m_doc, 1);
-    if (unlikely(!m_val)) return NULL;
-    m_val->tag = m_vals->tag;
-    
-    switch (unsafe_yyjson_get_type(m_vals)) {
-        case YYJSON_TYPE_OBJ:
-        case YYJSON_TYPE_ARR:
-            if (unsafe_yyjson_get_len(m_vals) > 0) {
-                yyjson_mut_val *last = (yyjson_mut_val *)m_vals->uni.ptr;
-                yyjson_mut_val *next = last->next, *prev;
-                prev = unsafe_yyjson_mut_val_mut_copy(m_doc, last);
-                if (!prev) return NULL;
-                m_val->uni.ptr = (void *)prev;
-                while (next != last) {
-                    prev->next = unsafe_yyjson_mut_val_mut_copy(m_doc, next);
-                    if (!prev->next) return NULL;
-                    prev = prev->next;
-                    next = next->next;
-                }
-                prev->next = (yyjson_mut_val *)m_val->uni.ptr;
-            }
-            break;
-        
-        case YYJSON_TYPE_RAW:
-        case YYJSON_TYPE_STR: {
-            const char *str = m_vals->uni.str;
-            usize str_len = unsafe_yyjson_get_len(m_vals);
-            m_val->uni.str = unsafe_yyjson_mut_strncpy(m_doc, str, str_len);
-            if (!m_val->uni.str) return NULL;
-            break;
-        }
-        
-        default:
-            m_val->uni = m_vals->uni;
-            break;
-    }
-    
-    return m_val;
-}
-
-yyjson_api yyjson_mut_val *yyjson_mut_val_mut_copy(yyjson_mut_doc *doc,
-                                                   yyjson_mut_val *val) {
-    if (doc && val) return unsafe_yyjson_mut_val_mut_copy(doc, val);
-    return NULL;
-}
-
-static_inline bool unsafe_yyjson_num_equals(void *lhs, void *rhs) {
-    yyjson_val_uni *luni = &((yyjson_val *)lhs)->uni;
-    yyjson_val_uni *runi = &((yyjson_val *)rhs)->uni;
-    yyjson_subtype lt = unsafe_yyjson_get_subtype(lhs);
-    yyjson_subtype rt = unsafe_yyjson_get_subtype(rhs);
-    if (lt == rt)
-        return luni->u64 == runi->u64;
-    if (lt == YYJSON_SUBTYPE_SINT && rt == YYJSON_SUBTYPE_UINT)
-        return luni->i64 >= 0 && luni->u64 == runi->u64;
-    if (lt == YYJSON_SUBTYPE_UINT && rt == YYJSON_SUBTYPE_SINT)
-        return runi->i64 >= 0 && luni->u64 == runi->u64;
-    return false;
-}
-
-static_inline bool unsafe_yyjson_str_equals(void *lhs, void *rhs) {
-    usize len = unsafe_yyjson_get_len(lhs);
-    if (len != unsafe_yyjson_get_len(rhs)) return false;
-    return 0 == len ||
-           0 == memcmp(unsafe_yyjson_get_str(lhs),
-                       unsafe_yyjson_get_str(rhs), len);
-}
-
-yyjson_api bool unsafe_yyjson_equals(yyjson_val *lhs, yyjson_val *rhs) {
-    yyjson_type type = unsafe_yyjson_get_type(lhs);
-    if (type != unsafe_yyjson_get_type(rhs)) return false;
-    
-    switch (type) {
-        case YYJSON_TYPE_OBJ: {
-            usize len = unsafe_yyjson_get_len(lhs);
-            if (len != unsafe_yyjson_get_len(rhs)) return false;
-            if (len > 0) {
-                yyjson_obj_iter iter;
-                yyjson_obj_iter_init(rhs, &iter);
-                lhs = unsafe_yyjson_get_first(lhs);
-                while (len-- > 0) {
-                    rhs = yyjson_obj_iter_getn(&iter, lhs->uni.str,
-                                               unsafe_yyjson_get_len(lhs));
-                    if (!rhs || !unsafe_yyjson_equals(lhs + 1, rhs))
-                        return false;
-                    lhs = unsafe_yyjson_get_next(lhs + 1);
-                }
-            }
-            /* yyjson allows duplicate keys, so the check may be inaccurate */
-            return true;
-        }
-        
-        case YYJSON_TYPE_ARR: {
-            usize len = unsafe_yyjson_get_len(lhs);
-            if (len != unsafe_yyjson_get_len(rhs)) return false;
-            if (len > 0) {
-                lhs = unsafe_yyjson_get_first(lhs);
-                rhs = unsafe_yyjson_get_first(rhs);
-                while (len-- > 0) {
-                    if (!unsafe_yyjson_equals(lhs, rhs))
-                        return false;
-                    lhs = unsafe_yyjson_get_next(lhs);
-                    rhs = unsafe_yyjson_get_next(rhs);
-                }
-            }
-            return true;
-        }
-        
-        case YYJSON_TYPE_NUM:
-            return unsafe_yyjson_num_equals(lhs, rhs);
-        
-        case YYJSON_TYPE_RAW:
-        case YYJSON_TYPE_STR:
-            return unsafe_yyjson_str_equals(lhs, rhs);
-        
-        case YYJSON_TYPE_NULL:
-        case YYJSON_TYPE_BOOL:
-            return lhs->tag == rhs->tag;
-        
-        default:
-            return false;
-    }
-}
-
-bool unsafe_yyjson_mut_equals(yyjson_mut_val *lhs, yyjson_mut_val *rhs) {
-    yyjson_type type = unsafe_yyjson_get_type(lhs);
-    if (type != unsafe_yyjson_get_type(rhs)) return false;
-    
-    switch (type) {
-        case YYJSON_TYPE_OBJ: {
-            usize len = unsafe_yyjson_get_len(lhs);
-            if (len != unsafe_yyjson_get_len(rhs)) return false;
-            if (len > 0) {
-                yyjson_mut_obj_iter iter;
-                yyjson_mut_obj_iter_init(rhs, &iter);
-                lhs = (yyjson_mut_val *)lhs->uni.ptr;
-                while (len-- > 0) {
-                    rhs = yyjson_mut_obj_iter_getn(&iter, lhs->uni.str,
-                                                   unsafe_yyjson_get_len(lhs));
-                    if (!rhs || !unsafe_yyjson_mut_equals(lhs->next, rhs))
-                        return false;
-                    lhs = lhs->next->next;
-                }
-            }
-            /* yyjson allows duplicate keys, so the check may be inaccurate */
-            return true;
-        }
-        
-        case YYJSON_TYPE_ARR: {
-            usize len = unsafe_yyjson_get_len(lhs);
-            if (len != unsafe_yyjson_get_len(rhs)) return false;
-            if (len > 0) {
-                lhs = (yyjson_mut_val *)lhs->uni.ptr;
-                rhs = (yyjson_mut_val *)rhs->uni.ptr;
-                while (len-- > 0) {
-                    if (!unsafe_yyjson_mut_equals(lhs, rhs))
-                        return false;
-                    lhs = lhs->next;
-                    rhs = rhs->next;
-                }
-            }
-            return true;
-        }
-        
-        case YYJSON_TYPE_NUM:
-            return unsafe_yyjson_num_equals(lhs, rhs);
-        
-        case YYJSON_TYPE_RAW:
-        case YYJSON_TYPE_STR:
-            return unsafe_yyjson_str_equals(lhs, rhs);
-        
-        case YYJSON_TYPE_NULL:
-        case YYJSON_TYPE_BOOL:
-            return lhs->tag == rhs->tag;
-        
-        default:
-            return false;
-    }
-}
-
-
-
-/*==============================================================================
- * JSON Pointer
- *============================================================================*/
-
-/**
- Get value from JSON array with a path segment (array index).
- @param ptr Input the segment after `/`, output the end of segment.
- @param end The end of entire JSON pointer.
- @param arr JSON array (yyjson_val/yyjson_mut_val, based on `mut`).
- @param mut Whether `arr` is mutable.
- @return The matched value, or NULL if not matched.
- */
-static_inline void *pointer_read_arr(const char **ptr,
-                                     const char *end,
-                                     void *arr,
-                                     bool mut) {
-    const char *hdr = *ptr;
-    const char *cur = hdr;
-    yyjson_val *i_arr = (yyjson_val *)arr;
-    yyjson_mut_val *m_arr = (yyjson_mut_val *)arr;
-    u64 idx = 0;
-    u8 add;
-    
-    /* start with 0 */
-    if (cur < end && *cur == '0') {
-        *ptr = cur + 1;
-        return mut
-            ? (void *)yyjson_mut_arr_get_first(m_arr)
-            : (void *)yyjson_arr_get_first(i_arr);
-    }
-    
-    /* read whole number */
-    if (cur + U64_SAFE_DIG < end) end = cur + U64_SAFE_DIG;
-    while (cur < end && (add = (u8)((u8)*cur - (u8)'0')) <= 9) {
-        cur++;
-        idx = idx * 10 + add;
-    }
-    if (cur == hdr || idx >= (u64)USIZE_MAX) return NULL;
-    *ptr = cur;
-    return mut
-        ? (void *)yyjson_mut_arr_get(m_arr, (usize)idx)
-        : (void *)yyjson_arr_get(i_arr, (usize)idx);
-}
-
-/**
- Get value from JSON object with a path segment (object key).
- @param ptr Input the segment after `/`, output the end of segment.
- @param end The end of entire JSON pointer.
- @param obj JSON object (yyjson_val/yyjson_mut_val, based on `mut`).
- @param mut `obj` is mutable.
- @return The matched value, or NULL if not matched.
- */
-static_inline void *pointer_read_obj(const char **ptr,
-                                     const char *end,
-                                     void *obj,
-                                     bool mut) {
-#define BUF_SIZE 512
-#define is_escaped(cur) ((cur) < end && (*(cur) == '0' || *(cur) == '1'))
-#define is_unescaped(cur) ((cur) < end && *(cur) != '/' && *(cur) != '~')
-#define is_completed(cur) ((cur) == end || *(cur) == '/')
-    
-    const char *hdr = *ptr;
-    const char *cur = hdr;
-    yyjson_val *i_obj = (yyjson_val *)obj;
-    yyjson_mut_val *m_obj = (yyjson_mut_val *)obj;
-    yyjson_obj_iter i_iter;
-    yyjson_mut_obj_iter m_iter;
-    void *key;
-    
-    /* skip unescaped characters */
-    while (is_unescaped(cur)) cur++;
-    if (likely(is_completed(cur))) {
-        usize len = (usize)(cur - hdr);
-        *ptr = cur;
-        return mut
-            ? (void *)yyjson_mut_obj_getn(m_obj, hdr, len)
-            : (void *)yyjson_obj_getn(i_obj, hdr, len);
-    }
-    
-    /* copy escaped characters to buffer */
-    if (likely(end - hdr <= BUF_SIZE)) {
-        char buf[BUF_SIZE];
-        char *dst = buf + (usize)(cur - hdr);
-        memcpy(buf, hdr, (usize)(cur - hdr));
-        while (true) {
-            if (is_unescaped(cur)) {
-                *dst++ = *cur++;
-            } else if (is_completed(cur)) {
-                usize len = (usize)(dst - buf);
-                *ptr = cur;
-                return mut
-                    ? (void *)yyjson_mut_obj_getn(m_obj, buf, len)
-                    : (void *)yyjson_obj_getn(i_obj, buf, len);
-            } else {
-                cur++; /* skip '~' */
-                if (unlikely(!is_escaped(cur))) return NULL;
-                *dst++ = (char)(*cur++ == '0' ? '~' : '/');
-            }
-        }
-    }
-    
-    /* compare byte by byte */
-    cur = hdr;
-    if (!mut) yyjson_obj_iter_init(i_obj, &i_iter);
-    else yyjson_mut_obj_iter_init(m_obj, &m_iter);
-    while ((key = mut ? (void *)yyjson_mut_obj_iter_next(&m_iter)
-                      : (void *)yyjson_obj_iter_next(&i_iter))) {
-        const char *k_str = unsafe_yyjson_get_str(key);
-        const char *k_end = k_str + unsafe_yyjson_get_len(key);
-        while (k_str < k_end) {
-            if (is_unescaped(cur) && *k_str == *cur) {
-                k_str += 1;
-                cur += 1;
-            } else if (cur < end && *cur == '~' && is_escaped(cur + 1) &&
-                       *k_str == (*(cur + 1) == '0' ? '~' : '/')) {
-                k_str += 1;
-                cur += 2;
-            } else {
-                break;
-            }
-        }
-        if (k_str == k_end && is_completed(cur)) {
-            *ptr = cur;
-            return mut
-                ? (void *)yyjson_mut_obj_iter_get_val((yyjson_mut_val *)key)
-                : (void *)yyjson_obj_iter_get_val((yyjson_val *)key);
-        }
-    }
-    return NULL;
-    
-#undef BUF_SIZE
-#undef is_escaped
-#undef is_unescaped
-#undef is_completed
-}
-
-yyjson_api yyjson_val *unsafe_yyjson_get_pointer(yyjson_val *val,
-                                                 const char *ptr,
-                                                 usize len) {
-    const char *end = ptr + len;
-    ptr++; /* skip '/' */
-    while (true) {
-        if (yyjson_is_obj(val)) {
-            val = (yyjson_val *)pointer_read_obj(&ptr, end, val, false);
-        } else if (yyjson_is_arr(val)) {
-            val = (yyjson_val *)pointer_read_arr(&ptr, end, val, false);
-        } else {
-            val = NULL;
-        }
-        if (!val || ptr == end) return val;
-        if (*ptr++ != '/') return NULL;
-    }
-}
-
-yyjson_api yyjson_mut_val *unsafe_yyjson_mut_get_pointer(yyjson_mut_val *val,
-                                                         const char *ptr,
-                                                         usize len) {
-    const char *end = ptr + len;
-    ptr++; /* skip '/' */
-    while (true) {
-        if (yyjson_mut_is_obj(val)) {
-            val = (yyjson_mut_val *)pointer_read_obj(&ptr, end, val, true);
-        } else if (yyjson_mut_is_arr(val)) {
-            val = (yyjson_mut_val *)pointer_read_arr(&ptr, end, val, true);
-        } else {
-            val = NULL;
-        }
-        if (!val || ptr == end) return val;
-        if (*ptr++ != '/') return NULL;
-    }
-}
-
-
-
-/*==============================================================================
- * JSON Merge-Patch
- *============================================================================*/
-
-yyjson_api yyjson_mut_val *yyjson_merge_patch(yyjson_mut_doc *doc,
-                                              yyjson_val *orig,
-                                              yyjson_val *patch) {
-    usize idx, max;
-    yyjson_val *key, *orig_val, *patch_val, local_orig;
-    yyjson_mut_val *builder, *mut_key, *mut_val, *merged_val;
-    
-    if (unlikely(!yyjson_is_obj(patch))) {
-        return yyjson_val_mut_copy(doc, patch);
-    }
-    
-    builder = yyjson_mut_obj(doc);
-    if (unlikely(!builder)) return NULL;
-    
-    if (!yyjson_is_obj(orig)) {
-        orig = &local_orig;
-        orig->tag = builder->tag;
-        orig->uni = builder->uni;
-    }
-    
-    /* Merge items modified by the patch. */
-    yyjson_obj_foreach(patch, idx, max, key, patch_val) {
-        /* null indicates the field is removed. */
-        if (unsafe_yyjson_is_null(patch_val)) {
-            continue;
-        }
-        mut_key = yyjson_val_mut_copy(doc, key);
-        orig_val = yyjson_obj_getn(orig,
-                                   unsafe_yyjson_get_str(key),
-                                   unsafe_yyjson_get_len(key));
-        merged_val = yyjson_merge_patch(doc, orig_val, patch_val);
-        if (!yyjson_mut_obj_add(builder, mut_key, merged_val)) return NULL;
-    }
-    
-    /* Exit early, if orig is not contributing to the final result. */
-    if (orig == &local_orig) {
-        return builder;
-    }
-    
-    /* Copy over any items that weren't modified by the patch. */
-    yyjson_obj_foreach(orig, idx, max, key, orig_val) {
-        patch_val = yyjson_obj_getn(patch,
-                                    unsafe_yyjson_get_str(key),
-                                    unsafe_yyjson_get_len(key));
-        if (!patch_val) {
-            mut_key = yyjson_val_mut_copy(doc, key);
-            mut_val = yyjson_val_mut_copy(doc, orig_val);
-            if (!yyjson_mut_obj_add(builder, mut_key, mut_val)) return NULL;
-        }
-    }
-    
-    return builder;
-}
-
-yyjson_api yyjson_mut_val *yyjson_mut_merge_patch(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *orig,
-                                                  yyjson_mut_val *patch) {
-    usize idx, max;
-    yyjson_mut_val *key, *orig_val, *patch_val, local_orig;
-    yyjson_mut_val *builder, *mut_key, *mut_val, *merged_val;
-    
-    if (unlikely(!yyjson_mut_is_obj(patch))) {
-        return yyjson_mut_val_mut_copy(doc, patch);
-    }
-    
-    builder = yyjson_mut_obj(doc);
-    if (unlikely(!builder)) return NULL;
-    
-    if (!yyjson_mut_is_obj(orig)) {
-        orig = &local_orig;
-        orig->tag = builder->tag;
-        orig->uni = builder->uni;
-    }
-    
-    /* Merge items modified by the patch. */
-    yyjson_mut_obj_foreach(patch, idx, max, key, patch_val) {
-        /* null indicates the field is removed. */
-        if (unsafe_yyjson_is_null(patch_val)) {
-            continue;
-        }
-        mut_key = yyjson_mut_val_mut_copy(doc, key);
-        orig_val = yyjson_mut_obj_getn(orig,
-                                       unsafe_yyjson_get_str(key),
-                                       unsafe_yyjson_get_len(key));
-        merged_val = yyjson_mut_merge_patch(doc, orig_val, patch_val);
-        if (!yyjson_mut_obj_add(builder, mut_key, merged_val)) return NULL;
-    }
-    
-    /* Exit early, if orig is not contributing to the final result. */
-    if (orig == &local_orig) {
-        return builder;
-    }
-    
-    /* Copy over any items that weren't modified by the patch. */
-    yyjson_mut_obj_foreach(orig, idx, max, key, orig_val) {
-        patch_val = yyjson_mut_obj_getn(patch,
-                                        unsafe_yyjson_get_str(key),
-                                        unsafe_yyjson_get_len(key));
-        if (!patch_val) {
-            mut_key = yyjson_mut_val_mut_copy(doc, key);
-            mut_val = yyjson_mut_val_mut_copy(doc, orig_val);
-            if (!yyjson_mut_obj_add(builder, mut_key, mut_val)) return NULL;
-        }
-    }
-    
-    return builder;
-}
-
-
-
-/*==============================================================================
- * Power10 Lookup Table
- * These data are used by the floating-point number reader and writer.
- *============================================================================*/
-
-#if (!YYJSON_DISABLE_READER || !YYJSON_DISABLE_WRITER) && \
-    (!YYJSON_DISABLE_FAST_FP_CONV)
-
-/** Minimum decimal exponent in pow10_sig_table. */
-#define POW10_SIG_TABLE_MIN_EXP -343
-
-/** Maximum decimal exponent in pow10_sig_table. */
-#define POW10_SIG_TABLE_MAX_EXP 324
-
-/** Minimum exact decimal exponent in pow10_sig_table */
-#define POW10_SIG_TABLE_MIN_EXACT_EXP 0
-
-/** Maximum exact decimal exponent in pow10_sig_table */
-#define POW10_SIG_TABLE_MAX_EXACT_EXP 55
-
-/** Normalized significant 128 bits of pow10, no rounded up (size: 10.4KB).
-    This lookup table is used by both the double number reader and writer.
-    (generate with misc/make_tables.c) */
-static const u64 pow10_sig_table[] = {
-    U64(0xBF29DCAB, 0xA82FDEAE), U64(0x7432EE87, 0x3880FC33), /* ~= 10^-343 */
-    U64(0xEEF453D6, 0x923BD65A), U64(0x113FAA29, 0x06A13B3F), /* ~= 10^-342 */
-    U64(0x9558B466, 0x1B6565F8), U64(0x4AC7CA59, 0xA424C507), /* ~= 10^-341 */
-    U64(0xBAAEE17F, 0xA23EBF76), U64(0x5D79BCF0, 0x0D2DF649), /* ~= 10^-340 */
-    U64(0xE95A99DF, 0x8ACE6F53), U64(0xF4D82C2C, 0x107973DC), /* ~= 10^-339 */
-    U64(0x91D8A02B, 0xB6C10594), U64(0x79071B9B, 0x8A4BE869), /* ~= 10^-338 */
-    U64(0xB64EC836, 0xA47146F9), U64(0x9748E282, 0x6CDEE284), /* ~= 10^-337 */
-    U64(0xE3E27A44, 0x4D8D98B7), U64(0xFD1B1B23, 0x08169B25), /* ~= 10^-336 */
-    U64(0x8E6D8C6A, 0xB0787F72), U64(0xFE30F0F5, 0xE50E20F7), /* ~= 10^-335 */
-    U64(0xB208EF85, 0x5C969F4F), U64(0xBDBD2D33, 0x5E51A935), /* ~= 10^-334 */
-    U64(0xDE8B2B66, 0xB3BC4723), U64(0xAD2C7880, 0x35E61382), /* ~= 10^-333 */
-    U64(0x8B16FB20, 0x3055AC76), U64(0x4C3BCB50, 0x21AFCC31), /* ~= 10^-332 */
-    U64(0xADDCB9E8, 0x3C6B1793), U64(0xDF4ABE24, 0x2A1BBF3D), /* ~= 10^-331 */
-    U64(0xD953E862, 0x4B85DD78), U64(0xD71D6DAD, 0x34A2AF0D), /* ~= 10^-330 */
-    U64(0x87D4713D, 0x6F33AA6B), U64(0x8672648C, 0x40E5AD68), /* ~= 10^-329 */
-    U64(0xA9C98D8C, 0xCB009506), U64(0x680EFDAF, 0x511F18C2), /* ~= 10^-328 */
-    U64(0xD43BF0EF, 0xFDC0BA48), U64(0x0212BD1B, 0x2566DEF2), /* ~= 10^-327 */
-    U64(0x84A57695, 0xFE98746D), U64(0x014BB630, 0xF7604B57), /* ~= 10^-326 */
-    U64(0xA5CED43B, 0x7E3E9188), U64(0x419EA3BD, 0x35385E2D), /* ~= 10^-325 */
-    U64(0xCF42894A, 0x5DCE35EA), U64(0x52064CAC, 0x828675B9), /* ~= 10^-324 */
-    U64(0x818995CE, 0x7AA0E1B2), U64(0x7343EFEB, 0xD1940993), /* ~= 10^-323 */
-    U64(0xA1EBFB42, 0x19491A1F), U64(0x1014EBE6, 0xC5F90BF8), /* ~= 10^-322 */
-    U64(0xCA66FA12, 0x9F9B60A6), U64(0xD41A26E0, 0x77774EF6), /* ~= 10^-321 */
-    U64(0xFD00B897, 0x478238D0), U64(0x8920B098, 0x955522B4), /* ~= 10^-320 */
-    U64(0x9E20735E, 0x8CB16382), U64(0x55B46E5F, 0x5D5535B0), /* ~= 10^-319 */
-    U64(0xC5A89036, 0x2FDDBC62), U64(0xEB2189F7, 0x34AA831D), /* ~= 10^-318 */
-    U64(0xF712B443, 0xBBD52B7B), U64(0xA5E9EC75, 0x01D523E4), /* ~= 10^-317 */
-    U64(0x9A6BB0AA, 0x55653B2D), U64(0x47B233C9, 0x2125366E), /* ~= 10^-316 */
-    U64(0xC1069CD4, 0xEABE89F8), U64(0x999EC0BB, 0x696E840A), /* ~= 10^-315 */
-    U64(0xF148440A, 0x256E2C76), U64(0xC00670EA, 0x43CA250D), /* ~= 10^-314 */
-    U64(0x96CD2A86, 0x5764DBCA), U64(0x38040692, 0x6A5E5728), /* ~= 10^-313 */
-    U64(0xBC807527, 0xED3E12BC), U64(0xC6050837, 0x04F5ECF2), /* ~= 10^-312 */
-    U64(0xEBA09271, 0xE88D976B), U64(0xF7864A44, 0xC633682E), /* ~= 10^-311 */
-    U64(0x93445B87, 0x31587EA3), U64(0x7AB3EE6A, 0xFBE0211D), /* ~= 10^-310 */
-    U64(0xB8157268, 0xFDAE9E4C), U64(0x5960EA05, 0xBAD82964), /* ~= 10^-309 */
-    U64(0xE61ACF03, 0x3D1A45DF), U64(0x6FB92487, 0x298E33BD), /* ~= 10^-308 */
-    U64(0x8FD0C162, 0x06306BAB), U64(0xA5D3B6D4, 0x79F8E056), /* ~= 10^-307 */
-    U64(0xB3C4F1BA, 0x87BC8696), U64(0x8F48A489, 0x9877186C), /* ~= 10^-306 */
-    U64(0xE0B62E29, 0x29ABA83C), U64(0x331ACDAB, 0xFE94DE87), /* ~= 10^-305 */
-    U64(0x8C71DCD9, 0xBA0B4925), U64(0x9FF0C08B, 0x7F1D0B14), /* ~= 10^-304 */
-    U64(0xAF8E5410, 0x288E1B6F), U64(0x07ECF0AE, 0x5EE44DD9), /* ~= 10^-303 */
-    U64(0xDB71E914, 0x32B1A24A), U64(0xC9E82CD9, 0xF69D6150), /* ~= 10^-302 */
-    U64(0x892731AC, 0x9FAF056E), U64(0xBE311C08, 0x3A225CD2), /* ~= 10^-301 */
-    U64(0xAB70FE17, 0xC79AC6CA), U64(0x6DBD630A, 0x48AAF406), /* ~= 10^-300 */
-    U64(0xD64D3D9D, 0xB981787D), U64(0x092CBBCC, 0xDAD5B108), /* ~= 10^-299 */
-    U64(0x85F04682, 0x93F0EB4E), U64(0x25BBF560, 0x08C58EA5), /* ~= 10^-298 */
-    U64(0xA76C5823, 0x38ED2621), U64(0xAF2AF2B8, 0x0AF6F24E), /* ~= 10^-297 */
-    U64(0xD1476E2C, 0x07286FAA), U64(0x1AF5AF66, 0x0DB4AEE1), /* ~= 10^-296 */
-    U64(0x82CCA4DB, 0x847945CA), U64(0x50D98D9F, 0xC890ED4D), /* ~= 10^-295 */
-    U64(0xA37FCE12, 0x6597973C), U64(0xE50FF107, 0xBAB528A0), /* ~= 10^-294 */
-    U64(0xCC5FC196, 0xFEFD7D0C), U64(0x1E53ED49, 0xA96272C8), /* ~= 10^-293 */
-    U64(0xFF77B1FC, 0xBEBCDC4F), U64(0x25E8E89C, 0x13BB0F7A), /* ~= 10^-292 */
-    U64(0x9FAACF3D, 0xF73609B1), U64(0x77B19161, 0x8C54E9AC), /* ~= 10^-291 */
-    U64(0xC795830D, 0x75038C1D), U64(0xD59DF5B9, 0xEF6A2417), /* ~= 10^-290 */
-    U64(0xF97AE3D0, 0xD2446F25), U64(0x4B057328, 0x6B44AD1D), /* ~= 10^-289 */
-    U64(0x9BECCE62, 0x836AC577), U64(0x4EE367F9, 0x430AEC32), /* ~= 10^-288 */
-    U64(0xC2E801FB, 0x244576D5), U64(0x229C41F7, 0x93CDA73F), /* ~= 10^-287 */
-    U64(0xF3A20279, 0xED56D48A), U64(0x6B435275, 0x78C1110F), /* ~= 10^-286 */
-    U64(0x9845418C, 0x345644D6), U64(0x830A1389, 0x6B78AAA9), /* ~= 10^-285 */
-    U64(0xBE5691EF, 0x416BD60C), U64(0x23CC986B, 0xC656D553), /* ~= 10^-284 */
-    U64(0xEDEC366B, 0x11C6CB8F), U64(0x2CBFBE86, 0xB7EC8AA8), /* ~= 10^-283 */
-    U64(0x94B3A202, 0xEB1C3F39), U64(0x7BF7D714, 0x32F3D6A9), /* ~= 10^-282 */
-    U64(0xB9E08A83, 0xA5E34F07), U64(0xDAF5CCD9, 0x3FB0CC53), /* ~= 10^-281 */
-    U64(0xE858AD24, 0x8F5C22C9), U64(0xD1B3400F, 0x8F9CFF68), /* ~= 10^-280 */
-    U64(0x91376C36, 0xD99995BE), U64(0x23100809, 0xB9C21FA1), /* ~= 10^-279 */
-    U64(0xB5854744, 0x8FFFFB2D), U64(0xABD40A0C, 0x2832A78A), /* ~= 10^-278 */
-    U64(0xE2E69915, 0xB3FFF9F9), U64(0x16C90C8F, 0x323F516C), /* ~= 10^-277 */
-    U64(0x8DD01FAD, 0x907FFC3B), U64(0xAE3DA7D9, 0x7F6792E3), /* ~= 10^-276 */
-    U64(0xB1442798, 0xF49FFB4A), U64(0x99CD11CF, 0xDF41779C), /* ~= 10^-275 */
-    U64(0xDD95317F, 0x31C7FA1D), U64(0x40405643, 0xD711D583), /* ~= 10^-274 */
-    U64(0x8A7D3EEF, 0x7F1CFC52), U64(0x482835EA, 0x666B2572), /* ~= 10^-273 */
-    U64(0xAD1C8EAB, 0x5EE43B66), U64(0xDA324365, 0x0005EECF), /* ~= 10^-272 */
-    U64(0xD863B256, 0x369D4A40), U64(0x90BED43E, 0x40076A82), /* ~= 10^-271 */
-    U64(0x873E4F75, 0xE2224E68), U64(0x5A7744A6, 0xE804A291), /* ~= 10^-270 */
-    U64(0xA90DE353, 0x5AAAE202), U64(0x711515D0, 0xA205CB36), /* ~= 10^-269 */
-    U64(0xD3515C28, 0x31559A83), U64(0x0D5A5B44, 0xCA873E03), /* ~= 10^-268 */
-    U64(0x8412D999, 0x1ED58091), U64(0xE858790A, 0xFE9486C2), /* ~= 10^-267 */
-    U64(0xA5178FFF, 0x668AE0B6), U64(0x626E974D, 0xBE39A872), /* ~= 10^-266 */
-    U64(0xCE5D73FF, 0x402D98E3), U64(0xFB0A3D21, 0x2DC8128F), /* ~= 10^-265 */
-    U64(0x80FA687F, 0x881C7F8E), U64(0x7CE66634, 0xBC9D0B99), /* ~= 10^-264 */
-    U64(0xA139029F, 0x6A239F72), U64(0x1C1FFFC1, 0xEBC44E80), /* ~= 10^-263 */
-    U64(0xC9874347, 0x44AC874E), U64(0xA327FFB2, 0x66B56220), /* ~= 10^-262 */
-    U64(0xFBE91419, 0x15D7A922), U64(0x4BF1FF9F, 0x0062BAA8), /* ~= 10^-261 */
-    U64(0x9D71AC8F, 0xADA6C9B5), U64(0x6F773FC3, 0x603DB4A9), /* ~= 10^-260 */
-    U64(0xC4CE17B3, 0x99107C22), U64(0xCB550FB4, 0x384D21D3), /* ~= 10^-259 */
-    U64(0xF6019DA0, 0x7F549B2B), U64(0x7E2A53A1, 0x46606A48), /* ~= 10^-258 */
-    U64(0x99C10284, 0x4F94E0FB), U64(0x2EDA7444, 0xCBFC426D), /* ~= 10^-257 */
-    U64(0xC0314325, 0x637A1939), U64(0xFA911155, 0xFEFB5308), /* ~= 10^-256 */
-    U64(0xF03D93EE, 0xBC589F88), U64(0x793555AB, 0x7EBA27CA), /* ~= 10^-255 */
-    U64(0x96267C75, 0x35B763B5), U64(0x4BC1558B, 0x2F3458DE), /* ~= 10^-254 */
-    U64(0xBBB01B92, 0x83253CA2), U64(0x9EB1AAED, 0xFB016F16), /* ~= 10^-253 */
-    U64(0xEA9C2277, 0x23EE8BCB), U64(0x465E15A9, 0x79C1CADC), /* ~= 10^-252 */
-    U64(0x92A1958A, 0x7675175F), U64(0x0BFACD89, 0xEC191EC9), /* ~= 10^-251 */
-    U64(0xB749FAED, 0x14125D36), U64(0xCEF980EC, 0x671F667B), /* ~= 10^-250 */
-    U64(0xE51C79A8, 0x5916F484), U64(0x82B7E127, 0x80E7401A), /* ~= 10^-249 */
-    U64(0x8F31CC09, 0x37AE58D2), U64(0xD1B2ECB8, 0xB0908810), /* ~= 10^-248 */
-    U64(0xB2FE3F0B, 0x8599EF07), U64(0x861FA7E6, 0xDCB4AA15), /* ~= 10^-247 */
-    U64(0xDFBDCECE, 0x67006AC9), U64(0x67A791E0, 0x93E1D49A), /* ~= 10^-246 */
-    U64(0x8BD6A141, 0x006042BD), U64(0xE0C8BB2C, 0x5C6D24E0), /* ~= 10^-245 */
-    U64(0xAECC4991, 0x4078536D), U64(0x58FAE9F7, 0x73886E18), /* ~= 10^-244 */
-    U64(0xDA7F5BF5, 0x90966848), U64(0xAF39A475, 0x506A899E), /* ~= 10^-243 */
-    U64(0x888F9979, 0x7A5E012D), U64(0x6D8406C9, 0x52429603), /* ~= 10^-242 */
-    U64(0xAAB37FD7, 0xD8F58178), U64(0xC8E5087B, 0xA6D33B83), /* ~= 10^-241 */
-    U64(0xD5605FCD, 0xCF32E1D6), U64(0xFB1E4A9A, 0x90880A64), /* ~= 10^-240 */
-    U64(0x855C3BE0, 0xA17FCD26), U64(0x5CF2EEA0, 0x9A55067F), /* ~= 10^-239 */
-    U64(0xA6B34AD8, 0xC9DFC06F), U64(0xF42FAA48, 0xC0EA481E), /* ~= 10^-238 */
-    U64(0xD0601D8E, 0xFC57B08B), U64(0xF13B94DA, 0xF124DA26), /* ~= 10^-237 */
-    U64(0x823C1279, 0x5DB6CE57), U64(0x76C53D08, 0xD6B70858), /* ~= 10^-236 */
-    U64(0xA2CB1717, 0xB52481ED), U64(0x54768C4B, 0x0C64CA6E), /* ~= 10^-235 */
-    U64(0xCB7DDCDD, 0xA26DA268), U64(0xA9942F5D, 0xCF7DFD09), /* ~= 10^-234 */
-    U64(0xFE5D5415, 0x0B090B02), U64(0xD3F93B35, 0x435D7C4C), /* ~= 10^-233 */
-    U64(0x9EFA548D, 0x26E5A6E1), U64(0xC47BC501, 0x4A1A6DAF), /* ~= 10^-232 */
-    U64(0xC6B8E9B0, 0x709F109A), U64(0x359AB641, 0x9CA1091B), /* ~= 10^-231 */
-    U64(0xF867241C, 0x8CC6D4C0), U64(0xC30163D2, 0x03C94B62), /* ~= 10^-230 */
-    U64(0x9B407691, 0xD7FC44F8), U64(0x79E0DE63, 0x425DCF1D), /* ~= 10^-229 */
-    U64(0xC2109436, 0x4DFB5636), U64(0x985915FC, 0x12F542E4), /* ~= 10^-228 */
-    U64(0xF294B943, 0xE17A2BC4), U64(0x3E6F5B7B, 0x17B2939D), /* ~= 10^-227 */
-    U64(0x979CF3CA, 0x6CEC5B5A), U64(0xA705992C, 0xEECF9C42), /* ~= 10^-226 */
-    U64(0xBD8430BD, 0x08277231), U64(0x50C6FF78, 0x2A838353), /* ~= 10^-225 */
-    U64(0xECE53CEC, 0x4A314EBD), U64(0xA4F8BF56, 0x35246428), /* ~= 10^-224 */
-    U64(0x940F4613, 0xAE5ED136), U64(0x871B7795, 0xE136BE99), /* ~= 10^-223 */
-    U64(0xB9131798, 0x99F68584), U64(0x28E2557B, 0x59846E3F), /* ~= 10^-222 */
-    U64(0xE757DD7E, 0xC07426E5), U64(0x331AEADA, 0x2FE589CF), /* ~= 10^-221 */
-    U64(0x9096EA6F, 0x3848984F), U64(0x3FF0D2C8, 0x5DEF7621), /* ~= 10^-220 */
-    U64(0xB4BCA50B, 0x065ABE63), U64(0x0FED077A, 0x756B53A9), /* ~= 10^-219 */
-    U64(0xE1EBCE4D, 0xC7F16DFB), U64(0xD3E84959, 0x12C62894), /* ~= 10^-218 */
-    U64(0x8D3360F0, 0x9CF6E4BD), U64(0x64712DD7, 0xABBBD95C), /* ~= 10^-217 */
-    U64(0xB080392C, 0xC4349DEC), U64(0xBD8D794D, 0x96AACFB3), /* ~= 10^-216 */
-    U64(0xDCA04777, 0xF541C567), U64(0xECF0D7A0, 0xFC5583A0), /* ~= 10^-215 */
-    U64(0x89E42CAA, 0xF9491B60), U64(0xF41686C4, 0x9DB57244), /* ~= 10^-214 */
-    U64(0xAC5D37D5, 0xB79B6239), U64(0x311C2875, 0xC522CED5), /* ~= 10^-213 */
-    U64(0xD77485CB, 0x25823AC7), U64(0x7D633293, 0x366B828B), /* ~= 10^-212 */
-    U64(0x86A8D39E, 0xF77164BC), U64(0xAE5DFF9C, 0x02033197), /* ~= 10^-211 */
-    U64(0xA8530886, 0xB54DBDEB), U64(0xD9F57F83, 0x0283FDFC), /* ~= 10^-210 */
-    U64(0xD267CAA8, 0x62A12D66), U64(0xD072DF63, 0xC324FD7B), /* ~= 10^-209 */
-    U64(0x8380DEA9, 0x3DA4BC60), U64(0x4247CB9E, 0x59F71E6D), /* ~= 10^-208 */
-    U64(0xA4611653, 0x8D0DEB78), U64(0x52D9BE85, 0xF074E608), /* ~= 10^-207 */
-    U64(0xCD795BE8, 0x70516656), U64(0x67902E27, 0x6C921F8B), /* ~= 10^-206 */
-    U64(0x806BD971, 0x4632DFF6), U64(0x00BA1CD8, 0xA3DB53B6), /* ~= 10^-205 */
-    U64(0xA086CFCD, 0x97BF97F3), U64(0x80E8A40E, 0xCCD228A4), /* ~= 10^-204 */
-    U64(0xC8A883C0, 0xFDAF7DF0), U64(0x6122CD12, 0x8006B2CD), /* ~= 10^-203 */
-    U64(0xFAD2A4B1, 0x3D1B5D6C), U64(0x796B8057, 0x20085F81), /* ~= 10^-202 */
-    U64(0x9CC3A6EE, 0xC6311A63), U64(0xCBE33036, 0x74053BB0), /* ~= 10^-201 */
-    U64(0xC3F490AA, 0x77BD60FC), U64(0xBEDBFC44, 0x11068A9C), /* ~= 10^-200 */
-    U64(0xF4F1B4D5, 0x15ACB93B), U64(0xEE92FB55, 0x15482D44), /* ~= 10^-199 */
-    U64(0x99171105, 0x2D8BF3C5), U64(0x751BDD15, 0x2D4D1C4A), /* ~= 10^-198 */
-    U64(0xBF5CD546, 0x78EEF0B6), U64(0xD262D45A, 0x78A0635D), /* ~= 10^-197 */
-    U64(0xEF340A98, 0x172AACE4), U64(0x86FB8971, 0x16C87C34), /* ~= 10^-196 */
-    U64(0x9580869F, 0x0E7AAC0E), U64(0xD45D35E6, 0xAE3D4DA0), /* ~= 10^-195 */
-    U64(0xBAE0A846, 0xD2195712), U64(0x89748360, 0x59CCA109), /* ~= 10^-194 */
-    U64(0xE998D258, 0x869FACD7), U64(0x2BD1A438, 0x703FC94B), /* ~= 10^-193 */
-    U64(0x91FF8377, 0x5423CC06), U64(0x7B6306A3, 0x4627DDCF), /* ~= 10^-192 */
-    U64(0xB67F6455, 0x292CBF08), U64(0x1A3BC84C, 0x17B1D542), /* ~= 10^-191 */
-    U64(0xE41F3D6A, 0x7377EECA), U64(0x20CABA5F, 0x1D9E4A93), /* ~= 10^-190 */
-    U64(0x8E938662, 0x882AF53E), U64(0x547EB47B, 0x7282EE9C), /* ~= 10^-189 */
-    U64(0xB23867FB, 0x2A35B28D), U64(0xE99E619A, 0x4F23AA43), /* ~= 10^-188 */
-    U64(0xDEC681F9, 0xF4C31F31), U64(0x6405FA00, 0xE2EC94D4), /* ~= 10^-187 */
-    U64(0x8B3C113C, 0x38F9F37E), U64(0xDE83BC40, 0x8DD3DD04), /* ~= 10^-186 */
-    U64(0xAE0B158B, 0x4738705E), U64(0x9624AB50, 0xB148D445), /* ~= 10^-185 */
-    U64(0xD98DDAEE, 0x19068C76), U64(0x3BADD624, 0xDD9B0957), /* ~= 10^-184 */
-    U64(0x87F8A8D4, 0xCFA417C9), U64(0xE54CA5D7, 0x0A80E5D6), /* ~= 10^-183 */
-    U64(0xA9F6D30A, 0x038D1DBC), U64(0x5E9FCF4C, 0xCD211F4C), /* ~= 10^-182 */
-    U64(0xD47487CC, 0x8470652B), U64(0x7647C320, 0x0069671F), /* ~= 10^-181 */
-    U64(0x84C8D4DF, 0xD2C63F3B), U64(0x29ECD9F4, 0x0041E073), /* ~= 10^-180 */
-    U64(0xA5FB0A17, 0xC777CF09), U64(0xF4681071, 0x00525890), /* ~= 10^-179 */
-    U64(0xCF79CC9D, 0xB955C2CC), U64(0x7182148D, 0x4066EEB4), /* ~= 10^-178 */
-    U64(0x81AC1FE2, 0x93D599BF), U64(0xC6F14CD8, 0x48405530), /* ~= 10^-177 */
-    U64(0xA21727DB, 0x38CB002F), U64(0xB8ADA00E, 0x5A506A7C), /* ~= 10^-176 */
-    U64(0xCA9CF1D2, 0x06FDC03B), U64(0xA6D90811, 0xF0E4851C), /* ~= 10^-175 */
-    U64(0xFD442E46, 0x88BD304A), U64(0x908F4A16, 0x6D1DA663), /* ~= 10^-174 */
-    U64(0x9E4A9CEC, 0x15763E2E), U64(0x9A598E4E, 0x043287FE), /* ~= 10^-173 */
-    U64(0xC5DD4427, 0x1AD3CDBA), U64(0x40EFF1E1, 0x853F29FD), /* ~= 10^-172 */
-    U64(0xF7549530, 0xE188C128), U64(0xD12BEE59, 0xE68EF47C), /* ~= 10^-171 */
-    U64(0x9A94DD3E, 0x8CF578B9), U64(0x82BB74F8, 0x301958CE), /* ~= 10^-170 */
-    U64(0xC13A148E, 0x3032D6E7), U64(0xE36A5236, 0x3C1FAF01), /* ~= 10^-169 */
-    U64(0xF18899B1, 0xBC3F8CA1), U64(0xDC44E6C3, 0xCB279AC1), /* ~= 10^-168 */
-    U64(0x96F5600F, 0x15A7B7E5), U64(0x29AB103A, 0x5EF8C0B9), /* ~= 10^-167 */
-    U64(0xBCB2B812, 0xDB11A5DE), U64(0x7415D448, 0xF6B6F0E7), /* ~= 10^-166 */
-    U64(0xEBDF6617, 0x91D60F56), U64(0x111B495B, 0x3464AD21), /* ~= 10^-165 */
-    U64(0x936B9FCE, 0xBB25C995), U64(0xCAB10DD9, 0x00BEEC34), /* ~= 10^-164 */
-    U64(0xB84687C2, 0x69EF3BFB), U64(0x3D5D514F, 0x40EEA742), /* ~= 10^-163 */
-    U64(0xE65829B3, 0x046B0AFA), U64(0x0CB4A5A3, 0x112A5112), /* ~= 10^-162 */
-    U64(0x8FF71A0F, 0xE2C2E6DC), U64(0x47F0E785, 0xEABA72AB), /* ~= 10^-161 */
-    U64(0xB3F4E093, 0xDB73A093), U64(0x59ED2167, 0x65690F56), /* ~= 10^-160 */
-    U64(0xE0F218B8, 0xD25088B8), U64(0x306869C1, 0x3EC3532C), /* ~= 10^-159 */
-    U64(0x8C974F73, 0x83725573), U64(0x1E414218, 0xC73A13FB), /* ~= 10^-158 */
-    U64(0xAFBD2350, 0x644EEACF), U64(0xE5D1929E, 0xF90898FA), /* ~= 10^-157 */
-    U64(0xDBAC6C24, 0x7D62A583), U64(0xDF45F746, 0xB74ABF39), /* ~= 10^-156 */
-    U64(0x894BC396, 0xCE5DA772), U64(0x6B8BBA8C, 0x328EB783), /* ~= 10^-155 */
-    U64(0xAB9EB47C, 0x81F5114F), U64(0x066EA92F, 0x3F326564), /* ~= 10^-154 */
-    U64(0xD686619B, 0xA27255A2), U64(0xC80A537B, 0x0EFEFEBD), /* ~= 10^-153 */
-    U64(0x8613FD01, 0x45877585), U64(0xBD06742C, 0xE95F5F36), /* ~= 10^-152 */
-    U64(0xA798FC41, 0x96E952E7), U64(0x2C481138, 0x23B73704), /* ~= 10^-151 */
-    U64(0xD17F3B51, 0xFCA3A7A0), U64(0xF75A1586, 0x2CA504C5), /* ~= 10^-150 */
-    U64(0x82EF8513, 0x3DE648C4), U64(0x9A984D73, 0xDBE722FB), /* ~= 10^-149 */
-    U64(0xA3AB6658, 0x0D5FDAF5), U64(0xC13E60D0, 0xD2E0EBBA), /* ~= 10^-148 */
-    U64(0xCC963FEE, 0x10B7D1B3), U64(0x318DF905, 0x079926A8), /* ~= 10^-147 */
-    U64(0xFFBBCFE9, 0x94E5C61F), U64(0xFDF17746, 0x497F7052), /* ~= 10^-146 */
-    U64(0x9FD561F1, 0xFD0F9BD3), U64(0xFEB6EA8B, 0xEDEFA633), /* ~= 10^-145 */
-    U64(0xC7CABA6E, 0x7C5382C8), U64(0xFE64A52E, 0xE96B8FC0), /* ~= 10^-144 */
-    U64(0xF9BD690A, 0x1B68637B), U64(0x3DFDCE7A, 0xA3C673B0), /* ~= 10^-143 */
-    U64(0x9C1661A6, 0x51213E2D), U64(0x06BEA10C, 0xA65C084E), /* ~= 10^-142 */
-    U64(0xC31BFA0F, 0xE5698DB8), U64(0x486E494F, 0xCFF30A62), /* ~= 10^-141 */
-    U64(0xF3E2F893, 0xDEC3F126), U64(0x5A89DBA3, 0xC3EFCCFA), /* ~= 10^-140 */
-    U64(0x986DDB5C, 0x6B3A76B7), U64(0xF8962946, 0x5A75E01C), /* ~= 10^-139 */
-    U64(0xBE895233, 0x86091465), U64(0xF6BBB397, 0xF1135823), /* ~= 10^-138 */
-    U64(0xEE2BA6C0, 0x678B597F), U64(0x746AA07D, 0xED582E2C), /* ~= 10^-137 */
-    U64(0x94DB4838, 0x40B717EF), U64(0xA8C2A44E, 0xB4571CDC), /* ~= 10^-136 */
-    U64(0xBA121A46, 0x50E4DDEB), U64(0x92F34D62, 0x616CE413), /* ~= 10^-135 */
-    U64(0xE896A0D7, 0xE51E1566), U64(0x77B020BA, 0xF9C81D17), /* ~= 10^-134 */
-    U64(0x915E2486, 0xEF32CD60), U64(0x0ACE1474, 0xDC1D122E), /* ~= 10^-133 */
-    U64(0xB5B5ADA8, 0xAAFF80B8), U64(0x0D819992, 0x132456BA), /* ~= 10^-132 */
-    U64(0xE3231912, 0xD5BF60E6), U64(0x10E1FFF6, 0x97ED6C69), /* ~= 10^-131 */
-    U64(0x8DF5EFAB, 0xC5979C8F), U64(0xCA8D3FFA, 0x1EF463C1), /* ~= 10^-130 */
-    U64(0xB1736B96, 0xB6FD83B3), U64(0xBD308FF8, 0xA6B17CB2), /* ~= 10^-129 */
-    U64(0xDDD0467C, 0x64BCE4A0), U64(0xAC7CB3F6, 0xD05DDBDE), /* ~= 10^-128 */
-    U64(0x8AA22C0D, 0xBEF60EE4), U64(0x6BCDF07A, 0x423AA96B), /* ~= 10^-127 */
-    U64(0xAD4AB711, 0x2EB3929D), U64(0x86C16C98, 0xD2C953C6), /* ~= 10^-126 */
-    U64(0xD89D64D5, 0x7A607744), U64(0xE871C7BF, 0x077BA8B7), /* ~= 10^-125 */
-    U64(0x87625F05, 0x6C7C4A8B), U64(0x11471CD7, 0x64AD4972), /* ~= 10^-124 */
-    U64(0xA93AF6C6, 0xC79B5D2D), U64(0xD598E40D, 0x3DD89BCF), /* ~= 10^-123 */
-    U64(0xD389B478, 0x79823479), U64(0x4AFF1D10, 0x8D4EC2C3), /* ~= 10^-122 */
-    U64(0x843610CB, 0x4BF160CB), U64(0xCEDF722A, 0x585139BA), /* ~= 10^-121 */
-    U64(0xA54394FE, 0x1EEDB8FE), U64(0xC2974EB4, 0xEE658828), /* ~= 10^-120 */
-    U64(0xCE947A3D, 0xA6A9273E), U64(0x733D2262, 0x29FEEA32), /* ~= 10^-119 */
-    U64(0x811CCC66, 0x8829B887), U64(0x0806357D, 0x5A3F525F), /* ~= 10^-118 */
-    U64(0xA163FF80, 0x2A3426A8), U64(0xCA07C2DC, 0xB0CF26F7), /* ~= 10^-117 */
-    U64(0xC9BCFF60, 0x34C13052), U64(0xFC89B393, 0xDD02F0B5), /* ~= 10^-116 */
-    U64(0xFC2C3F38, 0x41F17C67), U64(0xBBAC2078, 0xD443ACE2), /* ~= 10^-115 */
-    U64(0x9D9BA783, 0x2936EDC0), U64(0xD54B944B, 0x84AA4C0D), /* ~= 10^-114 */
-    U64(0xC5029163, 0xF384A931), U64(0x0A9E795E, 0x65D4DF11), /* ~= 10^-113 */
-    U64(0xF64335BC, 0xF065D37D), U64(0x4D4617B5, 0xFF4A16D5), /* ~= 10^-112 */
-    U64(0x99EA0196, 0x163FA42E), U64(0x504BCED1, 0xBF8E4E45), /* ~= 10^-111 */
-    U64(0xC06481FB, 0x9BCF8D39), U64(0xE45EC286, 0x2F71E1D6), /* ~= 10^-110 */
-    U64(0xF07DA27A, 0x82C37088), U64(0x5D767327, 0xBB4E5A4C), /* ~= 10^-109 */
-    U64(0x964E858C, 0x91BA2655), U64(0x3A6A07F8, 0xD510F86F), /* ~= 10^-108 */
-    U64(0xBBE226EF, 0xB628AFEA), U64(0x890489F7, 0x0A55368B), /* ~= 10^-107 */
-    U64(0xEADAB0AB, 0xA3B2DBE5), U64(0x2B45AC74, 0xCCEA842E), /* ~= 10^-106 */
-    U64(0x92C8AE6B, 0x464FC96F), U64(0x3B0B8BC9, 0x0012929D), /* ~= 10^-105 */
-    U64(0xB77ADA06, 0x17E3BBCB), U64(0x09CE6EBB, 0x40173744), /* ~= 10^-104 */
-    U64(0xE5599087, 0x9DDCAABD), U64(0xCC420A6A, 0x101D0515), /* ~= 10^-103 */
-    U64(0x8F57FA54, 0xC2A9EAB6), U64(0x9FA94682, 0x4A12232D), /* ~= 10^-102 */
-    U64(0xB32DF8E9, 0xF3546564), U64(0x47939822, 0xDC96ABF9), /* ~= 10^-101 */
-    U64(0xDFF97724, 0x70297EBD), U64(0x59787E2B, 0x93BC56F7), /* ~= 10^-100 */
-    U64(0x8BFBEA76, 0xC619EF36), U64(0x57EB4EDB, 0x3C55B65A), /* ~= 10^-99 */
-    U64(0xAEFAE514, 0x77A06B03), U64(0xEDE62292, 0x0B6B23F1), /* ~= 10^-98 */
-    U64(0xDAB99E59, 0x958885C4), U64(0xE95FAB36, 0x8E45ECED), /* ~= 10^-97 */
-    U64(0x88B402F7, 0xFD75539B), U64(0x11DBCB02, 0x18EBB414), /* ~= 10^-96 */
-    U64(0xAAE103B5, 0xFCD2A881), U64(0xD652BDC2, 0x9F26A119), /* ~= 10^-95 */
-    U64(0xD59944A3, 0x7C0752A2), U64(0x4BE76D33, 0x46F0495F), /* ~= 10^-94 */
-    U64(0x857FCAE6, 0x2D8493A5), U64(0x6F70A440, 0x0C562DDB), /* ~= 10^-93 */
-    U64(0xA6DFBD9F, 0xB8E5B88E), U64(0xCB4CCD50, 0x0F6BB952), /* ~= 10^-92 */
-    U64(0xD097AD07, 0xA71F26B2), U64(0x7E2000A4, 0x1346A7A7), /* ~= 10^-91 */
-    U64(0x825ECC24, 0xC873782F), U64(0x8ED40066, 0x8C0C28C8), /* ~= 10^-90 */
-    U64(0xA2F67F2D, 0xFA90563B), U64(0x72890080, 0x2F0F32FA), /* ~= 10^-89 */
-    U64(0xCBB41EF9, 0x79346BCA), U64(0x4F2B40A0, 0x3AD2FFB9), /* ~= 10^-88 */
-    U64(0xFEA126B7, 0xD78186BC), U64(0xE2F610C8, 0x4987BFA8), /* ~= 10^-87 */
-    U64(0x9F24B832, 0xE6B0F436), U64(0x0DD9CA7D, 0x2DF4D7C9), /* ~= 10^-86 */
-    U64(0xC6EDE63F, 0xA05D3143), U64(0x91503D1C, 0x79720DBB), /* ~= 10^-85 */
-    U64(0xF8A95FCF, 0x88747D94), U64(0x75A44C63, 0x97CE912A), /* ~= 10^-84 */
-    U64(0x9B69DBE1, 0xB548CE7C), U64(0xC986AFBE, 0x3EE11ABA), /* ~= 10^-83 */
-    U64(0xC24452DA, 0x229B021B), U64(0xFBE85BAD, 0xCE996168), /* ~= 10^-82 */
-    U64(0xF2D56790, 0xAB41C2A2), U64(0xFAE27299, 0x423FB9C3), /* ~= 10^-81 */
-    U64(0x97C560BA, 0x6B0919A5), U64(0xDCCD879F, 0xC967D41A), /* ~= 10^-80 */
-    U64(0xBDB6B8E9, 0x05CB600F), U64(0x5400E987, 0xBBC1C920), /* ~= 10^-79 */
-    U64(0xED246723, 0x473E3813), U64(0x290123E9, 0xAAB23B68), /* ~= 10^-78 */
-    U64(0x9436C076, 0x0C86E30B), U64(0xF9A0B672, 0x0AAF6521), /* ~= 10^-77 */
-    U64(0xB9447093, 0x8FA89BCE), U64(0xF808E40E, 0x8D5B3E69), /* ~= 10^-76 */
-    U64(0xE7958CB8, 0x7392C2C2), U64(0xB60B1D12, 0x30B20E04), /* ~= 10^-75 */
-    U64(0x90BD77F3, 0x483BB9B9), U64(0xB1C6F22B, 0x5E6F48C2), /* ~= 10^-74 */
-    U64(0xB4ECD5F0, 0x1A4AA828), U64(0x1E38AEB6, 0x360B1AF3), /* ~= 10^-73 */
-    U64(0xE2280B6C, 0x20DD5232), U64(0x25C6DA63, 0xC38DE1B0), /* ~= 10^-72 */
-    U64(0x8D590723, 0x948A535F), U64(0x579C487E, 0x5A38AD0E), /* ~= 10^-71 */
-    U64(0xB0AF48EC, 0x79ACE837), U64(0x2D835A9D, 0xF0C6D851), /* ~= 10^-70 */
-    U64(0xDCDB1B27, 0x98182244), U64(0xF8E43145, 0x6CF88E65), /* ~= 10^-69 */
-    U64(0x8A08F0F8, 0xBF0F156B), U64(0x1B8E9ECB, 0x641B58FF), /* ~= 10^-68 */
-    U64(0xAC8B2D36, 0xEED2DAC5), U64(0xE272467E, 0x3D222F3F), /* ~= 10^-67 */
-    U64(0xD7ADF884, 0xAA879177), U64(0x5B0ED81D, 0xCC6ABB0F), /* ~= 10^-66 */
-    U64(0x86CCBB52, 0xEA94BAEA), U64(0x98E94712, 0x9FC2B4E9), /* ~= 10^-65 */
-    U64(0xA87FEA27, 0xA539E9A5), U64(0x3F2398D7, 0x47B36224), /* ~= 10^-64 */
-    U64(0xD29FE4B1, 0x8E88640E), U64(0x8EEC7F0D, 0x19A03AAD), /* ~= 10^-63 */
-    U64(0x83A3EEEE, 0xF9153E89), U64(0x1953CF68, 0x300424AC), /* ~= 10^-62 */
-    U64(0xA48CEAAA, 0xB75A8E2B), U64(0x5FA8C342, 0x3C052DD7), /* ~= 10^-61 */
-    U64(0xCDB02555, 0x653131B6), U64(0x3792F412, 0xCB06794D), /* ~= 10^-60 */
-    U64(0x808E1755, 0x5F3EBF11), U64(0xE2BBD88B, 0xBEE40BD0), /* ~= 10^-59 */
-    U64(0xA0B19D2A, 0xB70E6ED6), U64(0x5B6ACEAE, 0xAE9D0EC4), /* ~= 10^-58 */
-    U64(0xC8DE0475, 0x64D20A8B), U64(0xF245825A, 0x5A445275), /* ~= 10^-57 */
-    U64(0xFB158592, 0xBE068D2E), U64(0xEED6E2F0, 0xF0D56712), /* ~= 10^-56 */
-    U64(0x9CED737B, 0xB6C4183D), U64(0x55464DD6, 0x9685606B), /* ~= 10^-55 */
-    U64(0xC428D05A, 0xA4751E4C), U64(0xAA97E14C, 0x3C26B886), /* ~= 10^-54 */
-    U64(0xF5330471, 0x4D9265DF), U64(0xD53DD99F, 0x4B3066A8), /* ~= 10^-53 */
-    U64(0x993FE2C6, 0xD07B7FAB), U64(0xE546A803, 0x8EFE4029), /* ~= 10^-52 */
-    U64(0xBF8FDB78, 0x849A5F96), U64(0xDE985204, 0x72BDD033), /* ~= 10^-51 */
-    U64(0xEF73D256, 0xA5C0F77C), U64(0x963E6685, 0x8F6D4440), /* ~= 10^-50 */
-    U64(0x95A86376, 0x27989AAD), U64(0xDDE70013, 0x79A44AA8), /* ~= 10^-49 */
-    U64(0xBB127C53, 0xB17EC159), U64(0x5560C018, 0x580D5D52), /* ~= 10^-48 */
-    U64(0xE9D71B68, 0x9DDE71AF), U64(0xAAB8F01E, 0x6E10B4A6), /* ~= 10^-47 */
-    U64(0x92267121, 0x62AB070D), U64(0xCAB39613, 0x04CA70E8), /* ~= 10^-46 */
-    U64(0xB6B00D69, 0xBB55C8D1), U64(0x3D607B97, 0xC5FD0D22), /* ~= 10^-45 */
-    U64(0xE45C10C4, 0x2A2B3B05), U64(0x8CB89A7D, 0xB77C506A), /* ~= 10^-44 */
-    U64(0x8EB98A7A, 0x9A5B04E3), U64(0x77F3608E, 0x92ADB242), /* ~= 10^-43 */
-    U64(0xB267ED19, 0x40F1C61C), U64(0x55F038B2, 0x37591ED3), /* ~= 10^-42 */
-    U64(0xDF01E85F, 0x912E37A3), U64(0x6B6C46DE, 0xC52F6688), /* ~= 10^-41 */
-    U64(0x8B61313B, 0xBABCE2C6), U64(0x2323AC4B, 0x3B3DA015), /* ~= 10^-40 */
-    U64(0xAE397D8A, 0xA96C1B77), U64(0xABEC975E, 0x0A0D081A), /* ~= 10^-39 */
-    U64(0xD9C7DCED, 0x53C72255), U64(0x96E7BD35, 0x8C904A21), /* ~= 10^-38 */
-    U64(0x881CEA14, 0x545C7575), U64(0x7E50D641, 0x77DA2E54), /* ~= 10^-37 */
-    U64(0xAA242499, 0x697392D2), U64(0xDDE50BD1, 0xD5D0B9E9), /* ~= 10^-36 */
-    U64(0xD4AD2DBF, 0xC3D07787), U64(0x955E4EC6, 0x4B44E864), /* ~= 10^-35 */
-    U64(0x84EC3C97, 0xDA624AB4), U64(0xBD5AF13B, 0xEF0B113E), /* ~= 10^-34 */
-    U64(0xA6274BBD, 0xD0FADD61), U64(0xECB1AD8A, 0xEACDD58E), /* ~= 10^-33 */
-    U64(0xCFB11EAD, 0x453994BA), U64(0x67DE18ED, 0xA5814AF2), /* ~= 10^-32 */
-    U64(0x81CEB32C, 0x4B43FCF4), U64(0x80EACF94, 0x8770CED7), /* ~= 10^-31 */
-    U64(0xA2425FF7, 0x5E14FC31), U64(0xA1258379, 0xA94D028D), /* ~= 10^-30 */
-    U64(0xCAD2F7F5, 0x359A3B3E), U64(0x096EE458, 0x13A04330), /* ~= 10^-29 */
-    U64(0xFD87B5F2, 0x8300CA0D), U64(0x8BCA9D6E, 0x188853FC), /* ~= 10^-28 */
-    U64(0x9E74D1B7, 0x91E07E48), U64(0x775EA264, 0xCF55347D), /* ~= 10^-27 */
-    U64(0xC6120625, 0x76589DDA), U64(0x95364AFE, 0x032A819D), /* ~= 10^-26 */
-    U64(0xF79687AE, 0xD3EEC551), U64(0x3A83DDBD, 0x83F52204), /* ~= 10^-25 */
-    U64(0x9ABE14CD, 0x44753B52), U64(0xC4926A96, 0x72793542), /* ~= 10^-24 */
-    U64(0xC16D9A00, 0x95928A27), U64(0x75B7053C, 0x0F178293), /* ~= 10^-23 */
-    U64(0xF1C90080, 0xBAF72CB1), U64(0x5324C68B, 0x12DD6338), /* ~= 10^-22 */
-    U64(0x971DA050, 0x74DA7BEE), U64(0xD3F6FC16, 0xEBCA5E03), /* ~= 10^-21 */
-    U64(0xBCE50864, 0x92111AEA), U64(0x88F4BB1C, 0xA6BCF584), /* ~= 10^-20 */
-    U64(0xEC1E4A7D, 0xB69561A5), U64(0x2B31E9E3, 0xD06C32E5), /* ~= 10^-19 */
-    U64(0x9392EE8E, 0x921D5D07), U64(0x3AFF322E, 0x62439FCF), /* ~= 10^-18 */
-    U64(0xB877AA32, 0x36A4B449), U64(0x09BEFEB9, 0xFAD487C2), /* ~= 10^-17 */
-    U64(0xE69594BE, 0xC44DE15B), U64(0x4C2EBE68, 0x7989A9B3), /* ~= 10^-16 */
-    U64(0x901D7CF7, 0x3AB0ACD9), U64(0x0F9D3701, 0x4BF60A10), /* ~= 10^-15 */
-    U64(0xB424DC35, 0x095CD80F), U64(0x538484C1, 0x9EF38C94), /* ~= 10^-14 */
-    U64(0xE12E1342, 0x4BB40E13), U64(0x2865A5F2, 0x06B06FB9), /* ~= 10^-13 */
-    U64(0x8CBCCC09, 0x6F5088CB), U64(0xF93F87B7, 0x442E45D3), /* ~= 10^-12 */
-    U64(0xAFEBFF0B, 0xCB24AAFE), U64(0xF78F69A5, 0x1539D748), /* ~= 10^-11 */
-    U64(0xDBE6FECE, 0xBDEDD5BE), U64(0xB573440E, 0x5A884D1B), /* ~= 10^-10 */
-    U64(0x89705F41, 0x36B4A597), U64(0x31680A88, 0xF8953030), /* ~= 10^-9 */
-    U64(0xABCC7711, 0x8461CEFC), U64(0xFDC20D2B, 0x36BA7C3D), /* ~= 10^-8 */
-    U64(0xD6BF94D5, 0xE57A42BC), U64(0x3D329076, 0x04691B4C), /* ~= 10^-7 */
-    U64(0x8637BD05, 0xAF6C69B5), U64(0xA63F9A49, 0xC2C1B10F), /* ~= 10^-6 */
-    U64(0xA7C5AC47, 0x1B478423), U64(0x0FCF80DC, 0x33721D53), /* ~= 10^-5 */
-    U64(0xD1B71758, 0xE219652B), U64(0xD3C36113, 0x404EA4A8), /* ~= 10^-4 */
-    U64(0x83126E97, 0x8D4FDF3B), U64(0x645A1CAC, 0x083126E9), /* ~= 10^-3 */
-    U64(0xA3D70A3D, 0x70A3D70A), U64(0x3D70A3D7, 0x0A3D70A3), /* ~= 10^-2 */
-    U64(0xCCCCCCCC, 0xCCCCCCCC), U64(0xCCCCCCCC, 0xCCCCCCCC), /* ~= 10^-1 */
-    U64(0x80000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^0 */
-    U64(0xA0000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^1 */
-    U64(0xC8000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^2 */
-    U64(0xFA000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^3 */
-    U64(0x9C400000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^4 */
-    U64(0xC3500000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^5 */
-    U64(0xF4240000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^6 */
-    U64(0x98968000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^7 */
-    U64(0xBEBC2000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^8 */
-    U64(0xEE6B2800, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^9 */
-    U64(0x9502F900, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^10 */
-    U64(0xBA43B740, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^11 */
-    U64(0xE8D4A510, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^12 */
-    U64(0x9184E72A, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^13 */
-    U64(0xB5E620F4, 0x80000000), U64(0x00000000, 0x00000000), /* == 10^14 */
-    U64(0xE35FA931, 0xA0000000), U64(0x00000000, 0x00000000), /* == 10^15 */
-    U64(0x8E1BC9BF, 0x04000000), U64(0x00000000, 0x00000000), /* == 10^16 */
-    U64(0xB1A2BC2E, 0xC5000000), U64(0x00000000, 0x00000000), /* == 10^17 */
-    U64(0xDE0B6B3A, 0x76400000), U64(0x00000000, 0x00000000), /* == 10^18 */
-    U64(0x8AC72304, 0x89E80000), U64(0x00000000, 0x00000000), /* == 10^19 */
-    U64(0xAD78EBC5, 0xAC620000), U64(0x00000000, 0x00000000), /* == 10^20 */
-    U64(0xD8D726B7, 0x177A8000), U64(0x00000000, 0x00000000), /* == 10^21 */
-    U64(0x87867832, 0x6EAC9000), U64(0x00000000, 0x00000000), /* == 10^22 */
-    U64(0xA968163F, 0x0A57B400), U64(0x00000000, 0x00000000), /* == 10^23 */
-    U64(0xD3C21BCE, 0xCCEDA100), U64(0x00000000, 0x00000000), /* == 10^24 */
-    U64(0x84595161, 0x401484A0), U64(0x00000000, 0x00000000), /* == 10^25 */
-    U64(0xA56FA5B9, 0x9019A5C8), U64(0x00000000, 0x00000000), /* == 10^26 */
-    U64(0xCECB8F27, 0xF4200F3A), U64(0x00000000, 0x00000000), /* == 10^27 */
-    U64(0x813F3978, 0xF8940984), U64(0x40000000, 0x00000000), /* == 10^28 */
-    U64(0xA18F07D7, 0x36B90BE5), U64(0x50000000, 0x00000000), /* == 10^29 */
-    U64(0xC9F2C9CD, 0x04674EDE), U64(0xA4000000, 0x00000000), /* == 10^30 */
-    U64(0xFC6F7C40, 0x45812296), U64(0x4D000000, 0x00000000), /* == 10^31 */
-    U64(0x9DC5ADA8, 0x2B70B59D), U64(0xF0200000, 0x00000000), /* == 10^32 */
-    U64(0xC5371912, 0x364CE305), U64(0x6C280000, 0x00000000), /* == 10^33 */
-    U64(0xF684DF56, 0xC3E01BC6), U64(0xC7320000, 0x00000000), /* == 10^34 */
-    U64(0x9A130B96, 0x3A6C115C), U64(0x3C7F4000, 0x00000000), /* == 10^35 */
-    U64(0xC097CE7B, 0xC90715B3), U64(0x4B9F1000, 0x00000000), /* == 10^36 */
-    U64(0xF0BDC21A, 0xBB48DB20), U64(0x1E86D400, 0x00000000), /* == 10^37 */
-    U64(0x96769950, 0xB50D88F4), U64(0x13144480, 0x00000000), /* == 10^38 */
-    U64(0xBC143FA4, 0xE250EB31), U64(0x17D955A0, 0x00000000), /* == 10^39 */
-    U64(0xEB194F8E, 0x1AE525FD), U64(0x5DCFAB08, 0x00000000), /* == 10^40 */
-    U64(0x92EFD1B8, 0xD0CF37BE), U64(0x5AA1CAE5, 0x00000000), /* == 10^41 */
-    U64(0xB7ABC627, 0x050305AD), U64(0xF14A3D9E, 0x40000000), /* == 10^42 */
-    U64(0xE596B7B0, 0xC643C719), U64(0x6D9CCD05, 0xD0000000), /* == 10^43 */
-    U64(0x8F7E32CE, 0x7BEA5C6F), U64(0xE4820023, 0xA2000000), /* == 10^44 */
-    U64(0xB35DBF82, 0x1AE4F38B), U64(0xDDA2802C, 0x8A800000), /* == 10^45 */
-    U64(0xE0352F62, 0xA19E306E), U64(0xD50B2037, 0xAD200000), /* == 10^46 */
-    U64(0x8C213D9D, 0xA502DE45), U64(0x4526F422, 0xCC340000), /* == 10^47 */
-    U64(0xAF298D05, 0x0E4395D6), U64(0x9670B12B, 0x7F410000), /* == 10^48 */
-    U64(0xDAF3F046, 0x51D47B4C), U64(0x3C0CDD76, 0x5F114000), /* == 10^49 */
-    U64(0x88D8762B, 0xF324CD0F), U64(0xA5880A69, 0xFB6AC800), /* == 10^50 */
-    U64(0xAB0E93B6, 0xEFEE0053), U64(0x8EEA0D04, 0x7A457A00), /* == 10^51 */
-    U64(0xD5D238A4, 0xABE98068), U64(0x72A49045, 0x98D6D880), /* == 10^52 */
-    U64(0x85A36366, 0xEB71F041), U64(0x47A6DA2B, 0x7F864750), /* == 10^53 */
-    U64(0xA70C3C40, 0xA64E6C51), U64(0x999090B6, 0x5F67D924), /* == 10^54 */
-    U64(0xD0CF4B50, 0xCFE20765), U64(0xFFF4B4E3, 0xF741CF6D), /* == 10^55 */
-    U64(0x82818F12, 0x81ED449F), U64(0xBFF8F10E, 0x7A8921A4), /* ~= 10^56 */
-    U64(0xA321F2D7, 0x226895C7), U64(0xAFF72D52, 0x192B6A0D), /* ~= 10^57 */
-    U64(0xCBEA6F8C, 0xEB02BB39), U64(0x9BF4F8A6, 0x9F764490), /* ~= 10^58 */
-    U64(0xFEE50B70, 0x25C36A08), U64(0x02F236D0, 0x4753D5B4), /* ~= 10^59 */
-    U64(0x9F4F2726, 0x179A2245), U64(0x01D76242, 0x2C946590), /* ~= 10^60 */
-    U64(0xC722F0EF, 0x9D80AAD6), U64(0x424D3AD2, 0xB7B97EF5), /* ~= 10^61 */
-    U64(0xF8EBAD2B, 0x84E0D58B), U64(0xD2E08987, 0x65A7DEB2), /* ~= 10^62 */
-    U64(0x9B934C3B, 0x330C8577), U64(0x63CC55F4, 0x9F88EB2F), /* ~= 10^63 */
-    U64(0xC2781F49, 0xFFCFA6D5), U64(0x3CBF6B71, 0xC76B25FB), /* ~= 10^64 */
-    U64(0xF316271C, 0x7FC3908A), U64(0x8BEF464E, 0x3945EF7A), /* ~= 10^65 */
-    U64(0x97EDD871, 0xCFDA3A56), U64(0x97758BF0, 0xE3CBB5AC), /* ~= 10^66 */
-    U64(0xBDE94E8E, 0x43D0C8EC), U64(0x3D52EEED, 0x1CBEA317), /* ~= 10^67 */
-    U64(0xED63A231, 0xD4C4FB27), U64(0x4CA7AAA8, 0x63EE4BDD), /* ~= 10^68 */
-    U64(0x945E455F, 0x24FB1CF8), U64(0x8FE8CAA9, 0x3E74EF6A), /* ~= 10^69 */
-    U64(0xB975D6B6, 0xEE39E436), U64(0xB3E2FD53, 0x8E122B44), /* ~= 10^70 */
-    U64(0xE7D34C64, 0xA9C85D44), U64(0x60DBBCA8, 0x7196B616), /* ~= 10^71 */
-    U64(0x90E40FBE, 0xEA1D3A4A), U64(0xBC8955E9, 0x46FE31CD), /* ~= 10^72 */
-    U64(0xB51D13AE, 0xA4A488DD), U64(0x6BABAB63, 0x98BDBE41), /* ~= 10^73 */
-    U64(0xE264589A, 0x4DCDAB14), U64(0xC696963C, 0x7EED2DD1), /* ~= 10^74 */
-    U64(0x8D7EB760, 0x70A08AEC), U64(0xFC1E1DE5, 0xCF543CA2), /* ~= 10^75 */
-    U64(0xB0DE6538, 0x8CC8ADA8), U64(0x3B25A55F, 0x43294BCB), /* ~= 10^76 */
-    U64(0xDD15FE86, 0xAFFAD912), U64(0x49EF0EB7, 0x13F39EBE), /* ~= 10^77 */
-    U64(0x8A2DBF14, 0x2DFCC7AB), U64(0x6E356932, 0x6C784337), /* ~= 10^78 */
-    U64(0xACB92ED9, 0x397BF996), U64(0x49C2C37F, 0x07965404), /* ~= 10^79 */
-    U64(0xD7E77A8F, 0x87DAF7FB), U64(0xDC33745E, 0xC97BE906), /* ~= 10^80 */
-    U64(0x86F0AC99, 0xB4E8DAFD), U64(0x69A028BB, 0x3DED71A3), /* ~= 10^81 */
-    U64(0xA8ACD7C0, 0x222311BC), U64(0xC40832EA, 0x0D68CE0C), /* ~= 10^82 */
-    U64(0xD2D80DB0, 0x2AABD62B), U64(0xF50A3FA4, 0x90C30190), /* ~= 10^83 */
-    U64(0x83C7088E, 0x1AAB65DB), U64(0x792667C6, 0xDA79E0FA), /* ~= 10^84 */
-    U64(0xA4B8CAB1, 0xA1563F52), U64(0x577001B8, 0x91185938), /* ~= 10^85 */
-    U64(0xCDE6FD5E, 0x09ABCF26), U64(0xED4C0226, 0xB55E6F86), /* ~= 10^86 */
-    U64(0x80B05E5A, 0xC60B6178), U64(0x544F8158, 0x315B05B4), /* ~= 10^87 */
-    U64(0xA0DC75F1, 0x778E39D6), U64(0x696361AE, 0x3DB1C721), /* ~= 10^88 */
-    U64(0xC913936D, 0xD571C84C), U64(0x03BC3A19, 0xCD1E38E9), /* ~= 10^89 */
-    U64(0xFB587849, 0x4ACE3A5F), U64(0x04AB48A0, 0x4065C723), /* ~= 10^90 */
-    U64(0x9D174B2D, 0xCEC0E47B), U64(0x62EB0D64, 0x283F9C76), /* ~= 10^91 */
-    U64(0xC45D1DF9, 0x42711D9A), U64(0x3BA5D0BD, 0x324F8394), /* ~= 10^92 */
-    U64(0xF5746577, 0x930D6500), U64(0xCA8F44EC, 0x7EE36479), /* ~= 10^93 */
-    U64(0x9968BF6A, 0xBBE85F20), U64(0x7E998B13, 0xCF4E1ECB), /* ~= 10^94 */
-    U64(0xBFC2EF45, 0x6AE276E8), U64(0x9E3FEDD8, 0xC321A67E), /* ~= 10^95 */
-    U64(0xEFB3AB16, 0xC59B14A2), U64(0xC5CFE94E, 0xF3EA101E), /* ~= 10^96 */
-    U64(0x95D04AEE, 0x3B80ECE5), U64(0xBBA1F1D1, 0x58724A12), /* ~= 10^97 */
-    U64(0xBB445DA9, 0xCA61281F), U64(0x2A8A6E45, 0xAE8EDC97), /* ~= 10^98 */
-    U64(0xEA157514, 0x3CF97226), U64(0xF52D09D7, 0x1A3293BD), /* ~= 10^99 */
-    U64(0x924D692C, 0xA61BE758), U64(0x593C2626, 0x705F9C56), /* ~= 10^100 */
-    U64(0xB6E0C377, 0xCFA2E12E), U64(0x6F8B2FB0, 0x0C77836C), /* ~= 10^101 */
-    U64(0xE498F455, 0xC38B997A), U64(0x0B6DFB9C, 0x0F956447), /* ~= 10^102 */
-    U64(0x8EDF98B5, 0x9A373FEC), U64(0x4724BD41, 0x89BD5EAC), /* ~= 10^103 */
-    U64(0xB2977EE3, 0x00C50FE7), U64(0x58EDEC91, 0xEC2CB657), /* ~= 10^104 */
-    U64(0xDF3D5E9B, 0xC0F653E1), U64(0x2F2967B6, 0x6737E3ED), /* ~= 10^105 */
-    U64(0x8B865B21, 0x5899F46C), U64(0xBD79E0D2, 0x0082EE74), /* ~= 10^106 */
-    U64(0xAE67F1E9, 0xAEC07187), U64(0xECD85906, 0x80A3AA11), /* ~= 10^107 */
-    U64(0xDA01EE64, 0x1A708DE9), U64(0xE80E6F48, 0x20CC9495), /* ~= 10^108 */
-    U64(0x884134FE, 0x908658B2), U64(0x3109058D, 0x147FDCDD), /* ~= 10^109 */
-    U64(0xAA51823E, 0x34A7EEDE), U64(0xBD4B46F0, 0x599FD415), /* ~= 10^110 */
-    U64(0xD4E5E2CD, 0xC1D1EA96), U64(0x6C9E18AC, 0x7007C91A), /* ~= 10^111 */
-    U64(0x850FADC0, 0x9923329E), U64(0x03E2CF6B, 0xC604DDB0), /* ~= 10^112 */
-    U64(0xA6539930, 0xBF6BFF45), U64(0x84DB8346, 0xB786151C), /* ~= 10^113 */
-    U64(0xCFE87F7C, 0xEF46FF16), U64(0xE6126418, 0x65679A63), /* ~= 10^114 */
-    U64(0x81F14FAE, 0x158C5F6E), U64(0x4FCB7E8F, 0x3F60C07E), /* ~= 10^115 */
-    U64(0xA26DA399, 0x9AEF7749), U64(0xE3BE5E33, 0x0F38F09D), /* ~= 10^116 */
-    U64(0xCB090C80, 0x01AB551C), U64(0x5CADF5BF, 0xD3072CC5), /* ~= 10^117 */
-    U64(0xFDCB4FA0, 0x02162A63), U64(0x73D9732F, 0xC7C8F7F6), /* ~= 10^118 */
-    U64(0x9E9F11C4, 0x014DDA7E), U64(0x2867E7FD, 0xDCDD9AFA), /* ~= 10^119 */
-    U64(0xC646D635, 0x01A1511D), U64(0xB281E1FD, 0x541501B8), /* ~= 10^120 */
-    U64(0xF7D88BC2, 0x4209A565), U64(0x1F225A7C, 0xA91A4226), /* ~= 10^121 */
-    U64(0x9AE75759, 0x6946075F), U64(0x3375788D, 0xE9B06958), /* ~= 10^122 */
-    U64(0xC1A12D2F, 0xC3978937), U64(0x0052D6B1, 0x641C83AE), /* ~= 10^123 */
-    U64(0xF209787B, 0xB47D6B84), U64(0xC0678C5D, 0xBD23A49A), /* ~= 10^124 */
-    U64(0x9745EB4D, 0x50CE6332), U64(0xF840B7BA, 0x963646E0), /* ~= 10^125 */
-    U64(0xBD176620, 0xA501FBFF), U64(0xB650E5A9, 0x3BC3D898), /* ~= 10^126 */
-    U64(0xEC5D3FA8, 0xCE427AFF), U64(0xA3E51F13, 0x8AB4CEBE), /* ~= 10^127 */
-    U64(0x93BA47C9, 0x80E98CDF), U64(0xC66F336C, 0x36B10137), /* ~= 10^128 */
-    U64(0xB8A8D9BB, 0xE123F017), U64(0xB80B0047, 0x445D4184), /* ~= 10^129 */
-    U64(0xE6D3102A, 0xD96CEC1D), U64(0xA60DC059, 0x157491E5), /* ~= 10^130 */
-    U64(0x9043EA1A, 0xC7E41392), U64(0x87C89837, 0xAD68DB2F), /* ~= 10^131 */
-    U64(0xB454E4A1, 0x79DD1877), U64(0x29BABE45, 0x98C311FB), /* ~= 10^132 */
-    U64(0xE16A1DC9, 0xD8545E94), U64(0xF4296DD6, 0xFEF3D67A), /* ~= 10^133 */
-    U64(0x8CE2529E, 0x2734BB1D), U64(0x1899E4A6, 0x5F58660C), /* ~= 10^134 */
-    U64(0xB01AE745, 0xB101E9E4), U64(0x5EC05DCF, 0xF72E7F8F), /* ~= 10^135 */
-    U64(0xDC21A117, 0x1D42645D), U64(0x76707543, 0xF4FA1F73), /* ~= 10^136 */
-    U64(0x899504AE, 0x72497EBA), U64(0x6A06494A, 0x791C53A8), /* ~= 10^137 */
-    U64(0xABFA45DA, 0x0EDBDE69), U64(0x0487DB9D, 0x17636892), /* ~= 10^138 */
-    U64(0xD6F8D750, 0x9292D603), U64(0x45A9D284, 0x5D3C42B6), /* ~= 10^139 */
-    U64(0x865B8692, 0x5B9BC5C2), U64(0x0B8A2392, 0xBA45A9B2), /* ~= 10^140 */
-    U64(0xA7F26836, 0xF282B732), U64(0x8E6CAC77, 0x68D7141E), /* ~= 10^141 */
-    U64(0xD1EF0244, 0xAF2364FF), U64(0x3207D795, 0x430CD926), /* ~= 10^142 */
-    U64(0x8335616A, 0xED761F1F), U64(0x7F44E6BD, 0x49E807B8), /* ~= 10^143 */
-    U64(0xA402B9C5, 0xA8D3A6E7), U64(0x5F16206C, 0x9C6209A6), /* ~= 10^144 */
-    U64(0xCD036837, 0x130890A1), U64(0x36DBA887, 0xC37A8C0F), /* ~= 10^145 */
-    U64(0x80222122, 0x6BE55A64), U64(0xC2494954, 0xDA2C9789), /* ~= 10^146 */
-    U64(0xA02AA96B, 0x06DEB0FD), U64(0xF2DB9BAA, 0x10B7BD6C), /* ~= 10^147 */
-    U64(0xC83553C5, 0xC8965D3D), U64(0x6F928294, 0x94E5ACC7), /* ~= 10^148 */
-    U64(0xFA42A8B7, 0x3ABBF48C), U64(0xCB772339, 0xBA1F17F9), /* ~= 10^149 */
-    U64(0x9C69A972, 0x84B578D7), U64(0xFF2A7604, 0x14536EFB), /* ~= 10^150 */
-    U64(0xC38413CF, 0x25E2D70D), U64(0xFEF51385, 0x19684ABA), /* ~= 10^151 */
-    U64(0xF46518C2, 0xEF5B8CD1), U64(0x7EB25866, 0x5FC25D69), /* ~= 10^152 */
-    U64(0x98BF2F79, 0xD5993802), U64(0xEF2F773F, 0xFBD97A61), /* ~= 10^153 */
-    U64(0xBEEEFB58, 0x4AFF8603), U64(0xAAFB550F, 0xFACFD8FA), /* ~= 10^154 */
-    U64(0xEEAABA2E, 0x5DBF6784), U64(0x95BA2A53, 0xF983CF38), /* ~= 10^155 */
-    U64(0x952AB45C, 0xFA97A0B2), U64(0xDD945A74, 0x7BF26183), /* ~= 10^156 */
-    U64(0xBA756174, 0x393D88DF), U64(0x94F97111, 0x9AEEF9E4), /* ~= 10^157 */
-    U64(0xE912B9D1, 0x478CEB17), U64(0x7A37CD56, 0x01AAB85D), /* ~= 10^158 */
-    U64(0x91ABB422, 0xCCB812EE), U64(0xAC62E055, 0xC10AB33A), /* ~= 10^159 */
-    U64(0xB616A12B, 0x7FE617AA), U64(0x577B986B, 0x314D6009), /* ~= 10^160 */
-    U64(0xE39C4976, 0x5FDF9D94), U64(0xED5A7E85, 0xFDA0B80B), /* ~= 10^161 */
-    U64(0x8E41ADE9, 0xFBEBC27D), U64(0x14588F13, 0xBE847307), /* ~= 10^162 */
-    U64(0xB1D21964, 0x7AE6B31C), U64(0x596EB2D8, 0xAE258FC8), /* ~= 10^163 */
-    U64(0xDE469FBD, 0x99A05FE3), U64(0x6FCA5F8E, 0xD9AEF3BB), /* ~= 10^164 */
-    U64(0x8AEC23D6, 0x80043BEE), U64(0x25DE7BB9, 0x480D5854), /* ~= 10^165 */
-    U64(0xADA72CCC, 0x20054AE9), U64(0xAF561AA7, 0x9A10AE6A), /* ~= 10^166 */
-    U64(0xD910F7FF, 0x28069DA4), U64(0x1B2BA151, 0x8094DA04), /* ~= 10^167 */
-    U64(0x87AA9AFF, 0x79042286), U64(0x90FB44D2, 0xF05D0842), /* ~= 10^168 */
-    U64(0xA99541BF, 0x57452B28), U64(0x353A1607, 0xAC744A53), /* ~= 10^169 */
-    U64(0xD3FA922F, 0x2D1675F2), U64(0x42889B89, 0x97915CE8), /* ~= 10^170 */
-    U64(0x847C9B5D, 0x7C2E09B7), U64(0x69956135, 0xFEBADA11), /* ~= 10^171 */
-    U64(0xA59BC234, 0xDB398C25), U64(0x43FAB983, 0x7E699095), /* ~= 10^172 */
-    U64(0xCF02B2C2, 0x1207EF2E), U64(0x94F967E4, 0x5E03F4BB), /* ~= 10^173 */
-    U64(0x8161AFB9, 0x4B44F57D), U64(0x1D1BE0EE, 0xBAC278F5), /* ~= 10^174 */
-    U64(0xA1BA1BA7, 0x9E1632DC), U64(0x6462D92A, 0x69731732), /* ~= 10^175 */
-    U64(0xCA28A291, 0x859BBF93), U64(0x7D7B8F75, 0x03CFDCFE), /* ~= 10^176 */
-    U64(0xFCB2CB35, 0xE702AF78), U64(0x5CDA7352, 0x44C3D43E), /* ~= 10^177 */
-    U64(0x9DEFBF01, 0xB061ADAB), U64(0x3A088813, 0x6AFA64A7), /* ~= 10^178 */
-    U64(0xC56BAEC2, 0x1C7A1916), U64(0x088AAA18, 0x45B8FDD0), /* ~= 10^179 */
-    U64(0xF6C69A72, 0xA3989F5B), U64(0x8AAD549E, 0x57273D45), /* ~= 10^180 */
-    U64(0x9A3C2087, 0xA63F6399), U64(0x36AC54E2, 0xF678864B), /* ~= 10^181 */
-    U64(0xC0CB28A9, 0x8FCF3C7F), U64(0x84576A1B, 0xB416A7DD), /* ~= 10^182 */
-    U64(0xF0FDF2D3, 0xF3C30B9F), U64(0x656D44A2, 0xA11C51D5), /* ~= 10^183 */
-    U64(0x969EB7C4, 0x7859E743), U64(0x9F644AE5, 0xA4B1B325), /* ~= 10^184 */
-    U64(0xBC4665B5, 0x96706114), U64(0x873D5D9F, 0x0DDE1FEE), /* ~= 10^185 */
-    U64(0xEB57FF22, 0xFC0C7959), U64(0xA90CB506, 0xD155A7EA), /* ~= 10^186 */
-    U64(0x9316FF75, 0xDD87CBD8), U64(0x09A7F124, 0x42D588F2), /* ~= 10^187 */
-    U64(0xB7DCBF53, 0x54E9BECE), U64(0x0C11ED6D, 0x538AEB2F), /* ~= 10^188 */
-    U64(0xE5D3EF28, 0x2A242E81), U64(0x8F1668C8, 0xA86DA5FA), /* ~= 10^189 */
-    U64(0x8FA47579, 0x1A569D10), U64(0xF96E017D, 0x694487BC), /* ~= 10^190 */
-    U64(0xB38D92D7, 0x60EC4455), U64(0x37C981DC, 0xC395A9AC), /* ~= 10^191 */
-    U64(0xE070F78D, 0x3927556A), U64(0x85BBE253, 0xF47B1417), /* ~= 10^192 */
-    U64(0x8C469AB8, 0x43B89562), U64(0x93956D74, 0x78CCEC8E), /* ~= 10^193 */
-    U64(0xAF584166, 0x54A6BABB), U64(0x387AC8D1, 0x970027B2), /* ~= 10^194 */
-    U64(0xDB2E51BF, 0xE9D0696A), U64(0x06997B05, 0xFCC0319E), /* ~= 10^195 */
-    U64(0x88FCF317, 0xF22241E2), U64(0x441FECE3, 0xBDF81F03), /* ~= 10^196 */
-    U64(0xAB3C2FDD, 0xEEAAD25A), U64(0xD527E81C, 0xAD7626C3), /* ~= 10^197 */
-    U64(0xD60B3BD5, 0x6A5586F1), U64(0x8A71E223, 0xD8D3B074), /* ~= 10^198 */
-    U64(0x85C70565, 0x62757456), U64(0xF6872D56, 0x67844E49), /* ~= 10^199 */
-    U64(0xA738C6BE, 0xBB12D16C), U64(0xB428F8AC, 0x016561DB), /* ~= 10^200 */
-    U64(0xD106F86E, 0x69D785C7), U64(0xE13336D7, 0x01BEBA52), /* ~= 10^201 */
-    U64(0x82A45B45, 0x0226B39C), U64(0xECC00246, 0x61173473), /* ~= 10^202 */
-    U64(0xA34D7216, 0x42B06084), U64(0x27F002D7, 0xF95D0190), /* ~= 10^203 */
-    U64(0xCC20CE9B, 0xD35C78A5), U64(0x31EC038D, 0xF7B441F4), /* ~= 10^204 */
-    U64(0xFF290242, 0xC83396CE), U64(0x7E670471, 0x75A15271), /* ~= 10^205 */
-    U64(0x9F79A169, 0xBD203E41), U64(0x0F0062C6, 0xE984D386), /* ~= 10^206 */
-    U64(0xC75809C4, 0x2C684DD1), U64(0x52C07B78, 0xA3E60868), /* ~= 10^207 */
-    U64(0xF92E0C35, 0x37826145), U64(0xA7709A56, 0xCCDF8A82), /* ~= 10^208 */
-    U64(0x9BBCC7A1, 0x42B17CCB), U64(0x88A66076, 0x400BB691), /* ~= 10^209 */
-    U64(0xC2ABF989, 0x935DDBFE), U64(0x6ACFF893, 0xD00EA435), /* ~= 10^210 */
-    U64(0xF356F7EB, 0xF83552FE), U64(0x0583F6B8, 0xC4124D43), /* ~= 10^211 */
-    U64(0x98165AF3, 0x7B2153DE), U64(0xC3727A33, 0x7A8B704A), /* ~= 10^212 */
-    U64(0xBE1BF1B0, 0x59E9A8D6), U64(0x744F18C0, 0x592E4C5C), /* ~= 10^213 */
-    U64(0xEDA2EE1C, 0x7064130C), U64(0x1162DEF0, 0x6F79DF73), /* ~= 10^214 */
-    U64(0x9485D4D1, 0xC63E8BE7), U64(0x8ADDCB56, 0x45AC2BA8), /* ~= 10^215 */
-    U64(0xB9A74A06, 0x37CE2EE1), U64(0x6D953E2B, 0xD7173692), /* ~= 10^216 */
-    U64(0xE8111C87, 0xC5C1BA99), U64(0xC8FA8DB6, 0xCCDD0437), /* ~= 10^217 */
-    U64(0x910AB1D4, 0xDB9914A0), U64(0x1D9C9892, 0x400A22A2), /* ~= 10^218 */
-    U64(0xB54D5E4A, 0x127F59C8), U64(0x2503BEB6, 0xD00CAB4B), /* ~= 10^219 */
-    U64(0xE2A0B5DC, 0x971F303A), U64(0x2E44AE64, 0x840FD61D), /* ~= 10^220 */
-    U64(0x8DA471A9, 0xDE737E24), U64(0x5CEAECFE, 0xD289E5D2), /* ~= 10^221 */
-    U64(0xB10D8E14, 0x56105DAD), U64(0x7425A83E, 0x872C5F47), /* ~= 10^222 */
-    U64(0xDD50F199, 0x6B947518), U64(0xD12F124E, 0x28F77719), /* ~= 10^223 */
-    U64(0x8A5296FF, 0xE33CC92F), U64(0x82BD6B70, 0xD99AAA6F), /* ~= 10^224 */
-    U64(0xACE73CBF, 0xDC0BFB7B), U64(0x636CC64D, 0x1001550B), /* ~= 10^225 */
-    U64(0xD8210BEF, 0xD30EFA5A), U64(0x3C47F7E0, 0x5401AA4E), /* ~= 10^226 */
-    U64(0x8714A775, 0xE3E95C78), U64(0x65ACFAEC, 0x34810A71), /* ~= 10^227 */
-    U64(0xA8D9D153, 0x5CE3B396), U64(0x7F1839A7, 0x41A14D0D), /* ~= 10^228 */
-    U64(0xD31045A8, 0x341CA07C), U64(0x1EDE4811, 0x1209A050), /* ~= 10^229 */
-    U64(0x83EA2B89, 0x2091E44D), U64(0x934AED0A, 0xAB460432), /* ~= 10^230 */
-    U64(0xA4E4B66B, 0x68B65D60), U64(0xF81DA84D, 0x5617853F), /* ~= 10^231 */
-    U64(0xCE1DE406, 0x42E3F4B9), U64(0x36251260, 0xAB9D668E), /* ~= 10^232 */
-    U64(0x80D2AE83, 0xE9CE78F3), U64(0xC1D72B7C, 0x6B426019), /* ~= 10^233 */
-    U64(0xA1075A24, 0xE4421730), U64(0xB24CF65B, 0x8612F81F), /* ~= 10^234 */
-    U64(0xC94930AE, 0x1D529CFC), U64(0xDEE033F2, 0x6797B627), /* ~= 10^235 */
-    U64(0xFB9B7CD9, 0xA4A7443C), U64(0x169840EF, 0x017DA3B1), /* ~= 10^236 */
-    U64(0x9D412E08, 0x06E88AA5), U64(0x8E1F2895, 0x60EE864E), /* ~= 10^237 */
-    U64(0xC491798A, 0x08A2AD4E), U64(0xF1A6F2BA, 0xB92A27E2), /* ~= 10^238 */
-    U64(0xF5B5D7EC, 0x8ACB58A2), U64(0xAE10AF69, 0x6774B1DB), /* ~= 10^239 */
-    U64(0x9991A6F3, 0xD6BF1765), U64(0xACCA6DA1, 0xE0A8EF29), /* ~= 10^240 */
-    U64(0xBFF610B0, 0xCC6EDD3F), U64(0x17FD090A, 0x58D32AF3), /* ~= 10^241 */
-    U64(0xEFF394DC, 0xFF8A948E), U64(0xDDFC4B4C, 0xEF07F5B0), /* ~= 10^242 */
-    U64(0x95F83D0A, 0x1FB69CD9), U64(0x4ABDAF10, 0x1564F98E), /* ~= 10^243 */
-    U64(0xBB764C4C, 0xA7A4440F), U64(0x9D6D1AD4, 0x1ABE37F1), /* ~= 10^244 */
-    U64(0xEA53DF5F, 0xD18D5513), U64(0x84C86189, 0x216DC5ED), /* ~= 10^245 */
-    U64(0x92746B9B, 0xE2F8552C), U64(0x32FD3CF5, 0xB4E49BB4), /* ~= 10^246 */
-    U64(0xB7118682, 0xDBB66A77), U64(0x3FBC8C33, 0x221DC2A1), /* ~= 10^247 */
-    U64(0xE4D5E823, 0x92A40515), U64(0x0FABAF3F, 0xEAA5334A), /* ~= 10^248 */
-    U64(0x8F05B116, 0x3BA6832D), U64(0x29CB4D87, 0xF2A7400E), /* ~= 10^249 */
-    U64(0xB2C71D5B, 0xCA9023F8), U64(0x743E20E9, 0xEF511012), /* ~= 10^250 */
-    U64(0xDF78E4B2, 0xBD342CF6), U64(0x914DA924, 0x6B255416), /* ~= 10^251 */
-    U64(0x8BAB8EEF, 0xB6409C1A), U64(0x1AD089B6, 0xC2F7548E), /* ~= 10^252 */
-    U64(0xAE9672AB, 0xA3D0C320), U64(0xA184AC24, 0x73B529B1), /* ~= 10^253 */
-    U64(0xDA3C0F56, 0x8CC4F3E8), U64(0xC9E5D72D, 0x90A2741E), /* ~= 10^254 */
-    U64(0x88658996, 0x17FB1871), U64(0x7E2FA67C, 0x7A658892), /* ~= 10^255 */
-    U64(0xAA7EEBFB, 0x9DF9DE8D), U64(0xDDBB901B, 0x98FEEAB7), /* ~= 10^256 */
-    U64(0xD51EA6FA, 0x85785631), U64(0x552A7422, 0x7F3EA565), /* ~= 10^257 */
-    U64(0x8533285C, 0x936B35DE), U64(0xD53A8895, 0x8F87275F), /* ~= 10^258 */
-    U64(0xA67FF273, 0xB8460356), U64(0x8A892ABA, 0xF368F137), /* ~= 10^259 */
-    U64(0xD01FEF10, 0xA657842C), U64(0x2D2B7569, 0xB0432D85), /* ~= 10^260 */
-    U64(0x8213F56A, 0x67F6B29B), U64(0x9C3B2962, 0x0E29FC73), /* ~= 10^261 */
-    U64(0xA298F2C5, 0x01F45F42), U64(0x8349F3BA, 0x91B47B8F), /* ~= 10^262 */
-    U64(0xCB3F2F76, 0x42717713), U64(0x241C70A9, 0x36219A73), /* ~= 10^263 */
-    U64(0xFE0EFB53, 0xD30DD4D7), U64(0xED238CD3, 0x83AA0110), /* ~= 10^264 */
-    U64(0x9EC95D14, 0x63E8A506), U64(0xF4363804, 0x324A40AA), /* ~= 10^265 */
-    U64(0xC67BB459, 0x7CE2CE48), U64(0xB143C605, 0x3EDCD0D5), /* ~= 10^266 */
-    U64(0xF81AA16F, 0xDC1B81DA), U64(0xDD94B786, 0x8E94050A), /* ~= 10^267 */
-    U64(0x9B10A4E5, 0xE9913128), U64(0xCA7CF2B4, 0x191C8326), /* ~= 10^268 */
-    U64(0xC1D4CE1F, 0x63F57D72), U64(0xFD1C2F61, 0x1F63A3F0), /* ~= 10^269 */
-    U64(0xF24A01A7, 0x3CF2DCCF), U64(0xBC633B39, 0x673C8CEC), /* ~= 10^270 */
-    U64(0x976E4108, 0x8617CA01), U64(0xD5BE0503, 0xE085D813), /* ~= 10^271 */
-    U64(0xBD49D14A, 0xA79DBC82), U64(0x4B2D8644, 0xD8A74E18), /* ~= 10^272 */
-    U64(0xEC9C459D, 0x51852BA2), U64(0xDDF8E7D6, 0x0ED1219E), /* ~= 10^273 */
-    U64(0x93E1AB82, 0x52F33B45), U64(0xCABB90E5, 0xC942B503), /* ~= 10^274 */
-    U64(0xB8DA1662, 0xE7B00A17), U64(0x3D6A751F, 0x3B936243), /* ~= 10^275 */
-    U64(0xE7109BFB, 0xA19C0C9D), U64(0x0CC51267, 0x0A783AD4), /* ~= 10^276 */
-    U64(0x906A617D, 0x450187E2), U64(0x27FB2B80, 0x668B24C5), /* ~= 10^277 */
-    U64(0xB484F9DC, 0x9641E9DA), U64(0xB1F9F660, 0x802DEDF6), /* ~= 10^278 */
-    U64(0xE1A63853, 0xBBD26451), U64(0x5E7873F8, 0xA0396973), /* ~= 10^279 */
-    U64(0x8D07E334, 0x55637EB2), U64(0xDB0B487B, 0x6423E1E8), /* ~= 10^280 */
-    U64(0xB049DC01, 0x6ABC5E5F), U64(0x91CE1A9A, 0x3D2CDA62), /* ~= 10^281 */
-    U64(0xDC5C5301, 0xC56B75F7), U64(0x7641A140, 0xCC7810FB), /* ~= 10^282 */
-    U64(0x89B9B3E1, 0x1B6329BA), U64(0xA9E904C8, 0x7FCB0A9D), /* ~= 10^283 */
-    U64(0xAC2820D9, 0x623BF429), U64(0x546345FA, 0x9FBDCD44), /* ~= 10^284 */
-    U64(0xD732290F, 0xBACAF133), U64(0xA97C1779, 0x47AD4095), /* ~= 10^285 */
-    U64(0x867F59A9, 0xD4BED6C0), U64(0x49ED8EAB, 0xCCCC485D), /* ~= 10^286 */
-    U64(0xA81F3014, 0x49EE8C70), U64(0x5C68F256, 0xBFFF5A74), /* ~= 10^287 */
-    U64(0xD226FC19, 0x5C6A2F8C), U64(0x73832EEC, 0x6FFF3111), /* ~= 10^288 */
-    U64(0x83585D8F, 0xD9C25DB7), U64(0xC831FD53, 0xC5FF7EAB), /* ~= 10^289 */
-    U64(0xA42E74F3, 0xD032F525), U64(0xBA3E7CA8, 0xB77F5E55), /* ~= 10^290 */
-    U64(0xCD3A1230, 0xC43FB26F), U64(0x28CE1BD2, 0xE55F35EB), /* ~= 10^291 */
-    U64(0x80444B5E, 0x7AA7CF85), U64(0x7980D163, 0xCF5B81B3), /* ~= 10^292 */
-    U64(0xA0555E36, 0x1951C366), U64(0xD7E105BC, 0xC332621F), /* ~= 10^293 */
-    U64(0xC86AB5C3, 0x9FA63440), U64(0x8DD9472B, 0xF3FEFAA7), /* ~= 10^294 */
-    U64(0xFA856334, 0x878FC150), U64(0xB14F98F6, 0xF0FEB951), /* ~= 10^295 */
-    U64(0x9C935E00, 0xD4B9D8D2), U64(0x6ED1BF9A, 0x569F33D3), /* ~= 10^296 */
-    U64(0xC3B83581, 0x09E84F07), U64(0x0A862F80, 0xEC4700C8), /* ~= 10^297 */
-    U64(0xF4A642E1, 0x4C6262C8), U64(0xCD27BB61, 0x2758C0FA), /* ~= 10^298 */
-    U64(0x98E7E9CC, 0xCFBD7DBD), U64(0x8038D51C, 0xB897789C), /* ~= 10^299 */
-    U64(0xBF21E440, 0x03ACDD2C), U64(0xE0470A63, 0xE6BD56C3), /* ~= 10^300 */
-    U64(0xEEEA5D50, 0x04981478), U64(0x1858CCFC, 0xE06CAC74), /* ~= 10^301 */
-    U64(0x95527A52, 0x02DF0CCB), U64(0x0F37801E, 0x0C43EBC8), /* ~= 10^302 */
-    U64(0xBAA718E6, 0x8396CFFD), U64(0xD3056025, 0x8F54E6BA), /* ~= 10^303 */
-    U64(0xE950DF20, 0x247C83FD), U64(0x47C6B82E, 0xF32A2069), /* ~= 10^304 */
-    U64(0x91D28B74, 0x16CDD27E), U64(0x4CDC331D, 0x57FA5441), /* ~= 10^305 */
-    U64(0xB6472E51, 0x1C81471D), U64(0xE0133FE4, 0xADF8E952), /* ~= 10^306 */
-    U64(0xE3D8F9E5, 0x63A198E5), U64(0x58180FDD, 0xD97723A6), /* ~= 10^307 */
-    U64(0x8E679C2F, 0x5E44FF8F), U64(0x570F09EA, 0xA7EA7648), /* ~= 10^308 */
-    U64(0xB201833B, 0x35D63F73), U64(0x2CD2CC65, 0x51E513DA), /* ~= 10^309 */
-    U64(0xDE81E40A, 0x034BCF4F), U64(0xF8077F7E, 0xA65E58D1), /* ~= 10^310 */
-    U64(0x8B112E86, 0x420F6191), U64(0xFB04AFAF, 0x27FAF782), /* ~= 10^311 */
-    U64(0xADD57A27, 0xD29339F6), U64(0x79C5DB9A, 0xF1F9B563), /* ~= 10^312 */
-    U64(0xD94AD8B1, 0xC7380874), U64(0x18375281, 0xAE7822BC), /* ~= 10^313 */
-    U64(0x87CEC76F, 0x1C830548), U64(0x8F229391, 0x0D0B15B5), /* ~= 10^314 */
-    U64(0xA9C2794A, 0xE3A3C69A), U64(0xB2EB3875, 0x504DDB22), /* ~= 10^315 */
-    U64(0xD433179D, 0x9C8CB841), U64(0x5FA60692, 0xA46151EB), /* ~= 10^316 */
-    U64(0x849FEEC2, 0x81D7F328), U64(0xDBC7C41B, 0xA6BCD333), /* ~= 10^317 */
-    U64(0xA5C7EA73, 0x224DEFF3), U64(0x12B9B522, 0x906C0800), /* ~= 10^318 */
-    U64(0xCF39E50F, 0xEAE16BEF), U64(0xD768226B, 0x34870A00), /* ~= 10^319 */
-    U64(0x81842F29, 0xF2CCE375), U64(0xE6A11583, 0x00D46640), /* ~= 10^320 */
-    U64(0xA1E53AF4, 0x6F801C53), U64(0x60495AE3, 0xC1097FD0), /* ~= 10^321 */
-    U64(0xCA5E89B1, 0x8B602368), U64(0x385BB19C, 0xB14BDFC4), /* ~= 10^322 */
-    U64(0xFCF62C1D, 0xEE382C42), U64(0x46729E03, 0xDD9ED7B5), /* ~= 10^323 */
-    U64(0x9E19DB92, 0xB4E31BA9), U64(0x6C07A2C2, 0x6A8346D1)  /* ~= 10^324 */
-};
-
-/**
- Get the cached pow10 value from pow10_sig_table.
- @param exp10 The exponent of pow(10, e). This value must in range
-              POW10_SIG_TABLE_MIN_EXP to POW10_SIG_TABLE_MAX_EXP.
- @param hi    The highest 64 bits of pow(10, e).
- @param lo    The lower 64 bits after `hi`.
- */
-static_inline void pow10_table_get_sig(i32 exp10, u64 *hi, u64 *lo) {
-    i32 idx = exp10 - (POW10_SIG_TABLE_MIN_EXP);
-    *hi = pow10_sig_table[idx * 2];
-    *lo = pow10_sig_table[idx * 2 + 1];
-}
-
-/**
- Get the exponent (base 2) for highest 64 bits significand in pow10_sig_table.
- */
-static_inline void pow10_table_get_exp(i32 exp10, i32 *exp2) {
-    /* e2 = floor(log2(pow(10, e))) - 64 + 1 */
-    /*    = floor(e * log2(10) - 63)         */
-    *exp2 = (exp10 * 217706 - 4128768) >> 16;
-}
-
-#endif
-
-
-
-#if !YYJSON_DISABLE_READER
-
-/*==============================================================================
- * JSON Character Matcher
- *============================================================================*/
-
-/** Character type */
-typedef u8 char_type;
-
-/** Whitespace character: ' ', '\\t', '\\n', '\\r'. */
-static const char_type CHAR_TYPE_SPACE      = 1 << 0;
-
-/** Number character: '-', [0-9]. */
-static const char_type CHAR_TYPE_NUMBER     = 1 << 1;
-
-/** JSON Escaped character: '"', '\', [0x00-0x1F]. */
-static const char_type CHAR_TYPE_ESC_ASCII  = 1 << 2;
-
-/** Non-ASCII character: [0x80-0xFF]. */
-static const char_type CHAR_TYPE_NON_ASCII  = 1 << 3;
-
-/** JSON container character: '{', '['. */
-static const char_type CHAR_TYPE_CONTAINER  = 1 << 4;
-
-/** Comment character: '/'. */
-static const char_type CHAR_TYPE_COMMENT    = 1 << 5;
-
-/** Line end character '\\n', '\\r', '\0'. */
-static const char_type CHAR_TYPE_LINE_END   = 1 << 6;
-
-/** Character type table (generate with misc/make_tables.c) */
-static const char_type char_table[256] = {
-    0x44, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-    0x04, 0x05, 0x45, 0x04, 0x04, 0x45, 0x04, 0x04,
-    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-    0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x20,
-    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-    0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
-};
-
-/** Match a character with specified type. */
-static_inline bool char_is_type(u8 c, char_type type) {
-    return (char_table[c] & type) != 0;
-}
-
-/** Match a whitespace: ' ', '\\t', '\\n', '\\r'. */
-static_inline bool char_is_space(u8 c) {
-    return char_is_type(c, (char_type)CHAR_TYPE_SPACE);
-}
-
-/** Match a whitespace or comment: ' ', '\\t', '\\n', '\\r', '/'. */
-static_inline bool char_is_space_or_comment(u8 c) {
-    return char_is_type(c, (char_type)(CHAR_TYPE_SPACE | CHAR_TYPE_COMMENT));
-}
-
-/** Match a JSON number: '-', [0-9]. */
-static_inline bool char_is_number(u8 c) {
-    return char_is_type(c, (char_type)CHAR_TYPE_NUMBER);
-}
-
-/** Match a JSON container: '{', '['. */
-static_inline bool char_is_container(u8 c) {
-    return char_is_type(c, (char_type)CHAR_TYPE_CONTAINER);
-}
-
-/** Match a stop character in ASCII string: '"', '\', [0x00-0x1F], [0x80-0xFF]*/
-static_inline bool char_is_ascii_stop(u8 c) {
-    return char_is_type(c, (char_type)(CHAR_TYPE_ESC_ASCII |
-                                       CHAR_TYPE_NON_ASCII));
-}
-
-/** Match a line end character: '\\n', '\\r', '\0'*/
-static_inline bool char_is_line_end(u8 c) {
-    return char_is_type(c, (char_type)CHAR_TYPE_LINE_END);
-}
-
-
-
-/*==============================================================================
- * Digit Character Matcher
- *============================================================================*/
-
-/** Digit type */
-typedef u8 digi_type;
-
-/** Digit: '0'. */
-static const digi_type DIGI_TYPE_ZERO       = 1 << 0;
-
-/** Digit: [1-9]. */
-static const digi_type DIGI_TYPE_NONZERO    = 1 << 1;
-
-/** Plus sign (positive): '+'. */
-static const digi_type DIGI_TYPE_POS        = 1 << 2;
-
-/** Minus sign (negative): '-'. */
-static const digi_type DIGI_TYPE_NEG        = 1 << 3;
-
-/** Decimal point: '.' */
-static const digi_type DIGI_TYPE_DOT        = 1 << 4;
-
-/** Exponent sign: 'e, 'E'. */
-static const digi_type DIGI_TYPE_EXP        = 1 << 5;
-
-/** Digit type table (generate with misc/make_tables.c) */
-static const digi_type digi_table[256] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x10, 0x00,
-    0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-    0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-/** Match a character with specified type. */
-static_inline bool digi_is_type(u8 d, digi_type type) {
-    return (digi_table[d] & type) != 0;
-}
-
-/** Match a sign: '+', '-' */
-static_inline bool digi_is_sign(u8 d) {
-    return digi_is_type(d, (digi_type)(DIGI_TYPE_POS | DIGI_TYPE_NEG));
-}
-
-/** Match a none zero digit: [1-9] */
-static_inline bool digi_is_nonzero(u8 d) {
-    return digi_is_type(d, (digi_type)DIGI_TYPE_NONZERO);
-}
-
-/** Match a digit: [0-9] */
-static_inline bool digi_is_digit(u8 d) {
-    return digi_is_type(d, (digi_type)(DIGI_TYPE_ZERO | DIGI_TYPE_NONZERO));
-}
-
-/** Match an exponent sign: 'e', 'E'. */
-static_inline bool digi_is_exp(u8 d) {
-    return digi_is_type(d, (digi_type)DIGI_TYPE_EXP);
-}
-
-/** Match a floating point indicator: '.', 'e', 'E'. */
-static_inline bool digi_is_fp(u8 d) {
-    return digi_is_type(d, (digi_type)(DIGI_TYPE_DOT | DIGI_TYPE_EXP));
-}
-
-/** Match a digit or floating point indicator: [0-9], '.', 'e', 'E'. */
-static_inline bool digi_is_digit_or_fp(u8 d) {
-    return digi_is_type(d, (digi_type)(DIGI_TYPE_ZERO | DIGI_TYPE_NONZERO |
-                                       DIGI_TYPE_DOT | DIGI_TYPE_EXP));
-}
-
-
-
-/*==============================================================================
- * Hex Character Reader
- * This function is used by JSON reader to read escaped characters.
- *============================================================================*/
-
-/**
- This table is used to convert 4 hex character sequence to a number.
- A valid hex character [0-9A-Fa-f] will mapped to it's raw number [0x00, 0x0F],
- an invalid hex character will mapped to [0xF0].
- (generate with misc/make_tables.c)
- */
-static const u8 hex_conv_table[256] = {
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-    0x08, 0x09, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0
-};
-
-/**
- Scans an escaped character sequence as a UTF-16 code unit (branchless).
- e.g. "\\u005C" should pass "005C" as `cur`.
- 
- This requires the string has 4-byte zero padding.
- */
-static_inline bool read_hex_u16(const u8 *cur, u16 *val) {
-    u16 c0, c1, c2, c3, t0, t1;
-    c0 = hex_conv_table[cur[0]];
-    c1 = hex_conv_table[cur[1]];
-    c2 = hex_conv_table[cur[2]];
-    c3 = hex_conv_table[cur[3]];
-    t0 = (u16)((c0 << 8) | c2);
-    t1 = (u16)((c1 << 8) | c3);
-    *val = (u16)((t0 << 4) | t1);
-    return ((t0 | t1) & (u16)0xF0F0) == 0;
-}
-
-
-
-/*==============================================================================
- * JSON Reader Utils
- * These functions are used by JSON reader to read literals and comments.
- *============================================================================*/
-
-/** Read 'true' literal, '*cur' should be 't'. */
-static_inline bool read_true(u8 **ptr, yyjson_val *val) {
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if (likely(byte_match_4(cur, "true"))) {
-        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
-        *end = cur + 4;
-        return true;
-    }
-    return false;
-}
-
-/** Read 'false' literal, '*cur' should be 'f'. */
-static_inline bool read_false(u8 **ptr, yyjson_val *val) {
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if (likely(byte_match_4(cur + 1, "alse"))) {
-        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
-        *end = cur + 5;
-        return true;
-    }
-    return false;
-}
-
-/** Read 'null' literal, '*cur' should be 'n'. */
-static_inline bool read_null(u8 **ptr, yyjson_val *val) {
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if (likely(byte_match_4(cur, "null"))) {
-        val->tag = YYJSON_TYPE_NULL;
-        *end = cur + 4;
-        return true;
-    }
-    return false;
-}
-
-/** Read 'Inf' or 'Infinity' literal (ignoring case). */
-static_inline bool read_inf(bool sign, u8 **ptr, u8 **pre, yyjson_val *val) {
-#if !YYJSON_DISABLE_NON_STANDARD
-    u8 *hdr = *ptr - sign;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if ((cur[0] == 'I' || cur[0] == 'i') &&
-        (cur[1] == 'N' || cur[1] == 'n') &&
-        (cur[2] == 'F' || cur[2] == 'f')) {
-        if ((cur[3] == 'I' || cur[3] == 'i') &&
-            (cur[4] == 'N' || cur[4] == 'n') &&
-            (cur[5] == 'I' || cur[5] == 'i') &&
-            (cur[6] == 'T' || cur[6] == 't') &&
-            (cur[7] == 'Y' || cur[7] == 'y')) {
-            cur += 8;
-        } else {
-            cur += 3;
-        }
-        *end = cur;
-        if (pre) {
-            /* add null-terminator for previous raw string */
-            if (*pre) **pre = '\0';
-            *pre = cur;
-            val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
-            val->uni.str = (const char *)hdr;
-        } else {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-            val->uni.u64 = f64_raw_get_inf(sign);
-        }
-        return true;
-    }
-#endif
-    return false;
-}
-
-/** Read 'NaN' literal (ignoring case). */
-static_inline bool read_nan(bool sign, u8 **ptr, u8 **pre, yyjson_val *val) {
-#if !YYJSON_DISABLE_NON_STANDARD
-    u8 *hdr = *ptr - sign;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if ((cur[0] == 'N' || cur[0] == 'n') &&
-        (cur[1] == 'A' || cur[1] == 'a') &&
-        (cur[2] == 'N' || cur[2] == 'n')) {
-        cur += 3;
-        *end = cur;
-        if (pre) {
-            /* add null-terminator for previous raw string */
-            if (*pre) **pre = '\0';
-            *pre = cur;
-            val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
-            val->uni.str = (const char *)hdr;
-        } else {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-            val->uni.u64 = f64_raw_get_nan(sign);
-        }
-        return true;
-    }
-#endif
-    return false;
-}
-
-/** Read 'Inf', 'Infinity' or 'NaN' literal (ignoring case). */
-static_inline bool read_inf_or_nan(bool sign, u8 **ptr, u8 **pre,
-                                   yyjson_val *val) {
-    if (read_inf(sign, ptr, pre, val)) return true;
-    if (read_nan(sign, ptr, pre, val)) return true;
-    return false;
-}
-
-/** Read a JSON number as raw string. */
-static_noinline bool read_number_raw(u8 **ptr,
-                                     u8 **pre,
-                                     bool ext,
-                                     yyjson_val *val,
-                                     const char **msg) {
-    
-#define return_err(_pos, _msg) do { \
-    *msg = _msg; \
-    *end = _pos; \
-    return false; \
-} while (false)
-    
-#define return_raw() do { \
-    val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; \
-    val->uni.str = (const char *)hdr; \
-    *pre = cur; *end = cur; return true; \
-} while (false)
-    
-    u8 *hdr = *ptr;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    
-    /* add null-terminator for previous raw string */
-    if (*pre) **pre = '\0';
-    
-    /* skip sign */
-    cur += (*cur == '-');
-    
-    /* read first digit, check leading zero */
-    if (unlikely(!digi_is_digit(*cur))) {
-        if (unlikely(ext)) {
-            if (read_inf_or_nan(*hdr == '-', &cur, pre, val)) return_raw();
-        }
-        return_err(cur - 1, "no digit after minus sign");
-    }
-    
-    /* read integral part */
-    if (*cur == '0') {
-        cur++;
-        if (unlikely(digi_is_digit(*cur))) {
-            return_err(cur - 1, "number with leading zero is not allowed");
-        }
-        if (!digi_is_fp(*cur)) return_raw();
-    } else {
-        while (digi_is_digit(*cur)) cur++;
-        if (!digi_is_fp(*cur)) return_raw();
-    }
-    
-    /* read fraction part */
-    if (*cur == '.') {
-        cur++;
-        if (!digi_is_digit(*cur++)) {
-            return_err(cur - 1, "no digit after decimal point");
-        }
-        while (digi_is_digit(*cur)) cur++;
-    }
-    
-    /* read exponent part */
-    if (digi_is_exp(*cur)) {
-        cur += 1 + digi_is_sign(cur[1]);
-        if (!digi_is_digit(*cur++)) {
-            return_err(cur - 1, "no digit after exponent sign");
-        }
-        while (digi_is_digit(*cur)) cur++;
-    }
-    
-    return_raw();
-    
-#undef return_err
-#undef return_raw
-}
-
-/**
- Skips spaces and comments as many as possible.
- 
- It will return false in these cases:
-    1. No character is skipped. The 'end' pointer is set as input cursor.
-    2. A multiline comment is not closed. The 'end' pointer is set as the head
-       of this comment block.
- */
-static_noinline bool skip_spaces_and_comments(u8 **ptr) {
-    u8 *hdr = *ptr;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    while (true) {
-        if (byte_match_2(cur, "/*")) {
-            hdr = cur;
-            cur += 2;
-            while (true) {
-                if (byte_match_2(cur, "*/")) {
-                    cur += 2;
-                    break;
-                }
-                if (*cur == 0) {
-                    *end = hdr;
-                    return false;
-                }
-                cur++;
-            }
-            continue;
-        }
-        if (byte_match_2(cur, "//")) {
-            cur += 2;
-            while (!char_is_line_end(*cur)) cur++;
-            continue;
-        }
-        if (char_is_space(*cur)) {
-            cur += 1;
-            while (char_is_space(*cur)) cur++;
-            continue;
-        }
-        break;
-    }
-    *end = cur;
-    return hdr != cur;
-}
-
-
-
-#if YYJSON_HAS_IEEE_754 && !YYJSON_DISABLE_FAST_FP_CONV /* FP_READER */
-
-/*==============================================================================
- * BigInt For Floating Point Number Reader
- *
- * The bigint algorithm is used by floating-point number reader to get correctly
- * rounded result for numbers with lots of digits. This part of code is rarely
- * used for common numbers.
- *============================================================================*/
-
-/** Maximum exponent of exact pow10 */
-#define U64_POW10_MAX_EXP 19
-
-/** Table: [ 10^0, ..., 10^19 ] (generate with misc/make_tables.c) */
-static const u64 u64_pow10_table[U64_POW10_MAX_EXP + 1] = {
-    U64(0x00000000, 0x00000001), U64(0x00000000, 0x0000000A),
-    U64(0x00000000, 0x00000064), U64(0x00000000, 0x000003E8),
-    U64(0x00000000, 0x00002710), U64(0x00000000, 0x000186A0),
-    U64(0x00000000, 0x000F4240), U64(0x00000000, 0x00989680),
-    U64(0x00000000, 0x05F5E100), U64(0x00000000, 0x3B9ACA00),
-    U64(0x00000002, 0x540BE400), U64(0x00000017, 0x4876E800),
-    U64(0x000000E8, 0xD4A51000), U64(0x00000918, 0x4E72A000),
-    U64(0x00005AF3, 0x107A4000), U64(0x00038D7E, 0xA4C68000),
-    U64(0x002386F2, 0x6FC10000), U64(0x01634578, 0x5D8A0000),
-    U64(0x0DE0B6B3, 0xA7640000), U64(0x8AC72304, 0x89E80000)
-};
-
-/** Maximum numbers of chunks used by a bigint (58 is enough here). */
-#define BIGINT_MAX_CHUNKS 64
-
-/** Unsigned arbitrarily large integer */
-typedef struct bigint {
-    u32 used; /* used chunks count, should not be 0 */
-    u64 bits[BIGINT_MAX_CHUNKS]; /* chunks */
-} bigint;
-
-/**
- Evaluate 'big += val'.
- @param big A big number (can be 0).
- @param val An unsigned integer (can be 0).
- */
-static_inline void bigint_add_u64(bigint *big, u64 val) {
-    u32 idx, max;
-    u64 num = big->bits[0];
-    u64 add = num + val;
-    big->bits[0] = add;
-    if (likely((add >= num) || (add >= val))) return;
-    for ((void)(idx = 1), max = big->used; idx < max; idx++) {
-        if (likely(big->bits[idx] != U64_MAX)) {
-            big->bits[idx] += 1;
-            return;
-        }
-        big->bits[idx] = 0;
-    }
-    big->bits[big->used++] = 1;
-}
-
-/**
- Evaluate 'big *= val'.
- @param big A big number (can be 0).
- @param val An unsigned integer (cannot be 0).
- */
-static_inline void bigint_mul_u64(bigint *big, u64 val) {
-    u32 idx = 0, max = big->used;
-    u64 hi, lo, carry = 0;
-    for (; idx < max; idx++) {
-        if (big->bits[idx]) break;
-    }
-    for (; idx < max; idx++) {
-        u128_mul_add(big->bits[idx], val, carry, &hi, &lo);
-        big->bits[idx] = lo;
-        carry = hi;
-    }
-    if (carry) big->bits[big->used++] = carry;
-}
-
-/**
- Evaluate 'big *= 2^exp'.
- @param big A big number (can be 0).
- @param exp An exponent integer (can be 0).
- */
-static_inline void bigint_mul_pow2(bigint *big, u32 exp) {
-    u32 shft = exp % 64;
-    u32 move = exp / 64;
-    u32 idx = big->used;
-    if (unlikely(shft == 0)) {
-        for (; idx > 0; idx--) {
-            big->bits[idx + move - 1] = big->bits[idx - 1];
-        }
-        big->used += move;
-        while (move) big->bits[--move] = 0;
-    } else {
-        big->bits[idx] = 0;
-        for (; idx > 0; idx--) {
-            u64 num = big->bits[idx] << shft;
-            num |= big->bits[idx - 1] >> (64 - shft);
-            big->bits[idx + move] = num;
-        }
-        big->bits[move] = big->bits[0] << shft;
-        big->used += move + (big->bits[big->used + move] > 0);
-        while (move) big->bits[--move] = 0;
-    }
-}
-
-/**
- Evaluate 'big *= 10^exp'.
- @param big A big number (can be 0).
- @param exp An exponent integer (cannot be 0).
- */
-static_inline void bigint_mul_pow10(bigint *big, i32 exp) {
-    for (; exp >= U64_POW10_MAX_EXP; exp -= U64_POW10_MAX_EXP) {
-        bigint_mul_u64(big, u64_pow10_table[U64_POW10_MAX_EXP]);
-    }
-    if (exp) {
-        bigint_mul_u64(big, u64_pow10_table[exp]);
-    }
-}
-
-/**
- Compare two bigint.
- @return -1 if 'a < b', +1 if 'a > b', 0 if 'a == b'.
- */
-static_inline i32 bigint_cmp(bigint *a, bigint *b) {
-    u32 idx = a->used;
-    if (a->used < b->used) return -1;
-    if (a->used > b->used) return +1;
-    while (idx-- > 0) {
-        u64 av = a->bits[idx];
-        u64 bv = b->bits[idx];
-        if (av < bv) return -1;
-        if (av > bv) return +1;
-    }
-    return 0;
-}
-
-/**
- Evaluate 'big = val'.
- @param big A big number (can be 0).
- @param val An unsigned integer (can be 0).
- */
-static_inline void bigint_set_u64(bigint *big, u64 val) {
-    big->used = 1;
-    big->bits[0] = val;
-}
-
-/** Set a bigint with floating point number string. */
-static_noinline void bigint_set_buf(bigint *big, u64 sig, i32 *exp,
-                                    u8 *sig_cut, u8 *sig_end, u8 *dot_pos) {
-    
-    if (unlikely(!sig_cut)) {
-        /* no digit cut, set significant part only */
-        bigint_set_u64(big, sig);
-        return;
-        
-    } else {
-        /* some digits were cut, read them from 'sig_cut' to 'sig_end' */
-        u8 *hdr = sig_cut;
-        u8 *cur = hdr;
-        u32 len = 0;
-        u64 val = 0;
-        bool dig_big_cut = false;
-        bool has_dot = (hdr < dot_pos) & (dot_pos < sig_end);
-        u32 dig_len_total = U64_SAFE_DIG + (u32)(sig_end - hdr) - has_dot;
-        
-        sig -= (*sig_cut >= '5'); /* sig was rounded before */
-        if (dig_len_total > F64_MAX_DEC_DIG) {
-            dig_big_cut = true;
-            sig_end -= dig_len_total - (F64_MAX_DEC_DIG + 1);
-            sig_end -= (dot_pos + 1 == sig_end);
-            dig_len_total = (F64_MAX_DEC_DIG + 1);
-        }
-        *exp -= (i32)dig_len_total - U64_SAFE_DIG;
-        
-        big->used = 1;
-        big->bits[0] = sig;
-        while (cur < sig_end) {
-            if (likely(cur != dot_pos)) {
-                val = val * 10 + (u8)(*cur++ - '0');
-                len++;
-                if (unlikely(cur == sig_end && dig_big_cut)) {
-                    /* The last digit must be non-zero,    */
-                    /* set it to '1' for correct rounding. */
-                    val = val - (val % 10) + 1;
-                }
-                if (len == U64_SAFE_DIG || cur == sig_end) {
-                    bigint_mul_pow10(big, (i32)len);
-                    bigint_add_u64(big, val);
-                    val = 0;
-                    len = 0;
-                }
-            } else {
-                cur++;
-            }
-        }
-    }
-}
-
-
-
-/*==============================================================================
- * Diy Floating Point
- *============================================================================*/
-
-/** "Do It Yourself Floating Point" struct. */
-typedef struct diy_fp {
-    u64 sig; /* significand */
-    i32 exp; /* exponent, base 2 */
-    i32 pad; /* padding, useless */
-} diy_fp;
-
-/** Get cached rounded diy_fp with pow(10, e) The input value must in range
-    [POW10_SIG_TABLE_MIN_EXP, POW10_SIG_TABLE_MAX_EXP]. */
-static_inline diy_fp diy_fp_get_cached_pow10(i32 exp10) {
-    diy_fp fp;
-    u64 sig_ext;
-    pow10_table_get_sig(exp10, &fp.sig, &sig_ext);
-    pow10_table_get_exp(exp10, &fp.exp);
-    fp.sig += (sig_ext >> 63);
-    return fp;
-}
-
-/** Returns fp * fp2. */
-static_inline diy_fp diy_fp_mul(diy_fp fp, diy_fp fp2) {
-    u64 hi, lo;
-    u128_mul(fp.sig, fp2.sig, &hi, &lo);
-    fp.sig = hi + (lo >> 63);
-    fp.exp += fp2.exp + 64;
-    return fp;
-}
-
-/** Convert diy_fp to IEEE-754 raw value. */
-static_inline u64 diy_fp_to_ieee_raw(diy_fp fp) {
-    u64 sig = fp.sig;
-    i32 exp = fp.exp;
-    u32 lz_bits;
-    if (unlikely(fp.sig == 0)) return 0;
-    
-    lz_bits = u64_lz_bits(sig);
-    sig <<= lz_bits;
-    sig >>= F64_BITS - F64_SIG_FULL_BITS;
-    exp -= (i32)lz_bits;
-    exp += F64_BITS - F64_SIG_FULL_BITS;
-    exp += F64_SIG_BITS;
-    
-    if (unlikely(exp >= F64_MAX_BIN_EXP)) {
-        /* overflow */
-        return F64_RAW_INF;
-    } else if (likely(exp >= F64_MIN_BIN_EXP - 1)) {
-        /* normal */
-        exp += F64_EXP_BIAS;
-        return ((u64)exp << F64_SIG_BITS) | (sig & F64_SIG_MASK);
-    } else if (likely(exp >= F64_MIN_BIN_EXP - F64_SIG_FULL_BITS)) {
-        /* subnormal */
-        return sig >> (F64_MIN_BIN_EXP - exp - 1);
-    } else {
-        /* underflow */
-        return 0;
-    }
-}
-
-
-
-/*==============================================================================
- * JSON Number Reader (IEEE-754)
- *============================================================================*/
-
-/** Maximum exact pow10 exponent for double value. */
-#define F64_POW10_EXP_MAX_EXACT 22
-
-/** Cached pow10 table. */
-static const f64 f64_pow10_table[] = {
-    1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12,
-    1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
-};
-
-/**
- Read a JSON number.
- 
- 1. This function assume that the floating-point number is in IEEE-754 format.
- 2. This function support uint64/int64/double number. If an integer number
-    cannot fit in uint64/int64, it will returns as a double number. If a double
-    number is infinite, the return value is based on flag.
- 3. This function (with inline attribute) may generate a lot of instructions.
- */
-static_inline bool read_number(u8 **ptr,
-                               u8 **pre,
-                               bool ext,
-                               yyjson_val *val,
-                               const char **msg) {
-    
-#define return_err(_pos, _msg) do { \
-    *msg = _msg; \
-    *end = _pos; \
-    return false; \
-} while (false)
-    
-#define return_i64(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | (u8)((u8)sign << 3); \
-    val->uni.u64 = (u64)(sign ? (u64)(~(_v) + 1) : (u64)(_v)); \
-    *end = cur; return true; \
-} while (false)
-    
-#define return_f64(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \
-    val->uni.f64 = sign ? -(f64)(_v) : (f64)(_v); \
-    *end = cur; return true; \
-} while (false)
-    
-#define return_f64_raw(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \
-    val->uni.u64 = ((u64)sign << 63) | (u64)(_v); \
-    *end = cur; return true; \
-} while (false)
-    
-#define return_inf() do { \
-    if (unlikely(ext)) return_f64_raw(F64_RAW_INF); \
-    else return_err(hdr, "number is infinity when parsed as double"); \
-} while (false)
-    
-    u8 *sig_cut = NULL; /* significant part cutting position for long number */
-    u8 *sig_end = NULL; /* significant part ending position */
-    u8 *dot_pos = NULL; /* decimal point position */
-    
-    u64 sig = 0; /* significant part of the number */
-    i32 exp = 0; /* exponent part of the number */
-    
-    bool exp_sign; /* temporary exponent sign from literal part */
-    i64 exp_sig = 0; /* temporary exponent number from significant part */
-    i64 exp_lit = 0; /* temporary exponent number from exponent literal part */
-    u64 num; /* temporary number for reading */
-    u8 *tmp; /* temporary cursor for reading */
-    
-    u8 *hdr = *ptr;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    bool sign;
-    
-    /* read number as raw string if has flag */
-    if (unlikely(pre)) {
-        return read_number_raw(ptr, pre, ext, val, msg);
-    }
-    
-    sign = (*hdr == '-');
-    cur += sign;
-    
-    /* begin with a leading zero or non-digit */
-    if (unlikely(!digi_is_nonzero(*cur))) { /* 0 or non-digit char */
-        if (unlikely(*cur != '0')) { /* non-digit char */
-            if (unlikely(ext)) {
-                if (read_inf_or_nan(sign, &cur, pre, val)) {
-                    *end = cur;
-                    return true;
-                }
-            }
-            return_err(cur - 1, "no digit after minus sign");
-        }
-        /* begin with 0 */
-        if (likely(!digi_is_digit_or_fp(*++cur))) return_i64(0);
-        if (likely(*cur == '.')) {
-            dot_pos = cur++;
-            if (unlikely(!digi_is_digit(*cur))) {
-                return_err(cur - 1, "no digit after decimal point");
-            }
-            while (unlikely(*cur == '0')) cur++;
-            if (likely(digi_is_digit(*cur))) {
-                /* first non-zero digit after decimal point */
-                sig = (u64)(*cur - '0'); /* read first digit */
-                cur--;
-                goto digi_frac_1; /* continue read fraction part */
-            }
-        }
-        if (unlikely(digi_is_digit(*cur))) {
-            return_err(cur - 1, "number with leading zero is not allowed");
-        }
-        if (unlikely(digi_is_exp(*cur))) { /* 0 with any exponent is still 0 */
-            cur += (usize)1 + digi_is_sign(cur[1]);
-            if (unlikely(!digi_is_digit(*cur))) {
-                return_err(cur - 1, "no digit after exponent sign");
-            }
-            while (digi_is_digit(*++cur));
-        }
-        return_f64_raw(0);
-    }
-    
-    /* begin with non-zero digit */
-    sig = (u64)(*cur - '0');
-    
-    /*
-     Read integral part, same as the following code.
-     
-         for (int i = 1; i <= 18; i++) {
-            num = cur[i] - '0';
-            if (num <= 9) sig = num + sig * 10;
-            else goto digi_sepr_i;
-         }
-     */
-#define expr_intg(i) \
-    if (likely((num = (u64)(cur[i] - (u8)'0')) <= 9)) sig = num + sig * 10; \
-    else { goto digi_sepr_##i; }
-    repeat_in_1_18(expr_intg);
-#undef expr_intg
-    
-    
-    cur += 19; /* skip continuous 19 digits */
-    if (!digi_is_digit_or_fp(*cur)) {
-        /* this number is an integer consisting of 19 digits */
-        if (sign && (sig > ((u64)1 << 63))) { /* overflow */
-            return_f64(normalized_u64_to_f64(sig));
-        }
-        return_i64(sig);
-    }
-    goto digi_intg_more; /* read more digits in integral part */
-    
-    
-    /* process first non-digit character */
-#define expr_sepr(i) \
-    digi_sepr_##i: \
-    if (likely(!digi_is_fp(cur[i]))) { cur += i; return_i64(sig); } \
-    dot_pos = cur + i; \
-    if (likely(cur[i] == '.')) goto digi_frac_##i; \
-    cur += i; sig_end = cur; goto digi_exp_more;
-    repeat_in_1_18(expr_sepr)
-#undef expr_sepr
-    
-    
-    /* read fraction part */
-#define expr_frac(i) \
-    digi_frac_##i: \
-    if (likely((num = (u64)(cur[i + 1] - (u8)'0')) <= 9)) \
-        sig = num + sig * 10; \
-    else { goto digi_stop_##i; }
-    repeat_in_1_18(expr_frac)
-#undef expr_frac
-    
-    cur += 20; /* skip 19 digits and 1 decimal point */
-    if (!digi_is_digit(*cur)) goto digi_frac_end; /* fraction part end */
-    goto digi_frac_more; /* read more digits in fraction part */
-    
-    
-    /* significant part end */
-#define expr_stop(i) \
-    digi_stop_##i: \
-    cur += i + 1; \
-    goto digi_frac_end;
-    repeat_in_1_18(expr_stop)
-#undef expr_stop
-    
-    
-    /* read more digits in integral part */
-digi_intg_more:
-    if (digi_is_digit(*cur)) {
-        if (!digi_is_digit_or_fp(cur[1])) {
-            /* this number is an integer consisting of 20 digits */
-            num = (u64)(*cur - '0');
-            if ((sig < (U64_MAX / 10)) ||
-                (sig == (U64_MAX / 10) && num <= (U64_MAX % 10))) {
-                sig = num + sig * 10;
-                cur++;
-                /* convert to double if overflow */
-                if (sign) return_f64(normalized_u64_to_f64(sig));
-                return_i64(sig);
-            }
-        }
-    }
-    
-    if (digi_is_exp(*cur)) {
-        dot_pos = cur;
-        goto digi_exp_more;
-    }
-    
-    if (*cur == '.') {
-        dot_pos = cur++;
-        if (!digi_is_digit(*cur)) {
-            return_err(cur, "no digit after decimal point");
-        }
-    }
-    
-    
-    /* read more digits in fraction part */
-digi_frac_more:
-    sig_cut = cur; /* too large to fit in u64, excess digits need to be cut */
-    sig += (*cur >= '5'); /* round */
-    while (digi_is_digit(*++cur));
-    if (!dot_pos) {
-        dot_pos = cur;
-        if (*cur == '.') {
-            if (!digi_is_digit(*++cur)) {
-                return_err(cur, "no digit after decimal point");
-            }
-            while (digi_is_digit(*cur)) cur++;
-        }
-    }
-    exp_sig = (i64)(dot_pos - sig_cut);
-    exp_sig += (dot_pos < sig_cut);
-    
-    /* ignore trailing zeros */
-    tmp = cur - 1;
-    while (*tmp == '0' || *tmp == '.') tmp--;
-    if (tmp < sig_cut) {
-        sig_cut = NULL;
-    } else {
-        sig_end = cur;
-    }
-    
-    if (digi_is_exp(*cur)) goto digi_exp_more;
-    goto digi_exp_finish;
-    
-    
-    /* fraction part end */
-digi_frac_end:
-    if (unlikely(dot_pos + 1 == cur)) {
-        return_err(cur - 1, "no digit after decimal point");
-    }
-    sig_end = cur;
-    exp_sig = -(i64)((u64)(cur - dot_pos) - 1);
-    if (likely(!digi_is_exp(*cur))) {
-        if (unlikely(exp_sig < F64_MIN_DEC_EXP - 19)) {
-            return_f64_raw(0); /* underflow */
-        }
-        exp = (i32)exp_sig;
-        goto digi_finish;
-    } else {
-        goto digi_exp_more;
-    }
-    
-    
-    /* read exponent part */
-digi_exp_more:
-    exp_sign = (*++cur == '-');
-    cur += digi_is_sign(*cur);
-    if (unlikely(!digi_is_digit(*cur))) {
-        return_err(cur - 1, "no digit after exponent sign");
-    }
-    while (*cur == '0') cur++;
-    
-    /* read exponent literal */
-    tmp = cur;
-    while (digi_is_digit(*cur)) {
-        exp_lit = (i64)((u8)(*cur++ - '0') + (u64)exp_lit * 10);
-    }
-    if (unlikely(cur - tmp >= U64_SAFE_DIG)) {
-        if (exp_sign) {
-            return_f64_raw(0); /* underflow */
-        } else {
-            return_inf(); /* overflow */
-        }
-    }
-    exp_sig += exp_sign ? -exp_lit : exp_lit;
-    
-    
-    /* validate exponent value */
-digi_exp_finish:
-    if (unlikely(exp_sig < F64_MIN_DEC_EXP - 19)) {
-        return_f64_raw(0); /* underflow */
-    }
-    if (unlikely(exp_sig > F64_MAX_DEC_EXP)) {
-        return_inf(); /* overflow */
-    }
-    exp = (i32)exp_sig;
-    
-    
-    /* all digit read finished */
-digi_finish:
-    
-    /*
-     Fast path 1:
-     
-     1. The floating-point number calculation should be accurate, see the
-        comments of macro `YYJSON_DOUBLE_MATH_CORRECT`.
-     2. Correct rounding should be performed (fegetround() == FE_TONEAREST).
-     3. The input of floating point number calculation does not lose precision,
-        which means: 64 - leading_zero(input) - trailing_zero(input) < 53.
-    
-     We don't check all available inputs here, because that would make the code
-     more complicated, and not friendly to branch predictor.
-     */
-#if YYJSON_DOUBLE_MATH_CORRECT
-    if (sig < ((u64)1 << 53) &&
-        exp >= -F64_POW10_EXP_MAX_EXACT &&
-        exp <= +F64_POW10_EXP_MAX_EXACT) {
-        f64 dbl = (f64)sig;
-        if (exp < 0) {
-            dbl /= f64_pow10_table[-exp];
-        } else {
-            dbl *= f64_pow10_table[+exp];
-        }
-        return_f64(dbl);
-    }
-#endif
-    
-    /*
-     Fast path 2:
-     
-     To keep it simple, we only accept normal number here,
-     let the slow path to handle subnormal and infinity number.
-     */
-    if (likely(!sig_cut &&
-               exp > -F64_MAX_DEC_EXP + 1 &&
-               exp < +F64_MAX_DEC_EXP - 20)) {
-        /*
-         The result value is exactly equal to (sig * 10^exp),
-         the exponent part (10^exp) can be converted to (sig2 * 2^exp2).
-         
-         The sig2 can be an infinite length number, only the highest 128 bits
-         is cached in the pow10_sig_table.
-         
-         Now we have these bits:
-         sig1 (normalized 64bit)        : aaaaaaaa
-         sig2 (higher 64bit)            : bbbbbbbb
-         sig2_ext (lower 64bit)         : cccccccc
-         sig2_cut (extra unknown bits)  : dddddddddddd....
-         
-         And the calculation process is:
-         ----------------------------------------
-                 aaaaaaaa *
-                 bbbbbbbbccccccccdddddddddddd....
-         ----------------------------------------
-         abababababababab +
-                 acacacacacacacac +
-                         adadadadadadadadadad....
-         ----------------------------------------
-         [hi____][lo____] +
-                 [hi2___][lo2___] +
-                         [unknown___________....]
-         ----------------------------------------
-         
-         The addition with carry may affect higher bits, but if there is a 0
-         in higher bits, the bits higher than 0 will not be affected.
-         
-         `lo2` + `unknown` may get a carry bit and may affect `hi2`, the max
-         value of `hi2` is 0xFFFFFFFFFFFFFFFE, so `hi2` will not overflow.
-         
-         `lo` + `hi2` may also get a carry bit and may affect `hi`, but only
-         the highest significant 53 bits of `hi` is needed. If there is a 0
-         in the lower bits of `hi`, then all the following bits can be dropped.
-         
-         To convert the result to IEEE-754 double number, we need to perform
-         correct rounding:
-         1. if bit 54 is 0, round down,
-         2. if bit 54 is 1 and any bit beyond bit 54 is 1, round up,
-         3. if bit 54 is 1 and all bits beyond bit 54 are 0, round to even,
-            as the extra bits is unknown, this case will not be handled here.
-         */
-        
-        u64 raw;
-        u64 sig1, sig2, sig2_ext, hi, lo, hi2, lo2, add, bits;
-        i32 exp2;
-        u32 lz;
-        bool exact = false, carry, round_up;
-        
-        /* convert (10^exp) to (sig2 * 2^exp2) */
-        pow10_table_get_sig(exp, &sig2, &sig2_ext);
-        pow10_table_get_exp(exp, &exp2);
-        
-        /* normalize and multiply */
-        lz = u64_lz_bits(sig);
-        sig1 = sig << lz;
-        exp2 -= (i32)lz;
-        u128_mul(sig1, sig2, &hi, &lo);
-        
-        /*
-         The `hi` is in range [0x4000000000000000, 0xFFFFFFFFFFFFFFFE],
-         To get normalized value, `hi` should be shifted to the left by 0 or 1.
-         
-         The highest significant 53 bits is used by IEEE-754 double number,
-         and the bit 54 is used to detect rounding direction.
-         
-         The lowest (64 - 54 - 1) bits is used to check whether it contains 0.
-         */
-        bits = hi & (((u64)1 << (64 - 54 - 1)) - 1);
-        if (bits - 1 < (((u64)1 << (64 - 54 - 1)) - 2)) {
-            /*
-             (bits != 0 && bits != 0x1FF) => (bits - 1 < 0x1FF - 1)
-             The `bits` is not zero, so we don't need to check `round to even`
-             case. The `bits` contains bit `0`, so we can drop the extra bits
-             after `0`.
-             */
-            exact = true;
-            
-        } else {
-            /*
-             (bits == 0 || bits == 0x1FF)
-             The `bits` is filled with all `0` or all `1`, so we need to check
-             lower bits with another 64-bit multiplication.
-             */
-            u128_mul(sig1, sig2_ext, &hi2, &lo2);
-            
-            add = lo + hi2;
-            if (add + 1 > (u64)1) {
-                /*
-                 (add != 0 && add != U64_MAX) => (add + 1 > 1)
-                 The `add` is not zero, so we don't need to check `round to
-                 even` case. The `add` contains bit `0`, so we can drop the
-                 extra bits after `0`. The `hi` cannot be U64_MAX, so it will
-                 not overflow.
-                 */
-                carry = add < lo || add < hi2;
-                hi += carry;
-                exact = true;
-            }
-        }
-        
-        if (exact) {
-            /* normalize */
-            lz = hi < ((u64)1 << 63);
-            hi <<= lz;
-            exp2 -= (i32)lz;
-            exp2 += 64;
-            
-            /* test the bit 54 and get rounding direction */
-            round_up = (hi & ((u64)1 << (64 - 54))) > (u64)0;
-            hi += (round_up ? ((u64)1 << (64 - 54)) : (u64)0);
-            
-            /* test overflow */
-            if (hi < ((u64)1 << (64 - 54))) {
-                hi = ((u64)1 << 63);
-                exp2 += 1;
-            }
-            
-            /* This is a normal number, convert it to IEEE-754 format. */
-            hi >>= F64_BITS - F64_SIG_FULL_BITS;
-            exp2 += F64_BITS - F64_SIG_FULL_BITS + F64_SIG_BITS;
-            exp2 += F64_EXP_BIAS;
-            raw = ((u64)exp2 << F64_SIG_BITS) | (hi & F64_SIG_MASK);
-            return_f64_raw(raw);
-        }
-    }
-    
-    /*
-     Slow path: read double number exactly with diyfp.
-     1. Use cached diyfp to get an approximation value.
-     2. Use bigcomp to check the approximation value if needed.
-     
-     This algorithm refers to google's double-conversion project:
-     https://github.com/google/double-conversion
-     */
-    {
-        const i32 ERR_ULP_LOG = 3;
-        const i32 ERR_ULP = 1 << ERR_ULP_LOG;
-        const i32 ERR_CACHED_POW = ERR_ULP / 2;
-        const i32 ERR_MUL_FIXED = ERR_ULP / 2;
-        const i32 DIY_SIG_BITS = 64;
-        const i32 EXP_BIAS = F64_EXP_BIAS + F64_SIG_BITS;
-        const i32 EXP_SUBNORMAL = -EXP_BIAS + 1;
-        
-        u64 fp_err;
-        u32 bits;
-        i32 order_of_magnitude;
-        i32 effective_significand_size;
-        i32 precision_digits_count;
-        u64 precision_bits;
-        u64 half_way;
-        
-        u64 raw;
-        diy_fp fp, fp_upper;
-        bigint big_full, big_comp;
-        i32 cmp;
-        
-        fp.sig = sig;
-        fp.exp = 0;
-        fp_err = sig_cut ? (u64)(ERR_ULP / 2) : (u64)0;
-        
-        /* normalize */
-        bits = u64_lz_bits(fp.sig);
-        fp.sig <<= bits;
-        fp.exp -= (i32)bits;
-        fp_err <<= bits;
-        
-        /* multiply and add error */
-        fp = diy_fp_mul(fp, diy_fp_get_cached_pow10(exp));
-        fp_err += (u64)ERR_CACHED_POW + (fp_err != 0) + (u64)ERR_MUL_FIXED;
-        
-        /* normalize */
-        bits = u64_lz_bits(fp.sig);
-        fp.sig <<= bits;
-        fp.exp -= (i32)bits;
-        fp_err <<= bits;
-        
-        /* effective significand */
-        order_of_magnitude = DIY_SIG_BITS + fp.exp;
-        if (likely(order_of_magnitude >= EXP_SUBNORMAL + F64_SIG_FULL_BITS)) {
-            effective_significand_size = F64_SIG_FULL_BITS;
-        } else if (order_of_magnitude <= EXP_SUBNORMAL) {
-            effective_significand_size = 0;
-        } else {
-            effective_significand_size = order_of_magnitude - EXP_SUBNORMAL;
-        }
-        
-        /* precision digits count */
-        precision_digits_count = DIY_SIG_BITS - effective_significand_size;
-        if (unlikely(precision_digits_count + ERR_ULP_LOG >= DIY_SIG_BITS)) {
-            i32 shr = (precision_digits_count + ERR_ULP_LOG) - DIY_SIG_BITS + 1;
-            fp.sig >>= shr;
-            fp.exp += shr;
-            fp_err = (fp_err >> shr) + 1 + (u32)ERR_ULP;
-            precision_digits_count -= shr;
-        }
-        
-        /* half way */
-        precision_bits = fp.sig & (((u64)1 << precision_digits_count) - 1);
-        precision_bits *= (u32)ERR_ULP;
-        half_way = (u64)1 << (precision_digits_count - 1);
-        half_way *= (u32)ERR_ULP;
-        
-        /* rounding */
-        fp.sig >>= precision_digits_count;
-        fp.sig += (precision_bits >= half_way + fp_err);
-        fp.exp += precision_digits_count;
-        
-        /* get IEEE double raw value */
-        raw = diy_fp_to_ieee_raw(fp);
-        if (unlikely(raw == F64_RAW_INF)) return_inf();
-        if (likely(precision_bits <= half_way - fp_err ||
-                   precision_bits >= half_way + fp_err)) {
-            return_f64_raw(raw); /* number is accurate */
-        }
-        /* now the number is the correct value, or the next lower value */
-        
-        /* upper boundary */
-        if (raw & F64_EXP_MASK) {
-            fp_upper.sig = (raw & F64_SIG_MASK) + ((u64)1 << F64_SIG_BITS);
-            fp_upper.exp = (i32)((raw & F64_EXP_MASK) >> F64_SIG_BITS);
-        } else {
-            fp_upper.sig = (raw & F64_SIG_MASK);
-            fp_upper.exp = 1;
-        }
-        fp_upper.exp -= F64_EXP_BIAS + F64_SIG_BITS;
-        fp_upper.sig <<= 1;
-        fp_upper.exp -= 1;
-        fp_upper.sig += 1; /* add half ulp */
-        
-        /* compare with bigint */
-        bigint_set_buf(&big_full, sig, &exp, sig_cut, sig_end, dot_pos);
-        bigint_set_u64(&big_comp, fp_upper.sig);
-        if (exp >= 0) {
-            bigint_mul_pow10(&big_full, +exp);
-        } else {
-            bigint_mul_pow10(&big_comp, -exp);
-        }
-        if (fp_upper.exp > 0) {
-            bigint_mul_pow2(&big_comp, (u32)+fp_upper.exp);
-        } else {
-            bigint_mul_pow2(&big_full, (u32)-fp_upper.exp);
-        }
-        cmp = bigint_cmp(&big_full, &big_comp);
-        if (likely(cmp != 0)) {
-            /* round down or round up */
-            raw += (cmp > 0);
-        } else {
-            /* falls midway, round to even */
-            raw += (raw & 1);
-        }
-        
-        if (unlikely(raw == F64_RAW_INF)) return_inf();
-        return_f64_raw(raw);
-    }
-    
-#undef has_flag
-#undef return_err
-#undef return_inf
-#undef return_i64
-#undef return_f64
-#undef return_f64_raw
-}
-
-
-
-#else /* FP_READER */
-
-/**
- Read a JSON number.
- This is a fallback function if the custom number reader is disabled.
- This function use libc's strtod() to read floating-point number.
- */
-static_noinline bool read_number(u8 **ptr,
-                                 u8 **pre,
-                                 bool ext,
-                                 yyjson_val *val,
-                                 const char **msg) {
-    
-#define return_err(_pos, _msg) do { \
-    *msg = _msg; \
-    *end = _pos; \
-    return false; \
-} while (false)
-    
-#define return_i64(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | (u64)((u8)sign << 3); \
-    val->uni.u64 = (u64)(sign ? (u64)(~(_v) + 1) : (u64)(_v)); \
-    *end = cur; return true; \
-} while (false)
-    
-#define return_f64(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \
-    val->uni.f64 = sign ? -(f64)(_v) : (f64)(_v); \
-    *end = cur; return true; \
-} while (false)
-    
-#define return_f64_raw(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \
-    val->uni.u64 = ((u64)sign << 63) | (u64)(_v); \
-    *end = cur; return true; \
-} while (false)
-    
-    u64 sig, num;
-    u8 *hdr = *ptr;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    u8 *dot = NULL;
-    u8 *f64_end = NULL;
-    bool sign;
-    
-    /* read number as raw string if has flag */
-    if (unlikely(pre)) {
-        return read_number_raw(ptr, pre, ext, val, msg);
-    }
-    
-    sign = (*hdr == '-');
-    cur += sign;
-    sig = (u8)(*cur - '0');
-    
-    /* read first digit, check leading zero */
-    if (unlikely(!digi_is_digit(*cur))) {
-        if (unlikely(ext)) {
-            if (read_inf_or_nan(sign, &cur, pre, val)) {
-                *end = cur;
-                return true;
-            }
-        }
-        return_err(cur - 1, "no digit after minus sign");
-    }
-    if (*cur == '0') {
-        cur++;
-        if (unlikely(digi_is_digit(*cur))) {
-            return_err(cur - 1, "number with leading zero is not allowed");
-        }
-        if (!digi_is_fp(*cur)) return_i64(0);
-        goto read_double;
-    }
-    
-    /* read continuous digits, up to 19 characters */
-#define expr_intg(i) \
-    if (likely((num = (u64)(cur[i] - (u8)'0')) <= 9)) sig = num + sig * 10; \
-    else { cur += i; goto intg_end; }
-    repeat_in_1_18(expr_intg);
-#undef expr_intg
-    
-    /* here are 19 continuous digits, skip them */
-    cur += 19;
-    if (digi_is_digit(cur[0]) && !digi_is_digit_or_fp(cur[1])) {
-        /* this number is an integer consisting of 20 digits */
-        num = (u8)(*cur - '0');
-        if ((sig < (U64_MAX / 10)) ||
-            (sig == (U64_MAX / 10) && num <= (U64_MAX % 10))) {
-            sig = num + sig * 10;
-            cur++;
-            if (sign) return_f64(normalized_u64_to_f64(sig));
-            return_i64(sig);
-        }
-    }
-    
-intg_end:
-    /* continuous digits ended */
-    if (!digi_is_digit_or_fp(*cur)) {
-        /* this number is an integer consisting of 1 to 19 digits */
-        if (sign && (sig > ((u64)1 << 63))) {
-            return_f64(normalized_u64_to_f64(sig));
-        }
-        return_i64(sig);
-    }
-    
-read_double:
-    /* this number should be read as double */
-    while (digi_is_digit(*cur)) cur++;
-    if (*cur == '.') {
-        /* skip fraction part */
-        dot = cur;
-        cur++;
-        if (!digi_is_digit(*cur++)) {
-            return_err(cur - 1, "no digit after decimal point");
-        }
-        while (digi_is_digit(*cur)) cur++;
-    }
-    if (digi_is_exp(*cur)) {
-        /* skip exponent part */
-        cur += 1 + digi_is_sign(cur[1]);
-        if (!digi_is_digit(*cur++)) {
-            return_err(cur - 1, "no digit after exponent sign");
-        }
-        while (digi_is_digit(*cur)) cur++;
-    }
-    
-    /*
-     libc's strtod() is used to parse the floating-point number.
-     
-     Note that the decimal point character used by strtod() is locale-dependent,
-     and the rounding direction may affected by fesetround().
-     
-     For currently known locales, (en, zh, ja, ko, am, he, hi) use '.' as the
-     decimal point, while other locales use ',' as the decimal point.
-     
-     Here strtod() is called twice for different locales, but if another thread
-     happens calls setlocale() between two strtod(), parsing may still fail.
-     */
-    val->uni.f64 = strtod((const char *)hdr, (char **)&f64_end);
-    if (unlikely(f64_end != cur)) {
-        bool cut = (*cur == ',');
-        if (dot) *dot = ',';
-        if (cut) *cur = ' ';
-        val->uni.f64 = strtod((const char *)hdr, (char **)&f64_end);
-        if (cut) *cur = ',';
-        if (unlikely(f64_end != cur)) {
-            return_err(hdr, "strtod() failed to parse the number");
-        }
-    }
-    if (unlikely(val->uni.f64 == HUGE_VAL || val->uni.f64 == -HUGE_VAL)) {
-        if (!ext) {
-            return_err(hdr, "number is infinity when parsed as double");
-        }
-    }
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-    *end = cur;
-    return true;
-    
-#undef has_flag
-#undef return_err
-#undef return_i64
-#undef return_f64
-}
-
-#endif /* FP_READER */
-
-
-
-/*==============================================================================
- * JSON String Reader
- *============================================================================*/
-
-/**
- Read a JSON string.
- @param ptr The head pointer of string before '"' prefix (inout).
- @param lst JSON last position.
- @param inv Allow invalid unicode.
- @param val The string value to be written.
- @param msg The error message pointer.
- @return Whether success.
- */
-static_inline bool read_string(u8 **ptr,
-                               u8 *lst,
-                               bool inv,
-                               yyjson_val *val,
-                               const char **msg) {
-    /*
-     Each unicode code point is encoded as 1 to 4 bytes in UTF-8 encoding,
-     we use 4-byte mask and pattern value to validate UTF-8 byte sequence,
-     this requires the input data to have 4-byte zero padding.
-     ---------------------------------------------------
-     1 byte
-     unicode range [U+0000, U+007F]
-     unicode min   [.......0]
-     unicode max   [.1111111]
-     bit pattern   [0.......]
-     ---------------------------------------------------
-     2 byte
-     unicode range [U+0080, U+07FF]
-     unicode min   [......10 ..000000]
-     unicode max   [...11111 ..111111]
-     bit require   [...xxxx. ........] (1E 00)
-     bit mask      [xxx..... xx......] (E0 C0)
-     bit pattern   [110..... 10......] (C0 80)
-     ---------------------------------------------------
-     3 byte
-     unicode range [U+0800, U+FFFF]
-     unicode min   [........ ..100000 ..000000]
-     unicode max   [....1111 ..111111 ..111111]
-     bit require   [....xxxx ..x..... ........] (0F 20 00)
-     bit mask      [xxxx.... xx...... xx......] (F0 C0 C0)
-     bit pattern   [1110.... 10...... 10......] (E0 80 80)
-     ---------------------------------------------------
-     3 byte invalid (reserved for surrogate halves)
-     unicode range [U+D800, U+DFFF]
-     unicode min   [....1101 ..100000 ..000000]
-     unicode max   [....1101 ..111111 ..111111]
-     bit mask      [....xxxx ..x..... ........] (0F 20 00)
-     bit pattern   [....1101 ..1..... ........] (0D 20 00)
-     ---------------------------------------------------
-     4 byte
-     unicode range [U+10000, U+10FFFF]
-     unicode min   [........ ...10000 ..000000 ..000000]
-     unicode max   [.....100 ..001111 ..111111 ..111111]
-     bit require   [.....xxx ..xx.... ........ ........] (07 30 00 00)
-     bit mask      [xxxxx... xx...... xx...... xx......] (F8 C0 C0 C0)
-     bit pattern   [11110... 10...... 10...... 10......] (F0 80 80 80)
-     ---------------------------------------------------
-     */
-#if YYJSON_ENDIAN == YYJSON_BIG_ENDIAN
-    const u32 b1_mask = 0x80000000UL;
-    const u32 b1_patt = 0x00000000UL;
-    const u32 b2_mask = 0xE0C00000UL;
-    const u32 b2_patt = 0xC0800000UL;
-    const u32 b2_requ = 0x1E000000UL;
-    const u32 b3_mask = 0xF0C0C000UL;
-    const u32 b3_patt = 0xE0808000UL;
-    const u32 b3_requ = 0x0F200000UL;
-    const u32 b3_erro = 0x0D200000UL;
-    const u32 b4_mask = 0xF8C0C0C0UL;
-    const u32 b4_patt = 0xF0808080UL;
-    const u32 b4_requ = 0x07300000UL;
-    const u32 b4_err0 = 0x04000000UL;
-    const u32 b4_err1 = 0x03300000UL;
-#elif YYJSON_ENDIAN == YYJSON_LITTLE_ENDIAN
-    const u32 b1_mask = 0x00000080UL;
-    const u32 b1_patt = 0x00000000UL;
-    const u32 b2_mask = 0x0000C0E0UL;
-    const u32 b2_patt = 0x000080C0UL;
-    const u32 b2_requ = 0x0000001EUL;
-    const u32 b3_mask = 0x00C0C0F0UL;
-    const u32 b3_patt = 0x008080E0UL;
-    const u32 b3_requ = 0x0000200FUL;
-    const u32 b3_erro = 0x0000200DUL;
-    const u32 b4_mask = 0xC0C0C0F8UL;
-    const u32 b4_patt = 0x808080F0UL;
-    const u32 b4_requ = 0x00003007UL;
-    const u32 b4_err0 = 0x00000004UL;
-    const u32 b4_err1 = 0x00003003UL;
-#else
-    v32_uni b1_mask_uni = {{ 0x80, 0x00, 0x00, 0x00 }};
-    v32_uni b1_patt_uni = {{ 0x00, 0x00, 0x00, 0x00 }};
-    v32_uni b2_mask_uni = {{ 0xE0, 0xC0, 0x00, 0x00 }};
-    v32_uni b2_patt_uni = {{ 0xC0, 0x80, 0x00, 0x00 }};
-    v32_uni b2_requ_uni = {{ 0x1E, 0x00, 0x00, 0x00 }};
-    v32_uni b3_mask_uni = {{ 0xF0, 0xC0, 0xC0, 0x00 }};
-    v32_uni b3_patt_uni = {{ 0xE0, 0x80, 0x80, 0x00 }};
-    v32_uni b3_requ_uni = {{ 0x0F, 0x20, 0x00, 0x00 }};
-    v32_uni b3_erro_uni = {{ 0x0D, 0x20, 0x00, 0x00 }};
-    v32_uni b4_mask_uni = {{ 0xF8, 0xC0, 0xC0, 0xC0 }};
-    v32_uni b4_patt_uni = {{ 0xF0, 0x80, 0x80, 0x80 }};
-    v32_uni b4_requ_uni = {{ 0x07, 0x30, 0x00, 0x00 }};
-    v32_uni b4_err0_uni = {{ 0x04, 0x00, 0x00, 0x00 }};
-    v32_uni b4_err1_uni = {{ 0x03, 0x30, 0x00, 0x00 }};
-    u32 b1_mask = b1_mask_uni.u;
-    u32 b1_patt = b1_patt_uni.u;
-    u32 b2_mask = b2_mask_uni.u;
-    u32 b2_patt = b2_patt_uni.u;
-    u32 b2_requ = b2_requ_uni.u;
-    u32 b3_mask = b3_mask_uni.u;
-    u32 b3_patt = b3_patt_uni.u;
-    u32 b3_requ = b3_requ_uni.u;
-    u32 b3_erro = b3_erro_uni.u;
-    u32 b4_mask = b4_mask_uni.u;
-    u32 b4_patt = b4_patt_uni.u;
-    u32 b4_requ = b4_requ_uni.u;
-    u32 b4_err0 = b4_err0_uni.u;
-    u32 b4_err1 = b4_err1_uni.u;
-#endif
-    
-#define is_valid_seq_1(uni) ( \
-    ((uni & b1_mask) == b1_patt) \
-)
-
-#define is_valid_seq_2(uni) ( \
-    ((uni & b2_mask) == b2_patt) && \
-    ((uni & b2_requ)) \
-)
-    
-#define is_valid_seq_3(uni) ( \
-    ((uni & b3_mask) == b3_patt) && \
-    ((tmp = (uni & b3_requ))) && \
-    ((tmp != b3_erro)) \
-)
-    
-#define is_valid_seq_4(uni) ( \
-    ((uni & b4_mask) == b4_patt) && \
-    ((tmp = (uni & b4_requ))) && \
-    ((tmp & b4_err0) == 0 || (tmp & b4_err1) == 0) \
-)
-    
-#define return_err(_end, _msg) do { \
-    *msg = _msg; \
-    *end = _end; \
-    return false; \
-} while (false)
-    
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    u8 *src = ++cur, *dst, *pos;
-    u16 hi, lo;
-    u32 uni, tmp;
-    
-skip_ascii:
-    /* Most strings have no escaped characters, so we can jump them quickly. */
-    
-skip_ascii_begin:
-    /*
-     We want to make loop unrolling, as shown in the following code. Some
-     compiler may not generate instructions as expected, so we rewrite it with
-     explicit goto statements. We hope the compiler can generate instructions
-     like this: https://godbolt.org/z/8vjsYq
-     
-         while (true) repeat16({
-            if (likely(!(char_is_ascii_stop(*src)))) src++;
-            else break;
-         });
-     */
-#define expr_jump(i) \
-    if (likely(!char_is_ascii_stop(src[i]))) {} \
-    else goto skip_ascii_stop##i;
-    
-#define expr_stop(i) \
-    skip_ascii_stop##i: \
-    src += i; \
-    goto skip_ascii_end;
-    
-    repeat16_incr(expr_jump);
-    src += 16;
-    goto skip_ascii_begin;
-    repeat16_incr(expr_stop);
-    
-#undef expr_jump
-#undef expr_stop
-    
-skip_ascii_end:
-    
-    /*
-     GCC may store src[i] in a register at each line of expr_jump(i) above.
-     These instructions are useless and will degrade performance.
-     This inline asm is a hint for gcc: "the memory has been modified,
-     do not cache it".
-     
-     MSVC, Clang, ICC can generate expected instructions without this hint.
-     */
-#if YYJSON_IS_REAL_GCC
-    __asm volatile("":"=m"(*src)::);
-#endif
-    if (likely(*src == '"')) {
-        val->tag = ((u64)(src - cur) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = (const char *)cur;
-        *src = '\0';
-        *end = src + 1;
-        return true;
-    }
-    
-skip_utf8:
-    if (*src & 0x80) { /* non-ASCII character */
-        /*
-         Non-ASCII character appears here, which means that the text is likely
-         to be written in non-English or emoticons. According to some common
-         data set statistics, byte sequences of the same length may appear
-         consecutively. We process the byte sequences of the same length in each
-         loop, which is more friendly to branch prediction.
-         */
-        pos = src;
-        uni = byte_load_4(src);
-        while (is_valid_seq_3(uni)) {
-            src += 3;
-            uni = byte_load_4(src);
-        }
-        if (is_valid_seq_1(uni)) goto skip_ascii;
-        while (is_valid_seq_2(uni)) {
-            src += 2;
-            uni = byte_load_4(src);
-        }
-        while (is_valid_seq_4(uni)) {
-            src += 4;
-            uni = byte_load_4(src);
-        }
-        if (unlikely(pos == src)) {
-            if (!inv) return_err(src, "invalid UTF-8 encoding in string");
-            ++src;
-        }
-        goto skip_ascii;
-    }
-    
-    /* The escape character appears, we need to copy it. */
-    dst = src;
-copy_escape:
-    if (likely(*src == '\\')) {
-        switch (*++src) {
-            case '"':  *dst++ = '"';  src++; break;
-            case '\\': *dst++ = '\\'; src++; break;
-            case '/':  *dst++ = '/';  src++; break;
-            case 'b':  *dst++ = '\b'; src++; break;
-            case 'f':  *dst++ = '\f'; src++; break;
-            case 'n':  *dst++ = '\n'; src++; break;
-            case 'r':  *dst++ = '\r'; src++; break;
-            case 't':  *dst++ = '\t'; src++; break;
-            case 'u':
-                if (unlikely(!read_hex_u16(++src, &hi))) {
-                    return_err(src - 2, "invalid escaped unicode in string");
-                }
-                src += 4;
-                if (likely((hi & 0xF800) != 0xD800)) {
-                    /* a BMP character */
-                    if (hi >= 0x800) {
-                        *dst++ = (u8)(0xE0 | (hi >> 12));
-                        *dst++ = (u8)(0x80 | ((hi >> 6) & 0x3F));
-                        *dst++ = (u8)(0x80 | (hi & 0x3F));
-                    } else if (hi >= 0x80) {
-                        *dst++ = (u8)(0xC0 | (hi >> 6));
-                        *dst++ = (u8)(0x80 | (hi & 0x3F));
-                    } else {
-                        *dst++ = (u8)hi;
-                    }
-                } else {
-                    /* a non-BMP character, represented as a surrogate pair */
-                    if (unlikely((hi & 0xFC00) != 0xD800)) {
-                        return_err(src - 6, "invalid high surrogate in string");
-                    }
-                    if (unlikely(!byte_match_2(src, "\\u")) ||
-                        unlikely(!read_hex_u16(src + 2, &lo))) {
-                        return_err(src, "no matched low surrogate in string");
-                    }
-                    if (unlikely((lo & 0xFC00) != 0xDC00)) {
-                        return_err(src, "invalid low surrogate in string");
-                    }
-                    uni = ((((u32)hi - 0xD800) << 10) |
-                            ((u32)lo - 0xDC00)) + 0x10000;
-                    *dst++ = (u8)(0xF0 | (uni >> 18));
-                    *dst++ = (u8)(0x80 | ((uni >> 12) & 0x3F));
-                    *dst++ = (u8)(0x80 | ((uni >> 6) & 0x3F));
-                    *dst++ = (u8)(0x80 | (uni & 0x3F));
-                    src += 6;
-                }
-                break;
-            default: return_err(src, "invalid escaped character in string");
-        }
-    } else if (likely(*src == '"')) {
-        val->tag = ((u64)(dst - cur) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = (const char *)cur;
-        *dst = '\0';
-        *end = src + 1;
-        return true;
-    } else {
-        if (!inv) return_err(src, "unexpected control character in string");
-        if (src >= lst) return_err(src, "unclosed string");
-        *dst++ = *src++;
-    }
-    
-copy_ascii:
-    /*
-     Copy continuous ASCII, loop unrolling, same as the following code:
-     
-         while (true) repeat16({
-            if (unlikely(char_is_ascii_stop(*src))) break;
-            *dst++ = *src++;
-         });
-     */
-#if YYJSON_IS_REAL_GCC
-#   define expr_jump(i) \
-    if (likely(!(char_is_ascii_stop(src[i])))) {} \
-    else { __asm volatile("":"=m"(src[i])::); goto copy_ascii_stop_##i; }
-#else
-#   define expr_jump(i) \
-    if (likely(!(char_is_ascii_stop(src[i])))) {} \
-    else { goto copy_ascii_stop_##i; }
-#endif
-    repeat16_incr(expr_jump);
-#undef expr_jump
-    
-    byte_move_16(dst, src);
-    src += 16;
-    dst += 16;
-    goto copy_ascii;
-    
-copy_ascii_stop_0:
-    goto copy_utf8;
-copy_ascii_stop_1:
-    byte_move_2(dst, src);
-    src += 1;
-    dst += 1;
-    goto copy_utf8;
-copy_ascii_stop_2:
-    byte_move_2(dst, src);
-    src += 2;
-    dst += 2;
-    goto copy_utf8;
-copy_ascii_stop_3:
-    byte_move_4(dst, src);
-    src += 3;
-    dst += 3;
-    goto copy_utf8;
-copy_ascii_stop_4:
-    byte_move_4(dst, src);
-    src += 4;
-    dst += 4;
-    goto copy_utf8;
-copy_ascii_stop_5:
-    byte_move_4(dst, src);
-    byte_move_2(dst + 4, src + 4);
-    src += 5;
-    dst += 5;
-    goto copy_utf8;
-copy_ascii_stop_6:
-    byte_move_4(dst, src);
-    byte_move_2(dst + 4, src + 4);
-    src += 6;
-    dst += 6;
-    goto copy_utf8;
-copy_ascii_stop_7:
-    byte_move_8(dst, src);
-    src += 7;
-    dst += 7;
-    goto copy_utf8;
-copy_ascii_stop_8:
-    byte_move_8(dst, src);
-    src += 8;
-    dst += 8;
-    goto copy_utf8;
-copy_ascii_stop_9:
-    byte_move_8(dst, src);
-    byte_move_2(dst + 8, src + 8);
-    src += 9;
-    dst += 9;
-    goto copy_utf8;
-copy_ascii_stop_10:
-    byte_move_8(dst, src);
-    byte_move_2(dst + 8, src + 8);
-    src += 10;
-    dst += 10;
-    goto copy_utf8;
-copy_ascii_stop_11:
-    byte_move_8(dst, src);
-    byte_move_4(dst + 8, src + 8);
-    src += 11;
-    dst += 11;
-    goto copy_utf8;
-copy_ascii_stop_12:
-    byte_move_8(dst, src);
-    byte_move_4(dst + 8, src + 8);
-    src += 12;
-    dst += 12;
-    goto copy_utf8;
-copy_ascii_stop_13:
-    byte_move_8(dst, src);
-    byte_move_4(dst + 8, src + 8);
-    byte_move_2(dst + 12, src + 12);
-    src += 13;
-    dst += 13;
-    goto copy_utf8;
-copy_ascii_stop_14:
-    byte_move_8(dst, src);
-    byte_move_4(dst + 8, src + 8);
-    byte_move_2(dst + 12, src + 12);
-    src += 14;
-    dst += 14;
-    goto copy_utf8;
-copy_ascii_stop_15:
-    byte_move_16(dst, src);
-    src += 15;
-    dst += 15;
-    goto copy_utf8;
-    
-copy_utf8:
-    if (*src & 0x80) { /* non-ASCII character */
-        pos = src;
-        uni = byte_load_4(src);
-        while (is_valid_seq_3(uni)) {
-            byte_move_4(dst, &uni);
-            dst += 3;
-            src += 3;
-            uni = byte_load_4(src);
-        }
-        if (is_valid_seq_1(uni)) goto copy_ascii;
-        while (is_valid_seq_2(uni)) {
-            byte_move_2(dst, &uni);
-            dst += 2;
-            src += 2;
-            uni = byte_load_4(src);
-        }
-        while (is_valid_seq_4(uni)) {
-            byte_move_4(dst, &uni);
-            dst += 4;
-            src += 4;
-            uni = byte_load_4(src);
-        }
-        if (unlikely(pos == src)) {
-            if (!inv) return_err(src, "invalid UTF-8 encoding in string");
-            goto copy_ascii_stop_1;
-        }
-        goto copy_ascii;
-    }
-    goto copy_escape;
-    
-#undef return_err
-#undef is_valid_seq_1
-#undef is_valid_seq_2
-#undef is_valid_seq_3
-#undef is_valid_seq_4
-}
-
-
-
-/*==============================================================================
- * JSON Reader Implementation
- *
- * We use goto statements to build the finite state machine (FSM).
- * The FSM's state was held by program counter (PC) and the 'goto' make the
- * state transitions.
- *============================================================================*/
-
-/** Read single value JSON document. */
-static_noinline yyjson_doc *read_root_single(u8 *hdr,
-                                             u8 *cur,
-                                             u8 *end,
-                                             yyjson_alc alc,
-                                             yyjson_read_flag flg,
-                                             yyjson_read_err *err) {
-    
-#define has_flag(_flag) unlikely((flg & YYJSON_READ_##_flag) != 0)
-    
-#define return_err(_pos, _code, _msg) do { \
-    if (_pos >= end) { \
-        err->pos = (usize)(end - hdr); \
-        err->code = YYJSON_READ_ERROR_UNEXPECTED_END; \
-        err->msg = "unexpected end of data"; \
-    } else { \
-        err->pos = (usize)(_pos - hdr); \
-        err->code = YYJSON_READ_ERROR_##_code; \
-        err->msg = _msg; \
-    } \
-    if (val_hdr) alc.free(alc.ctx, (void *)val_hdr); \
-    return NULL; \
-} while (false)
-    
-    usize hdr_len; /* value count used by doc */
-    usize alc_num; /* value count capacity */
-    yyjson_val *val_hdr; /* the head of allocated values */
-    yyjson_val *val; /* current value */
-    yyjson_doc *doc; /* the JSON document, equals to val_hdr */
-    const char *msg; /* error message */
-    
-    bool raw; /* read number as raw */
-    bool ext; /* allow inf and nan */
-    bool inv; /* allow invalid unicode */
-    u8 *raw_end; /* raw end for null-terminator */
-    u8 **pre; /* previous raw end pointer */
-    
-    hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val);
-    hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0;
-    alc_num = hdr_len + 1; /* single value */
-    
-    val_hdr = (yyjson_val *)alc.malloc(alc.ctx, alc_num * sizeof(yyjson_val));
-    if (unlikely(!val_hdr)) goto fail_alloc;
-    val = val_hdr + hdr_len;
-    raw = (flg & YYJSON_READ_NUMBER_AS_RAW) != 0;
-    ext = (flg & YYJSON_READ_ALLOW_INF_AND_NAN) != 0;
-    inv = (flg & YYJSON_READ_ALLOW_INVALID_UNICODE) != 0;
-    raw_end = NULL;
-    pre = raw ? &raw_end : NULL;
-    
-    if (char_is_number(*cur)) {
-        if (likely(read_number(&cur, pre, ext, val, &msg))) goto doc_end;
-        goto fail_number;
-    }
-    if (*cur == '"') {
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto doc_end;
-        goto fail_string;
-    }
-    if (*cur == 't') {
-        if (likely(read_true(&cur, val))) goto doc_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        if (likely(read_false(&cur, val))) goto doc_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        if (likely(read_null(&cur, val))) goto doc_end;
-        if (unlikely(ext)) {
-            if (read_nan(false, &cur, pre, val)) goto doc_end;
-        }
-        goto fail_literal;
-    }
-    if (unlikely(ext)) {
-        if (read_inf_or_nan(false, &cur, pre, val)) goto doc_end;
-    }
-    goto fail_character;
-    
-doc_end:
-    /* check invalid contents after json document */
-    if (unlikely(cur < end) && !has_flag(STOP_WHEN_DONE)) {
-        if (has_flag(ALLOW_COMMENTS)) {
-            if (!skip_spaces_and_comments(&cur)) {
-                if (byte_match_2(cur, "/*")) goto fail_comment;
-            }
-        } else {
-            while (char_is_space(*cur)) cur++;
-        }
-        if (unlikely(cur < end)) goto fail_garbage;
-    }
-    
-    if (pre && *pre) **pre = '\0';
-    doc = (yyjson_doc *)val_hdr;
-    doc->root = val_hdr + hdr_len;
-    doc->alc = alc;
-    doc->dat_read = (usize)(cur - hdr);
-    doc->val_read = 1;
-    doc->str_pool = has_flag(INSITU) ? NULL : (char *)hdr;
-    return doc;
-    
-fail_string:
-    return_err(cur, INVALID_STRING, msg);
-fail_number:
-    return_err(cur, INVALID_NUMBER, msg);
-fail_alloc:
-    return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
-fail_literal:
-    return_err(cur, LITERAL, "invalid literal");
-fail_comment:
-    return_err(cur, INVALID_COMMENT, "unclosed multiline comment");
-fail_character:
-    return_err(cur, UNEXPECTED_CHARACTER, "unexpected character");
-fail_garbage:
-    return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document");
-    
-#undef has_flag
-#undef return_err
-}
-
-/** Read JSON document (accept all style, but optimized for minify). */
-static_inline yyjson_doc *read_root_minify(u8 *hdr,
-                                           u8 *cur,
-                                           u8 *end,
-                                           yyjson_alc alc,
-                                           yyjson_read_flag flg,
-                                           yyjson_read_err *err) {
-    
-#define has_flag(_flag) unlikely((flg & YYJSON_READ_##_flag) != 0)
-    
-#define return_err(_pos, _code, _msg) do { \
-    if (_pos >= end) { \
-        err->pos = (usize)(end - hdr); \
-        err->code = YYJSON_READ_ERROR_UNEXPECTED_END; \
-        err->msg = "unexpected end of data"; \
-    } else { \
-        err->pos = (usize)(_pos - hdr); \
-        err->code = YYJSON_READ_ERROR_##_code; \
-        err->msg = _msg; \
-    } \
-    if (val_hdr) alc.free(alc.ctx, (void *)val_hdr); \
-    return NULL; \
-} while (false)
-    
-#define val_incr() do { \
-    val++; \
-    if (unlikely(val >= val_end)) { \
-        alc_len += alc_len / 2; \
-        if ((alc_len >= alc_max)) goto fail_alloc; \
-        val_tmp = (yyjson_val *)alc.realloc(alc.ctx, (void *)val_hdr, \
-            alc_len * sizeof(yyjson_val)); \
-        if ((!val_tmp)) goto fail_alloc; \
-        val = val_tmp + (usize)(val - val_hdr); \
-        ctn = val_tmp + (usize)(ctn - val_hdr); \
-        val_hdr = val_tmp; \
-        val_end = val_tmp + (alc_len - 2); \
-    } \
-} while (false)
-    
-    usize dat_len; /* data length in bytes, hint for allocator */
-    usize hdr_len; /* value count used by yyjson_doc */
-    usize alc_len; /* value count allocated */
-    usize alc_max; /* maximum value count for allocator */
-    usize ctn_len; /* the number of elements in current container */
-    yyjson_val *val_hdr; /* the head of allocated values */
-    yyjson_val *val_end; /* the end of allocated values */
-    yyjson_val *val_tmp; /* temporary pointer for realloc */
-    yyjson_val *val; /* current JSON value */
-    yyjson_val *ctn; /* current container */
-    yyjson_val *ctn_parent; /* parent of current container */
-    yyjson_doc *doc; /* the JSON document, equals to val_hdr */
-    const char *msg; /* error message */
-    
-    bool raw; /* read number as raw */
-    bool ext; /* allow inf and nan */
-    bool inv; /* allow invalid unicode */
-    u8 *raw_end; /* raw end for null-terminator */
-    u8 **pre; /* previous raw end pointer */
-    
-    dat_len = has_flag(STOP_WHEN_DONE) ? 256 : (usize)(end - cur);
-    hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val);
-    hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0;
-    alc_max = USIZE_MAX / sizeof(yyjson_val);
-    alc_len = hdr_len + (dat_len / YYJSON_READER_ESTIMATED_MINIFY_RATIO) + 4;
-    alc_len = yyjson_min(alc_len, alc_max);
-    
-    val_hdr = (yyjson_val *)alc.malloc(alc.ctx, alc_len * sizeof(yyjson_val));
-    if (unlikely(!val_hdr)) goto fail_alloc;
-    val_end = val_hdr + (alc_len - 2); /* padding for key-value pair reading */
-    val = val_hdr + hdr_len;
-    ctn = val;
-    ctn_len = 0;
-    raw = (flg & YYJSON_READ_NUMBER_AS_RAW) != 0;
-    ext = (flg & YYJSON_READ_ALLOW_INF_AND_NAN) != 0;
-    inv = (flg & YYJSON_READ_ALLOW_INVALID_UNICODE) != 0;
-    raw_end = NULL;
-    pre = raw ? &raw_end : NULL;
-    
-    if (*cur++ == '{') {
-        ctn->tag = YYJSON_TYPE_OBJ;
-        ctn->uni.ofs = 0;
-        goto obj_key_begin;
-    } else {
-        ctn->tag = YYJSON_TYPE_ARR;
-        ctn->uni.ofs = 0;
-        goto arr_val_begin;
-    }
-    
-arr_begin:
-    /* save current container */
-    ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
-               (ctn->tag & YYJSON_TAG_MASK);
-    
-    /* create a new array value, save parent container offset */
-    val_incr();
-    val->tag = YYJSON_TYPE_ARR;
-    val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn);
-    
-    /* push the new array value as current container */
-    ctn = val;
-    ctn_len = 0;
-    
-arr_val_begin:
-    if (*cur == '{') {
-        cur++;
-        goto obj_begin;
-    }
-    if (*cur == '[') {
-        cur++;
-        goto arr_begin;
-    }
-    if (char_is_number(*cur)) {
-        val_incr();
-        ctn_len++;
-        if (likely(read_number(&cur, pre, ext, val, &msg))) goto arr_val_end;
-        goto fail_number;
-    }
-    if (*cur == '"') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto arr_val_end;
-        goto fail_string;
-    }
-    if (*cur == 't') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_true(&cur, val))) goto arr_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_false(&cur, val))) goto arr_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_null(&cur, val))) goto arr_val_end;
-        if (unlikely(ext)) {
-            if (read_nan(false, &cur, pre, val)) goto arr_val_end;
-        }
-        goto fail_literal;
-    }
-    if (*cur == ']') {
-        cur++;
-        if (likely(ctn_len == 0)) goto arr_end;
-        if (has_flag(ALLOW_TRAILING_COMMAS)) goto arr_end;
-        goto fail_trailing_comma;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto arr_val_begin;
-    }
-    if (unlikely(ext) && (*cur == 'i' || *cur == 'I' || *cur == 'N')) {
-        val_incr();
-        ctn_len++;
-        if (read_inf_or_nan(false, &cur, pre, val)) goto arr_val_end;
-        goto fail_character;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto arr_val_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-arr_val_end:
-    if (*cur == ',') {
-        cur++;
-        goto arr_val_begin;
-    }
-    if (*cur == ']') {
-        cur++;
-        goto arr_end;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto arr_val_end;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto arr_val_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-arr_end:
-    /* get parent container */
-    ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
-    
-    /* save the next sibling value offset */
-    ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val);
-    ctn->tag = ((ctn_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR;
-    if (unlikely(ctn == ctn_parent)) goto doc_end;
-    
-    /* pop parent as current container */
-    ctn = ctn_parent;
-    ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT);
-    if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) {
-        goto obj_val_end;
-    } else {
-        goto arr_val_end;
-    }
-    
-obj_begin:
-    /* push container */
-    ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
-               (ctn->tag & YYJSON_TAG_MASK);
-    val_incr();
-    val->tag = YYJSON_TYPE_OBJ;
-    /* offset to the parent */
-    val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn);
-    ctn = val;
-    ctn_len = 0;
-    
-obj_key_begin:
-    if (likely(*cur == '"')) {
-        val_incr();
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_key_end;
-        goto fail_string;
-    }
-    if (likely(*cur == '}')) {
-        cur++;
-        if (likely(ctn_len == 0)) goto obj_end;
-        if (has_flag(ALLOW_TRAILING_COMMAS)) goto obj_end;
-        goto fail_trailing_comma;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_key_begin;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_key_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-obj_key_end:
-    if (*cur == ':') {
-        cur++;
-        goto obj_val_begin;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_key_end;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_key_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-obj_val_begin:
-    if (*cur == '"') {
-        val++;
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_val_end;
-        goto fail_string;
-    }
-    if (char_is_number(*cur)) {
-        val++;
-        ctn_len++;
-        if (likely(read_number(&cur, pre, ext, val, &msg))) goto obj_val_end;
-        goto fail_number;
-    }
-    if (*cur == '{') {
-        cur++;
-        goto obj_begin;
-    }
-    if (*cur == '[') {
-        cur++;
-        goto arr_begin;
-    }
-    if (*cur == 't') {
-        val++;
-        ctn_len++;
-        if (likely(read_true(&cur, val))) goto obj_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        val++;
-        ctn_len++;
-        if (likely(read_false(&cur, val))) goto obj_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        val++;
-        ctn_len++;
-        if (likely(read_null(&cur, val))) goto obj_val_end;
-        if (unlikely(ext)) {
-            if (read_nan(false, &cur, pre, val)) goto obj_val_end;
-        }
-        goto fail_literal;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_val_begin;
-    }
-    if (unlikely(ext) && (*cur == 'i' || *cur == 'I' || *cur == 'N')) {
-        val++;
-        ctn_len++;
-        if (read_inf_or_nan(false, &cur, pre, val)) goto obj_val_end;
-        goto fail_character;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_val_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-obj_val_end:
-    if (likely(*cur == ',')) {
-        cur++;
-        goto obj_key_begin;
-    }
-    if (likely(*cur == '}')) {
-        cur++;
-        goto obj_end;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_val_end;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_val_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-obj_end:
-    /* pop container */
-    ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
-    /* point to the next value */
-    ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val);
-    ctn->tag = (ctn_len << (YYJSON_TAG_BIT - 1)) | YYJSON_TYPE_OBJ;
-    if (unlikely(ctn == ctn_parent)) goto doc_end;
-    ctn = ctn_parent;
-    ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT);
-    if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) {
-        goto obj_val_end;
-    } else {
-        goto arr_val_end;
-    }
-    
-doc_end:
-    /* check invalid contents after json document */
-    if (unlikely(cur < end) && !has_flag(STOP_WHEN_DONE)) {
-        if (has_flag(ALLOW_COMMENTS)) skip_spaces_and_comments(&cur);
-        else while (char_is_space(*cur)) cur++;
-        if (unlikely(cur < end)) goto fail_garbage;
-    }
-    
-    if (pre && *pre) **pre = '\0';
-    doc = (yyjson_doc *)val_hdr;
-    doc->root = val_hdr + hdr_len;
-    doc->alc = alc;
-    doc->dat_read = (usize)(cur - hdr);
-    doc->val_read = (usize)((val - doc->root) + 1);
-    doc->str_pool = has_flag(INSITU) ? NULL : (char *)hdr;
-    return doc;
-    
-fail_string:
-    return_err(cur, INVALID_STRING, msg);
-fail_number:
-    return_err(cur, INVALID_NUMBER, msg);
-fail_alloc:
-    return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
-fail_trailing_comma:
-    return_err(cur, JSON_STRUCTURE, "trailing comma is not allowed");
-fail_literal:
-    return_err(cur, LITERAL, "invalid literal");
-fail_comment:
-    return_err(cur, INVALID_COMMENT, "unclosed multiline comment");
-fail_character:
-    return_err(cur, UNEXPECTED_CHARACTER, "unexpected character");
-fail_garbage:
-    return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document");
-    
-#undef has_flag
-#undef val_incr
-#undef return_err
-}
-
-/** Read JSON document (accept all style, but optimized for pretty). */
-static_inline yyjson_doc *read_root_pretty(u8 *hdr,
-                                           u8 *cur,
-                                           u8 *end,
-                                           yyjson_alc alc,
-                                           yyjson_read_flag flg,
-                                           yyjson_read_err *err) {
-    
-#define has_flag(_flag) unlikely((flg & YYJSON_READ_##_flag) != 0)
-    
-#define return_err(_pos, _code, _msg) do { \
-    if (_pos >= end) { \
-        err->pos = (usize)(end - hdr); \
-        err->code = YYJSON_READ_ERROR_UNEXPECTED_END; \
-        err->msg = "unexpected end of data"; \
-    } else { \
-        err->pos = (usize)(_pos - hdr); \
-        err->code = YYJSON_READ_ERROR_##_code; \
-        err->msg = _msg; \
-    } \
-    if (val_hdr) alc.free(alc.ctx, (void *)val_hdr); \
-    return NULL; \
-} while (false)
-    
-#define val_incr() do { \
-    val++; \
-    if (unlikely(val >= val_end)) { \
-        alc_len += alc_len / 2; \
-        if ((alc_len >= alc_max)) goto fail_alloc; \
-        val_tmp = (yyjson_val *)alc.realloc(alc.ctx, (void *)val_hdr, \
-            alc_len * sizeof(yyjson_val)); \
-        if ((!val_tmp)) goto fail_alloc; \
-        val = val_tmp + (usize)(val - val_hdr); \
-        ctn = val_tmp + (usize)(ctn - val_hdr); \
-        val_hdr = val_tmp; \
-        val_end = val_tmp + (alc_len - 2); \
-    } \
-} while (false)
-    
-    usize dat_len; /* data length in bytes, hint for allocator */
-    usize hdr_len; /* value count used by yyjson_doc */
-    usize alc_len; /* value count allocated */
-    usize alc_max; /* maximum value count for allocator */
-    usize ctn_len; /* the number of elements in current container */
-    yyjson_val *val_hdr; /* the head of allocated values */
-    yyjson_val *val_end; /* the end of allocated values */
-    yyjson_val *val_tmp; /* temporary pointer for realloc */
-    yyjson_val *val; /* current JSON value */
-    yyjson_val *ctn; /* current container */
-    yyjson_val *ctn_parent; /* parent of current container */
-    yyjson_doc *doc; /* the JSON document, equals to val_hdr */
-    const char *msg; /* error message */
-    
-    bool raw; /* read number as raw */
-    bool ext; /* allow inf and nan */
-    bool inv; /* allow invalid unicode */
-    u8 *raw_end; /* raw end for null-terminator */
-    u8 **pre; /* previous raw end pointer */
-    
-    dat_len = has_flag(STOP_WHEN_DONE) ? 256 : (usize)(end - cur);
-    hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val);
-    hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0;
-    alc_max = USIZE_MAX / sizeof(yyjson_val);
-    alc_len = hdr_len + (dat_len / YYJSON_READER_ESTIMATED_PRETTY_RATIO) + 4;
-    alc_len = yyjson_min(alc_len, alc_max);
-    
-    val_hdr = (yyjson_val *)alc.malloc(alc.ctx, alc_len * sizeof(yyjson_val));
-    if (unlikely(!val_hdr)) goto fail_alloc;
-    val_end = val_hdr + (alc_len - 2); /* padding for key-value pair reading */
-    val = val_hdr + hdr_len;
-    ctn = val;
-    ctn_len = 0;
-    raw = (flg & YYJSON_READ_NUMBER_AS_RAW) != 0;
-    ext = (flg & YYJSON_READ_ALLOW_INF_AND_NAN) != 0;
-    inv = (flg & YYJSON_READ_ALLOW_INVALID_UNICODE) != 0;
-    raw_end = NULL;
-    pre = raw ? &raw_end : NULL;
-    
-    if (*cur++ == '{') {
-        ctn->tag = YYJSON_TYPE_OBJ;
-        ctn->uni.ofs = 0;
-        if (*cur == '\n') cur++;
-        goto obj_key_begin;
-    } else {
-        ctn->tag = YYJSON_TYPE_ARR;
-        ctn->uni.ofs = 0;
-        if (*cur == '\n') cur++;
-        goto arr_val_begin;
-    }
-    
-arr_begin:
-    /* save current container */
-    ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
-               (ctn->tag & YYJSON_TAG_MASK);
-    
-    /* create a new array value, save parent container offset */
-    val_incr();
-    val->tag = YYJSON_TYPE_ARR;
-    val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn);
-    
-    /* push the new array value as current container */
-    ctn = val;
-    ctn_len = 0;
-    if (*cur == '\n') cur++;
-    
-arr_val_begin:
-#if YYJSON_IS_REAL_GCC
-    while (true) repeat16({
-        if (byte_match_2(cur, "  ")) cur += 2;
-        else break;
-    });
-#else
-    while (true) repeat16({
-        if (likely(byte_match_2(cur, "  "))) cur += 2;
-        else break;
-    });
-#endif
-    
-    if (*cur == '{') {
-        cur++;
-        goto obj_begin;
-    }
-    if (*cur == '[') {
-        cur++;
-        goto arr_begin;
-    }
-    if (char_is_number(*cur)) {
-        val_incr();
-        ctn_len++;
-        if (likely(read_number(&cur, pre, ext, val, &msg))) goto arr_val_end;
-        goto fail_number;
-    }
-    if (*cur == '"') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto arr_val_end;
-        goto fail_string;
-    }
-    if (*cur == 't') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_true(&cur, val))) goto arr_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_false(&cur, val))) goto arr_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_null(&cur, val))) goto arr_val_end;
-        if (unlikely(ext)) {
-            if (read_nan(false, &cur, pre, val)) goto arr_val_end;
-        }
-        goto fail_literal;
-    }
-    if (*cur == ']') {
-        cur++;
-        if (likely(ctn_len == 0)) goto arr_end;
-        if (has_flag(ALLOW_TRAILING_COMMAS)) goto arr_end;
-        goto fail_trailing_comma;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto arr_val_begin;
-    }
-    if (unlikely(ext) && (*cur == 'i' || *cur == 'I' || *cur == 'N')) {
-        val_incr();
-        ctn_len++;
-        if (read_inf_or_nan(false, &cur, pre, val)) goto arr_val_end;
-        goto fail_character;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto arr_val_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-arr_val_end:
-    if (byte_match_2(cur, ",\n")) {
-        cur += 2;
-        goto arr_val_begin;
-    }
-    if (*cur == ',') {
-        cur++;
-        goto arr_val_begin;
-    }
-    if (*cur == ']') {
-        cur++;
-        goto arr_end;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto arr_val_end;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto arr_val_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-arr_end:
-    /* get parent container */
-    ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
-    
-    /* save the next sibling value offset */
-    ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val);
-    ctn->tag = ((ctn_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR;
-    if (unlikely(ctn == ctn_parent)) goto doc_end;
-    
-    /* pop parent as current container */
-    ctn = ctn_parent;
-    ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT);
-    if (*cur == '\n') cur++;
-    if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) {
-        goto obj_val_end;
-    } else {
-        goto arr_val_end;
-    }
-    
-obj_begin:
-    /* push container */
-    ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
-               (ctn->tag & YYJSON_TAG_MASK);
-    val_incr();
-    val->tag = YYJSON_TYPE_OBJ;
-    /* offset to the parent */
-    val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn);
-    ctn = val;
-    ctn_len = 0;
-    if (*cur == '\n') cur++;
-    
-obj_key_begin:
-#if YYJSON_IS_REAL_GCC
-    while (true) repeat16({
-        if (byte_match_2(cur, "  ")) cur += 2;
-        else break;
-    });
-#else
-    while (true) repeat16({
-        if (likely(byte_match_2(cur, "  "))) cur += 2;
-        else break;
-    });
-#endif
-    if (likely(*cur == '"')) {
-        val_incr();
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_key_end;
-        goto fail_string;
-    }
-    if (likely(*cur == '}')) {
-        cur++;
-        if (likely(ctn_len == 0)) goto obj_end;
-        if (has_flag(ALLOW_TRAILING_COMMAS)) goto obj_end;
-        goto fail_trailing_comma;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_key_begin;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_key_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-obj_key_end:
-    if (byte_match_2(cur, ": ")) {
-        cur += 2;
-        goto obj_val_begin;
-    }
-    if (*cur == ':') {
-        cur++;
-        goto obj_val_begin;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_key_end;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_key_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-obj_val_begin:
-    if (*cur == '"') {
-        val++;
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_val_end;
-        goto fail_string;
-    }
-    if (char_is_number(*cur)) {
-        val++;
-        ctn_len++;
-        if (likely(read_number(&cur, pre, ext, val, &msg))) goto obj_val_end;
-        goto fail_number;
-    }
-    if (*cur == '{') {
-        cur++;
-        goto obj_begin;
-    }
-    if (*cur == '[') {
-        cur++;
-        goto arr_begin;
-    }
-    if (*cur == 't') {
-        val++;
-        ctn_len++;
-        if (likely(read_true(&cur, val))) goto obj_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        val++;
-        ctn_len++;
-        if (likely(read_false(&cur, val))) goto obj_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        val++;
-        ctn_len++;
-        if (likely(read_null(&cur, val))) goto obj_val_end;
-        if (unlikely(ext)) {
-            if (read_nan(false, &cur, pre, val)) goto obj_val_end;
-        }
-        goto fail_literal;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_val_begin;
-    }
-    if (unlikely(ext) && (*cur == 'i' || *cur == 'I' || *cur == 'N')) {
-        val++;
-        ctn_len++;
-        if (read_inf_or_nan(false, &cur, pre, val)) goto obj_val_end;
-        goto fail_character;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_val_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-obj_val_end:
-    if (byte_match_2(cur, ",\n")) {
-        cur += 2;
-        goto obj_key_begin;
-    }
-    if (likely(*cur == ',')) {
-        cur++;
-        goto obj_key_begin;
-    }
-    if (likely(*cur == '}')) {
-        cur++;
-        goto obj_end;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_val_end;
-    }
-    if (has_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_val_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-    
-obj_end:
-    /* pop container */
-    ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
-    /* point to the next value */
-    ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val);
-    ctn->tag = (ctn_len << (YYJSON_TAG_BIT - 1)) | YYJSON_TYPE_OBJ;
-    if (unlikely(ctn == ctn_parent)) goto doc_end;
-    ctn = ctn_parent;
-    ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT);
-    if (*cur == '\n') cur++;
-    if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) {
-        goto obj_val_end;
-    } else {
-        goto arr_val_end;
-    }
-    
-doc_end:
-    /* check invalid contents after json document */
-    if (unlikely(cur < end) && !has_flag(STOP_WHEN_DONE)) {
-        if (has_flag(ALLOW_COMMENTS)) skip_spaces_and_comments(&cur);
-        else while (char_is_space(*cur)) cur++;
-        if (unlikely(cur < end)) goto fail_garbage;
-    }
-    
-    if (pre && *pre) **pre = '\0';
-    doc = (yyjson_doc *)val_hdr;
-    doc->root = val_hdr + hdr_len;
-    doc->alc = alc;
-    doc->dat_read = (usize)(cur - hdr);
-    doc->val_read = (usize)((val - val_hdr)) - hdr_len + 1;
-    doc->str_pool = has_flag(INSITU) ? NULL : (char *)hdr;
-    return doc;
-    
-fail_string:
-    return_err(cur, INVALID_STRING, msg);
-fail_number:
-    return_err(cur, INVALID_NUMBER, msg);
-fail_alloc:
-    return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
-fail_trailing_comma:
-    return_err(cur, JSON_STRUCTURE, "trailing comma is not allowed");
-fail_literal:
-    return_err(cur, LITERAL, "invalid literal");
-fail_comment:
-    return_err(cur, INVALID_COMMENT, "unclosed multiline comment");
-fail_character:
-    return_err(cur, UNEXPECTED_CHARACTER, "unexpected character");
-fail_garbage:
-    return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document");
-    
-#undef has_flag
-#undef val_incr
-#undef return_err
-}
-
-
-
-/*==============================================================================
- * JSON Reader Entrance
- *============================================================================*/
-
-yyjson_doc *yyjson_read_opts(char *dat,
-                             usize len,
-                             yyjson_read_flag flg,
-                             const yyjson_alc *alc_ptr,
-                             yyjson_read_err *err) {
-    
-#define has_flag(_flag) unlikely((flg & YYJSON_READ_##_flag) != 0)
-    
-#define return_err(_pos, _code, _msg) do { \
-    err->pos = (usize)(_pos); \
-    err->msg = _msg; \
-    err->code = YYJSON_READ_ERROR_##_code; \
-    if (!has_flag(INSITU) && hdr) alc.free(alc.ctx, (void *)hdr); \
-    return NULL; \
-} while (false)
-    
-    yyjson_read_err dummy_err;
-    yyjson_alc alc;
-    yyjson_doc *doc;
-    u8 *hdr = NULL, *end, *cur;
-    
-#if YYJSON_DISABLE_NON_STANDARD
-    flg &= ~YYJSON_READ_ALLOW_TRAILING_COMMAS;
-    flg &= ~YYJSON_READ_ALLOW_COMMENTS;
-    flg &= ~YYJSON_READ_ALLOW_INF_AND_NAN;
-    flg &= ~YYJSON_READ_ALLOW_INVALID_UNICODE;
-#endif
-    
-    /* validate input parameters */
-    if (!err) err = &dummy_err;
-    if (likely(!alc_ptr)) {
-        alc = YYJSON_DEFAULT_ALC;
-    } else {
-        alc = *alc_ptr;
-    }
-    if (unlikely(!dat)) {
-        return_err(0, INVALID_PARAMETER, "input data is NULL");
-    }
-    if (unlikely(!len)) {
-        return_err(0, INVALID_PARAMETER, "input length is 0");
-    }
-    
-    /* add 4-byte zero padding for input data if necessary */
-    if (has_flag(INSITU)) {
-        hdr = (u8 *)dat;
-        end = (u8 *)dat + len;
-        cur = (u8 *)dat;
-    } else {
-        if (unlikely(len >= USIZE_MAX - YYJSON_PADDING_SIZE)) {
-            return_err(0, MEMORY_ALLOCATION, "memory allocation failed");
-        }
-        hdr = (u8 *)alc.malloc(alc.ctx, len + YYJSON_PADDING_SIZE);
-        if (unlikely(!hdr)) {
-            return_err(0, MEMORY_ALLOCATION, "memory allocation failed");
-        }
-        end = hdr + len;
-        cur = hdr;
-        memcpy(hdr, dat, len);
-        memset(end, 0, YYJSON_PADDING_SIZE);
-    }
-    
-    /* skip empty contents before json document */
-    if (unlikely(char_is_space_or_comment(*cur))) {
-        if (has_flag(ALLOW_COMMENTS)) {
-            if (!skip_spaces_and_comments(&cur)) {
-                return_err(cur - hdr, INVALID_COMMENT,
-                           "unclosed multiline comment");
-            }
-        } else {
-            if (likely(char_is_space(*cur))) {
-                while (char_is_space(*++cur));
-            }
-        }
-        if (unlikely(cur >= end)) {
-            return_err(0, EMPTY_CONTENT, "input data is empty");
-        }
-    }
-    
-    /* read json document */
-    if (likely(char_is_container(*cur))) {
-        if (char_is_space(cur[1]) && char_is_space(cur[2])) {
-            doc = read_root_pretty(hdr, cur, end, alc, flg, err);
-        } else {
-            doc = read_root_minify(hdr, cur, end, alc, flg, err);
-        }
-    } else {
-        doc = read_root_single(hdr, cur, end, alc, flg, err);
-    }
-    
-    /* check result */
-    if (likely(doc)) {
-        memset(err, 0, sizeof(yyjson_read_err));
-    } else {
-        /* RFC 8259: JSON text MUST be encoded using UTF-8 */
-        if (err->pos == 0 && err->code != YYJSON_READ_ERROR_MEMORY_ALLOCATION) {
-            if ((hdr[0] == 0xEF && hdr[1] == 0xBB && hdr[2] == 0xBF)) {
-                err->msg = "byte order mark (BOM) is not supported";
-            } else if (len >= 4 &&
-                       ((hdr[0] == 0x00 && hdr[1] == 0x00 &&
-                         hdr[2] == 0xFE && hdr[3] == 0xFF) ||
-                        (hdr[0] == 0xFF && hdr[1] == 0xFE &&
-                         hdr[2] == 0x00 && hdr[3] == 0x00))) {
-                err->msg = "UTF-32 encoding is not supported";
-            } else if (len >= 2 &&
-                       ((hdr[0] == 0xFE && hdr[1] == 0xFF) ||
-                        (hdr[0] == 0xFF && hdr[1] == 0xFE))) {
-                err->msg = "UTF-16 encoding is not supported";
-            }
-        }
-        if (!has_flag(INSITU)) alc.free(alc.ctx, (void *)hdr);
-    }
-    return doc;
-    
-#undef has_flag
-#undef return_err
-}
-
-yyjson_doc *yyjson_read_file(const char *path,
-                             yyjson_read_flag flg,
-                             const yyjson_alc *alc_ptr,
-                             yyjson_read_err *err) {
-    
-#define return_err(_code, _msg) do { \
-    err->pos = 0; \
-    err->msg = _msg; \
-    err->code = YYJSON_READ_ERROR_##_code; \
-    if (file) fclose(file); \
-    if (buf) alc.free(alc.ctx, buf); \
-    return NULL; \
-} while (false)
-    
-    yyjson_read_err dummy_err;
-    yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC;
-    yyjson_doc *doc;
-    
-    FILE *file = NULL;
-    long file_size = 0;
-    void *buf = NULL;
-    usize buf_size = 0;
-    
-    /* validate input parameters */
-    if (!err) err = &dummy_err;
-    if (unlikely(!path)) return_err(INVALID_PARAMETER, "input path is NULL");
-    
-    /* open file */
-    file = fopen_readonly(path);
-    if (file == NULL) return_err(FILE_OPEN, "file opening failed");
-    
-    /* get file size */
-    if (fseek(file, 0, SEEK_END) == 0) file_size = ftell(file);
-    rewind(file);
-    
-    /* read file */
-    if (file_size > 0) {
-        /* read the entire file in one call */
-        buf_size = (usize)file_size + YYJSON_PADDING_SIZE;
-        buf = alc.malloc(alc.ctx, buf_size);
-        if (buf == NULL) {
-            return_err(MEMORY_ALLOCATION, "fail to alloc memory");
-        }
-        if (fread_safe(buf, (usize)file_size, file) != (usize)file_size) {
-            return_err(FILE_READ, "file reading failed");
-        }
-    } else {
-        /* failed to get file size, read it as a stream */
-        usize chunk_min = (usize)64;
-        usize chunk_max = (usize)512 * 1024 * 1024;
-        usize chunk_now = chunk_min;
-        usize read_size;
-        void *tmp;
-        
-        buf_size = YYJSON_PADDING_SIZE;
-        while (true) {
-            if (buf_size + chunk_now < buf_size) { /* overflow */
-                return_err(MEMORY_ALLOCATION, "fail to alloc memory");
-            }
-            buf_size += chunk_now;
-            if (!buf) {
-                buf = alc.malloc(alc.ctx, buf_size);
-                if (!buf) return_err(MEMORY_ALLOCATION, "fail to alloc memory");
-            } else {
-                tmp = alc.realloc(alc.ctx, buf, buf_size);
-                if (!tmp) return_err(MEMORY_ALLOCATION, "fail to alloc memory");
-                buf = tmp;
-            }
-            tmp = ((u8 *)buf) + buf_size - YYJSON_PADDING_SIZE - chunk_now;
-            read_size = fread_safe(tmp, chunk_now, file);
-            file_size += (long)read_size;
-            if (read_size != chunk_now) break;
-            
-            chunk_now *= 2;
-            if (chunk_now > chunk_max) chunk_now = chunk_max;
-        }
-    }
-    fclose(file);
-    
-    /* read JSON */
-    memset((u8 *)buf + file_size, 0, YYJSON_PADDING_SIZE);
-    flg |= YYJSON_READ_INSITU;
-    doc = yyjson_read_opts((char *)buf, (usize)file_size, flg, &alc, err);
-    if (doc) {
-        doc->str_pool = (char *)buf;
-        return doc;
-    } else {
-        alc.free(alc.ctx, buf);
-        return NULL;
-    }
-    
-#undef return_err
-}
-
-#endif /* YYJSON_DISABLE_READER */
-
-
-
-#if !YYJSON_DISABLE_WRITER
-
-/*==============================================================================
- * Integer Writer
- *
- * The maximum value of uint32_t is 4294967295 (10 digits),
- * these digits are named as 'aabbccddee' here.
- *
- * Although most compilers may convert the "division by constant value" into
- * "multiply and shift", manual conversion can still help some compilers
- * generate fewer and better instructions.
- *
- * Reference:
- * Division by Invariant Integers using Multiplication, 1994.
- * https://gmplib.org/~tege/divcnst-pldi94.pdf
- * Improved division by invariant integers, 2011.
- * https://gmplib.org/~tege/division-paper.pdf
- *============================================================================*/
-
-/** Digit table from 00 to 99. */
-yyjson_align(2)
-static const char digit_table[200] = {
-    '0', '0', '0', '1', '0', '2', '0', '3', '0', '4',
-    '0', '5', '0', '6', '0', '7', '0', '8', '0', '9',
-    '1', '0', '1', '1', '1', '2', '1', '3', '1', '4',
-    '1', '5', '1', '6', '1', '7', '1', '8', '1', '9',
-    '2', '0', '2', '1', '2', '2', '2', '3', '2', '4',
-    '2', '5', '2', '6', '2', '7', '2', '8', '2', '9',
-    '3', '0', '3', '1', '3', '2', '3', '3', '3', '4',
-    '3', '5', '3', '6', '3', '7', '3', '8', '3', '9',
-    '4', '0', '4', '1', '4', '2', '4', '3', '4', '4',
-    '4', '5', '4', '6', '4', '7', '4', '8', '4', '9',
-    '5', '0', '5', '1', '5', '2', '5', '3', '5', '4',
-    '5', '5', '5', '6', '5', '7', '5', '8', '5', '9',
-    '6', '0', '6', '1', '6', '2', '6', '3', '6', '4',
-    '6', '5', '6', '6', '6', '7', '6', '8', '6', '9',
-    '7', '0', '7', '1', '7', '2', '7', '3', '7', '4',
-    '7', '5', '7', '6', '7', '7', '7', '8', '7', '9',
-    '8', '0', '8', '1', '8', '2', '8', '3', '8', '4',
-    '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
-    '9', '0', '9', '1', '9', '2', '9', '3', '9', '4',
-    '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'
-};
-
-static_inline u8 *write_u32_len_8(u32 val, u8 *buf) {
-    u32 aa, bb, cc, dd, aabb, ccdd;                 /* 8 digits: aabbccdd */
-    aabb = (u32)(((u64)val * 109951163) >> 40);     /* (val / 10000) */
-    ccdd = val - aabb * 10000;                      /* (val % 10000) */
-    aa = (aabb * 5243) >> 19;                       /* (aabb / 100) */
-    cc = (ccdd * 5243) >> 19;                       /* (ccdd / 100) */
-    bb = aabb - aa * 100;                           /* (aabb % 100) */
-    dd = ccdd - cc * 100;                           /* (ccdd % 100) */
-    ((v16 *)buf)[0] = ((const v16 *)digit_table)[aa];
-    ((v16 *)buf)[1] = ((const v16 *)digit_table)[bb];
-    ((v16 *)buf)[2] = ((const v16 *)digit_table)[cc];
-    ((v16 *)buf)[3] = ((const v16 *)digit_table)[dd];
-    return buf + 8;
-}
-
-static_inline u8 *write_u32_len_4(u32 val, u8 *buf) {
-    u32 aa, bb;                                     /* 4 digits: aabb */
-    aa = (val * 5243) >> 19;                        /* (val / 100) */
-    bb = val - aa * 100;                            /* (val % 100) */
-    ((v16 *)buf)[0] = ((const v16 *)digit_table)[aa];
-    ((v16 *)buf)[1] = ((const v16 *)digit_table)[bb];
-    return buf + 4;
-}
-
-static_inline u8 *write_u32_len_1_8(u32 val, u8 *buf) {
-    u32 aa, bb, cc, dd, aabb, bbcc, ccdd, lz;
-    
-    if (val < 100) {                                /* 1-2 digits: aa */
-        lz = val < 10;                              /* leading zero: 0 or 1 */
-        ((v16 *)buf)[0] = *(const v16 *)(digit_table + (val * 2 + lz));
-        buf -= lz;
-        return buf + 2;
-        
-    } else if (val < 10000) {                       /* 3-4 digits: aabb */
-        aa = (val * 5243) >> 19;                    /* (val / 100) */
-        bb = val - aa * 100;                        /* (val % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        ((v16 *)buf)[0] = *(const v16 *)(digit_table + (aa * 2 + lz));
-        buf -= lz;
-        ((v16 *)buf)[1] = ((const v16 *)digit_table)[bb];
-        return buf + 4;
-        
-    } else if (val < 1000000) {                     /* 5-6 digits: aabbcc */
-        aa = (u32)(((u64)val * 429497) >> 32);      /* (val / 10000) */
-        bbcc = val - aa * 10000;                    /* (val % 10000) */
-        bb = (bbcc * 5243) >> 19;                   /* (bbcc / 100) */
-        cc = bbcc - bb * 100;                       /* (bbcc % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        ((v16 *)buf)[0] = *(const v16 *)(digit_table + (aa * 2 + lz));
-        buf -= lz;
-        ((v16 *)buf)[1] = ((const v16 *)digit_table)[bb];
-        ((v16 *)buf)[2] = ((const v16 *)digit_table)[cc];
-        return buf + 6;
-        
-    } else {                                        /* 7-8 digits: aabbccdd */
-        aabb = (u32)(((u64)val * 109951163) >> 40); /* (val / 10000) */
-        ccdd = val - aabb * 10000;                  /* (val % 10000) */
-        aa = (aabb * 5243) >> 19;                   /* (aabb / 100) */
-        cc = (ccdd * 5243) >> 19;                   /* (ccdd / 100) */
-        bb = aabb - aa * 100;                       /* (aabb % 100) */
-        dd = ccdd - cc * 100;                       /* (ccdd % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        ((v16 *)buf)[0] = *(const v16 *)(digit_table + (aa * 2 + lz));
-        buf -= lz;
-        ((v16 *)buf)[1] = ((const v16 *)digit_table)[bb];
-        ((v16 *)buf)[2] = ((const v16 *)digit_table)[cc];
-        ((v16 *)buf)[3] = ((const v16 *)digit_table)[dd];
-        return buf + 8;
-    }
-}
-
-static_inline u8 *write_u64_len_5_8(u32 val, u8 *buf) {
-    u32 aa, bb, cc, dd, aabb, bbcc, ccdd, lz;
-    
-    if (val < 1000000) {                            /* 5-6 digits: aabbcc */
-        aa = (u32)(((u64)val * 429497) >> 32);      /* (val / 10000) */
-        bbcc = val - aa * 10000;                    /* (val % 10000) */
-        bb = (bbcc * 5243) >> 19;                   /* (bbcc / 100) */
-        cc = bbcc - bb * 100;                       /* (bbcc % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        ((v16 *)buf)[0] = *(const v16 *)(digit_table + (aa * 2 + lz));
-        buf -= lz;
-        ((v16 *)buf)[1] = ((const v16 *)digit_table)[bb];
-        ((v16 *)buf)[2] = ((const v16 *)digit_table)[cc];
-        return buf + 6;
-        
-    } else {                                        /* 7-8 digits: aabbccdd */
-        aabb = (u32)(((u64)val * 109951163) >> 40); /* (val / 10000) */
-        ccdd = val - aabb * 10000;                  /* (val % 10000) */
-        aa = (aabb * 5243) >> 19;                   /* (aabb / 100) */
-        cc = (ccdd * 5243) >> 19;                   /* (ccdd / 100) */
-        bb = aabb - aa * 100;                       /* (aabb % 100) */
-        dd = ccdd - cc * 100;                       /* (ccdd % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        ((v16 *)buf)[0] = *(const v16 *)(digit_table + (aa * 2 + lz));
-        buf -= lz;
-        ((v16 *)buf)[1] = ((const v16 *)digit_table)[bb];
-        ((v16 *)buf)[2] = ((const v16 *)digit_table)[cc];
-        ((v16 *)buf)[3] = ((const v16 *)digit_table)[dd];
-        return buf + 8;
-    }
-}
-
-static_inline u8 *write_u64(u64 val, u8 *buf) {
-    u64 tmp, hgh;
-    u32 mid, low;
-    
-    if (val < 100000000) {                          /* 1-8 digits */
-        buf = write_u32_len_1_8((u32)val, buf);
-        return buf;
-        
-    } else if (val < (u64)100000000 * 100000000) {  /* 9-16 digits */
-        hgh = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - hgh * 100000000);         /* (val % 100000000) */
-        buf = write_u32_len_1_8((u32)hgh, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-        
-    } else {                                        /* 17-20 digits */
-        tmp = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - tmp * 100000000);         /* (val % 100000000) */
-        hgh = (u32)(tmp / 10000);                   /* (tmp / 10000) */
-        mid = (u32)(tmp - hgh * 10000);             /* (tmp % 10000) */
-        buf = write_u64_len_5_8((u32)hgh, buf);
-        buf = write_u32_len_4(mid, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-    }
-}
-
-
-
-/*==============================================================================
- * Number Writer
- *============================================================================*/
-
-#if YYJSON_HAS_IEEE_754 && !YYJSON_DISABLE_FAST_FP_CONV  /* FP_WRITER */
-
-/** Trailing zero count table for number 0 to 99.
-    (generate with misc/make_tables.c) */
-static const u8 dec_trailing_zero_table[] = {
-    2, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
-
-/** Write an unsigned integer with a length of 1 to 16. */
-static_inline u8 *write_u64_len_1_to_16(u64 val, u8 *buf) {
-    u64 hgh;
-    u32 low;
-    if (val < 100000000) {                          /* 1-8 digits */
-        buf = write_u32_len_1_8((u32)val, buf);
-        return buf;
-    } else {                                        /* 9-16 digits */
-        hgh = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - hgh * 100000000);         /* (val % 100000000) */
-        buf = write_u32_len_1_8((u32)hgh, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-    }
-}
-
-/** Write an unsigned integer with a length of 1 to 17. */
-static_inline u8 *write_u64_len_1_to_17(u64 val, u8 *buf) {
-    u64 hgh;
-    u32 mid, low, one;
-    if (val >= (u64)100000000 * 10000000) {         /* len: 16 to 17 */
-        hgh = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - hgh * 100000000);         /* (val % 100000000) */
-        one = (u32)(hgh / 100000000);               /* (hgh / 100000000) */
-        mid = (u32)(hgh - (u64)one * 100000000);    /* (hgh % 100000000) */
-        *buf = (u8)((u8)one + (u8)'0');
-        buf += one > 0;
-        buf = write_u32_len_8(mid, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-    } else if (val >= (u64)100000000){              /* len: 9 to 15 */
-        hgh = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - hgh * 100000000);         /* (val % 100000000) */
-        buf = write_u32_len_1_8((u32)hgh, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-    } else { /* len: 1 to 8 */
-        buf = write_u32_len_1_8((u32)val, buf);
-        return buf;
-    }
-}
-
-/**
- Write an unsigned integer with a length of 15 to 17 with trailing zero trimmed.
- These digits are named as "aabbccddeeffgghhii" here.
- For example, input 1234567890123000, output "1234567890123".
- */
-static_inline u8 *write_u64_len_15_to_17_trim(u8 *buf, u64 sig) {
-    bool lz;                                        /* leading zero */
-    u32 tz1, tz2, tz;                               /* trailing zero */
-    
-    u32 abbccddee = (u32)(sig / 100000000);
-    u32 ffgghhii = (u32)(sig - (u64)abbccddee * 100000000);
-    u32 abbcc = abbccddee / 10000;                  /* (abbccddee / 10000) */
-    u32 ddee = abbccddee - abbcc * 10000;           /* (abbccddee % 10000) */
-    u32 abb = (u32)(((u64)abbcc * 167773) >> 24);   /* (abbcc / 100) */
-    u32 a = (abb * 41) >> 12;                       /* (abb / 100) */
-    u32 bb = abb - a * 100;                         /* (abb % 100) */
-    u32 cc = abbcc - abb * 100;                     /* (abbcc % 100) */
-    
-    /* write abbcc */
-    buf[0] = (u8)(a + '0');
-    buf += a > 0;
-    lz = bb < 10 && a == 0;
-    ((v16 *)buf)[0] = *(const v16 *)(digit_table + (bb * 2 + lz));
-    buf -= lz;
-    ((v16 *)buf)[1] = ((const v16 *)digit_table)[cc];
-    
-    if (ffgghhii) {
-        u32 dd = (ddee * 5243) >> 19;               /* (ddee / 100) */
-        u32 ee = ddee - dd * 100;                   /* (ddee % 100) */
-        u32 ffgg = (u32)(((u64)ffgghhii * 109951163) >> 40); /* (val / 10000) */
-        u32 hhii = ffgghhii - ffgg * 10000;         /* (val % 10000) */
-        u32 ff = (ffgg * 5243) >> 19;               /* (aabb / 100) */
-        u32 gg = ffgg - ff * 100;                   /* (aabb % 100) */
-        ((v16 *)buf)[2] = ((const v16 *)digit_table)[dd];
-        ((v16 *)buf)[3] = ((const v16 *)digit_table)[ee];
-        ((v16 *)buf)[4] = ((const v16 *)digit_table)[ff];
-        ((v16 *)buf)[5] = ((const v16 *)digit_table)[gg];
-        if (hhii) {
-            u32 hh = (hhii * 5243) >> 19;           /* (ccdd / 100) */
-            u32 ii = hhii - hh * 100;               /* (ccdd % 100) */
-            ((v16 *)buf)[6] = ((const v16 *)digit_table)[hh];
-            ((v16 *)buf)[7] = ((const v16 *)digit_table)[ii];
-            tz1 = dec_trailing_zero_table[hh];
-            tz2 = dec_trailing_zero_table[ii];
-            tz = ii ? tz2 : (tz1 + 2);
-            buf += 16 - tz;
-            return buf;
-        } else {
-            tz1 = dec_trailing_zero_table[ff];
-            tz2 = dec_trailing_zero_table[gg];
-            tz = gg ? tz2 : (tz1 + 2);
-            buf += 12 - tz;
-            return buf;
-        }
-    } else {
-        if (ddee) {
-            u32 dd = (ddee * 5243) >> 19;           /* (ddee / 100) */
-            u32 ee = ddee - dd * 100;               /* (ddee % 100) */
-            ((v16 *)buf)[2] = ((const v16 *)digit_table)[dd];
-            ((v16 *)buf)[3] = ((const v16 *)digit_table)[ee];
-            tz1 = dec_trailing_zero_table[dd];
-            tz2 = dec_trailing_zero_table[ee];
-            tz = ee ? tz2 : (tz1 + 2);
-            buf += 8 - tz;
-            return buf;
-        } else {
-            tz1 = dec_trailing_zero_table[bb];
-            tz2 = dec_trailing_zero_table[cc];
-            tz = cc ? tz2 : (tz1 + tz2);
-            buf += 4 - tz;
-            return buf;
-        }
-    }
-}
-
-/** Write a signed integer in the range -324 to 308. */
-static_inline u8 *write_f64_exp(i32 exp, u8 *buf) {
-    buf[0] = '-';
-    buf += exp < 0;
-    exp = exp < 0 ? -exp : exp;
-    if (exp < 100) {
-        u32 lz = exp < 10;
-        *(v16 *)&buf[0] = *(const v16 *)(digit_table + ((u32)exp * 2 + lz));
-        return buf + 2 - lz;
-    } else {
-        u32 hi = ((u32)exp * 656) >> 16;            /* exp / 100 */
-        u32 lo = (u32)exp - hi * 100;               /* exp % 100 */
-        buf[0] = (u8)((u8)hi + (u8)'0');
-        *(v16 *)&buf[1] = *(const v16 *)(digit_table + (lo * 2));
-        return buf + 3;
-    }
-}
-
-/** Multiplies 128-bit integer and returns highest 64-bit rounded value. */
-static_inline u64 round_to_odd(u64 hi, u64 lo, u64 cp) {
-    u64 x_hi, x_lo, y_hi, y_lo;
-    u128_mul(cp, lo, &x_hi, &x_lo);
-    u128_mul_add(cp, hi, x_hi, &y_hi, &y_lo);
-    return y_hi | (y_lo > 1);
-}
-
-/**
- Convert double number from binary to decimal.
- The output significand is shortest decimal but may have trailing zeros.
- 
- This function use the Schubfach algorithm:
- Raffaello Giulietti, The Schubfach way to render doubles (5th version), 2022.
- https://drive.google.com/file/d/1gp5xv4CAa78SVgCeWfGqqI4FfYYYuNFb
- https://mail.openjdk.java.net/pipermail/core-libs-dev/2021-November/083536.html
- https://github.com/openjdk/jdk/pull/3402 (Java implementation)
- https://github.com/abolz/Drachennest (C++ implementation)
- 
- See also:
- Dragonbox: A New Floating-Point Binary-to-Decimal Conversion Algorithm, 2022.
- https://github.com/jk-jeon/dragonbox/blob/master/other_files/Dragonbox.pdf
- https://github.com/jk-jeon/dragonbox
- 
- @param sig_raw The raw value of significand in IEEE 754 format.
- @param exp_raw The raw value of exponent in IEEE 754 format.
- @param sig_bin The decoded value of significand in binary.
- @param exp_bin The decoded value of exponent in binary.
- @param sig_dec The output value of significand in decimal.
- @param exp_dec The output value of exponent in decimal.
- @warning The input double number should not be 0, inf, nan.
- */
-static_inline void f64_bin_to_dec(u64 sig_raw, u32 exp_raw,
-                                  u64 sig_bin, i32 exp_bin,
-                                  u64 *sig_dec, i32 *exp_dec) {
-    
-    bool is_even, regular_spacing, u_inside, w_inside, round_up;
-    u64 s, sp, cb, cbl, cbr, vb, vbl, vbr, pow10hi, pow10lo, upper, lower, mid;
-    i32 k, h, exp10;
-    
-    is_even = !(sig_bin & 1);
-    regular_spacing = (sig_raw == 0 && exp_raw > 1);
-    
-    cbl = 4 * sig_bin - 2 + regular_spacing;
-    cb  = 4 * sig_bin;
-    cbr = 4 * sig_bin + 2;
-    
-    /* exp_bin: [-1074, 971]                                                  */
-    /* k = regular_spacing ? floor(log10(pow(2, exp_bin)))                    */
-    /*                     : floor(log10(pow(2, exp_bin) * 3.0 / 4.0))        */
-    /*   = regular_spacing ? floor(exp_bin * log10(2))                        */
-    /*                     : floor(exp_bin * log10(2) + log10(3.0 / 4.0))     */
-    k = (i32)(exp_bin * 315653 - (regular_spacing ? 131237 : 0)) >> 20;
-    
-    /* k: [-324, 292]                                                         */
-    /* h = exp_bin + floor(log2(pow(10, e)))                                  */
-    /*   = exp_bin + floor(log2(10) * e)                                      */
-    exp10 = -k;
-    h = exp_bin + ((exp10 * 217707) >> 16) + 1;
-    
-    pow10_table_get_sig(exp10, &pow10hi, &pow10lo);
-    pow10lo += (exp10 < POW10_SIG_TABLE_MIN_EXACT_EXP ||
-                exp10 > POW10_SIG_TABLE_MAX_EXACT_EXP);
-    vbl = round_to_odd(pow10hi, pow10lo, cbl << h);
-    vb  = round_to_odd(pow10hi, pow10lo, cb  << h);
-    vbr = round_to_odd(pow10hi, pow10lo, cbr << h);
-    
-    lower = vbl + !is_even;
-    upper = vbr - !is_even;
-    
-    s = vb / 4;
-    if (s >= 10) {
-        sp = s / 10;
-        u_inside = (lower <= 40 * sp);
-        w_inside = (upper >= 40 * sp + 40);
-        if (u_inside != w_inside) {
-            *sig_dec = sp + w_inside;
-            *exp_dec = k + 1;
-            return;
-        }
-    }
-    
-    u_inside = (lower <= 4 * s);
-    w_inside = (upper >= 4 * s + 4);
-    
-    mid = 4 * s + 2;
-    round_up = (vb > mid) || (vb == mid && (s & 1) != 0);
-    
-    *sig_dec = s + ((u_inside != w_inside) ? w_inside : round_up);
-    *exp_dec = k;
-}
-
-/**
- Write a double number (requires 32 bytes buffer).
- 
- We follows the ECMAScript specification to print floating point numbers,
- but with the following changes:
- 1. Keep the negative sign of 0.0 to preserve input information.
- 2. Keep decimal point to indicate the number is floating point.
- 3. Remove positive sign of exponent part.
- */
-static_noinline u8 *write_f64_raw(u8 *buf, u64 raw, yyjson_write_flag flg) {
-    u64 sig_bin, sig_dec, sig_raw;
-    i32 exp_bin, exp_dec, sig_len, dot_pos, i, max;
-    u32 exp_raw, hi, lo;
-    u8 *hdr, *num_hdr, *num_end, *dot_end;
-    bool sign;
-    
-    /* decode raw bytes from IEEE-754 double format. */
-    sign = (bool)(raw >> (F64_BITS - 1));
-    sig_raw = raw & F64_SIG_MASK;
-    exp_raw = (u32)((raw & F64_EXP_MASK) >> F64_SIG_BITS);
-    
-    /* return inf and nan */
-    if (unlikely(exp_raw == ((u32)1 << F64_EXP_BITS) - 1)) {
-        if (flg & YYJSON_WRITE_INF_AND_NAN_AS_NULL) {
-            byte_copy_4(buf, "null");
-            return buf + 4;
-        } else if (flg & YYJSON_WRITE_ALLOW_INF_AND_NAN) {
-            if (sig_raw == 0) {
-                buf[0] = '-';
-                buf += sign;
-                byte_copy_8(buf, "Infinity");
-                buf += 8;
-                return buf;
-            } else {
-                byte_copy_4(buf, "NaN");
-                return buf + 3;
-            }
-        } else {
-            return NULL;
-        }
-    }
-    
-    /* add sign for all finite double value, including 0.0 and inf */
-    buf[0] = '-';
-    buf += sign;
-    hdr = buf;
-    
-    /* return zero */
-    if ((raw << 1) == 0) {
-        byte_copy_4(buf, "0.0");
-        buf += 3;
-        return buf;
-    }
-    
-    if (likely(exp_raw != 0)) {
-        /* normal number */
-        sig_bin = sig_raw | ((u64)1 << F64_SIG_BITS);
-        exp_bin = (i32)exp_raw - F64_EXP_BIAS - F64_SIG_BITS;
-        
-        /* fast path for small integer number without fraction */
-        if (-F64_SIG_BITS <= exp_bin && exp_bin <= 0) {
-            if (u64_tz_bits(sig_bin) >= (u32)-exp_bin) {
-                /* number is integer in range 1 to 0x1FFFFFFFFFFFFF */
-                sig_dec = sig_bin >> -exp_bin;
-                buf = write_u64_len_1_to_16(sig_dec, buf);
-                byte_copy_2(buf, ".0");
-                buf += 2;
-                return buf;
-            }
-        }
-        
-        /* binary to decimal */
-        f64_bin_to_dec(sig_raw, exp_raw, sig_bin, exp_bin, &sig_dec, &exp_dec);
-        
-        /* the sig length is 15 to 17 */
-        sig_len = 17;
-        sig_len -= (sig_dec < (u64)100000000 * 100000000);
-        sig_len -= (sig_dec < (u64)100000000 * 10000000);
-        
-        /* the decimal point position relative to the first digit */
-        dot_pos = sig_len + exp_dec;
-        
-        if (-6 < dot_pos && dot_pos <= 21) {
-            /* no need to write exponent part */
-            if (dot_pos <= 0) {
-                /* dot before first digit */
-                /* such as 0.1234, 0.000001234 */
-                num_hdr = hdr + (2 - dot_pos);
-                num_end = write_u64_len_15_to_17_trim(num_hdr, sig_dec);
-                hdr[0] = '0';
-                hdr[1] = '.';
-                hdr += 2;
-                max = -dot_pos;
-                for (i = 0; i < max; i++) hdr[i] = '0';
-                return num_end;
-            } else {
-                /* dot after first digit */
-                /* such as 1.234, 1234.0, 123400000000000000000.0 */
-                memset(hdr +  0, '0', 8);
-                memset(hdr +  8, '0', 8);
-                memset(hdr + 16, '0', 8);
-                num_hdr = hdr + 1;
-                num_end = write_u64_len_15_to_17_trim(num_hdr, sig_dec);
-                for (i = 0; i < dot_pos; i++) hdr[i] = hdr[i + 1];
-                hdr[dot_pos] = '.';
-                dot_end = hdr + dot_pos + 2;
-                return dot_end < num_end ? num_end : dot_end;
-            }
-        } else {
-            /* write with scientific notation */
-            /* such as 1.234e56 */
-            u8 *end = write_u64_len_15_to_17_trim(buf + 1, sig_dec);
-            end -= (end == buf + 2); /* remove '.0', e.g. 2.0e34 -> 2e134 */
-            exp_dec += sig_len - 1;
-            hdr[0] = hdr[1];
-            hdr[1] = '.';
-            end[0] = 'e';
-            buf = write_f64_exp(exp_dec, end + 1);
-            return buf;
-        }
-        
-    } else {
-        /* subnormal number */
-        sig_bin = sig_raw;
-        exp_bin = 1 - F64_EXP_BIAS - F64_SIG_BITS;
-        
-        /* binary to decimal */
-        f64_bin_to_dec(sig_raw, exp_raw, sig_bin, exp_bin, &sig_dec, &exp_dec);
-        
-        /* write significand part */
-        buf = write_u64_len_1_to_17(sig_dec, buf + 1);
-        hdr[0] = hdr[1];
-        hdr[1] = '.';
-        do {
-            buf--;
-            exp_dec++;
-        } while (*buf == '0');
-        exp_dec += (i32)(buf - hdr - 2);
-        buf += (*buf != '.');
-        buf[0] = 'e';
-        buf++;
-        
-        /* write exponent part */
-        buf[0] = '-';
-        buf++;
-        exp_dec = -exp_dec;
-        hi = ((u32)exp_dec * 656) >> 16; /* exp / 100 */
-        lo = (u32)exp_dec - hi * 100; /* exp % 100 */
-        buf[0] = (u8)((u8)hi + (u8)'0');
-        *(v16 *)&buf[1] = *(const v16 *)(digit_table + (lo * 2));
-        buf += 3;
-        return buf;
-    }
-}
-
-#else /* FP_WRITER */
-
-/** Write a double number (requires 32 bytes buffer). */
-static_noinline u8 *write_f64_raw(u8 *buf, u64 raw, yyjson_write_flag flg) {
-    /*
-     For IEEE 754, `DBL_DECIMAL_DIG` is 17 for round-trip.
-     For non-IEEE formats, 17 is used to avoid buffer overflow,
-     round-trip is not guaranteed.
-     */
-#if defined(DBL_DECIMAL_DIG)
-    int dig = DBL_DECIMAL_DIG > 17 ? 17 : DBL_DECIMAL_DIG;
-#else
-    int dig = 17;
-#endif
-    
-    /*
-     The snprintf() function is locale-dependent. For currently known locales,
-     (en, zh, ja, ko, am, he, hi) use '.' as the decimal point, while other
-     locales use ',' as the decimal point. we need to replace ',' with '.'
-     to avoid the locale setting.
-     */
-    f64 val = f64_from_raw(raw);
-#if YYJSON_MSC_VER >= 1400
-    int len = sprintf_s((char *)buf, 32, "%.*g", dig, val);
-#elif defined(snprintf) || (YYJSON_STDC_VER >= 199901L)
-    int len = snprintf((char *)buf, 32, "%.*g", dig, val);
-#else
-    int len = sprintf((char *)buf, "%.*g", dig, val);
-#endif
-    
-    u8 *cur = buf;
-    if (unlikely(len < 1)) return NULL;
-    cur += (*cur == '-');
-    if (unlikely(!digi_is_digit(*cur))) {
-        /* nan, inf, or bad output */
-        if (flg & YYJSON_WRITE_INF_AND_NAN_AS_NULL) {
-            byte_copy_4(buf, "null");
-            return buf + 4;
-        } else if (flg & YYJSON_WRITE_ALLOW_INF_AND_NAN) {
-            if (*cur == 'i') {
-                byte_copy_8(cur, "Infinity");
-                cur += 8;
-                return cur;
-            } else if (*cur == 'n') {
-                byte_copy_4(buf, "NaN");
-                return buf + 3;
-            }
-        }
-        return NULL;
-    } else {
-        /* finite number */
-        int i = 0;
-        for (; i < len; i++) {
-            if (buf[i] == ',') {
-                buf[i] = '.';
-                break;
-            }
-        }
-    }
-    return buf + len;
-}
-
-#endif /* FP_WRITER */
-
-/** Write a JSON number (requires 32 bytes buffer). */
-static_inline u8 *write_number(u8 *cur, yyjson_val *val,
-                               yyjson_write_flag flg) {
-    if (val->tag & YYJSON_SUBTYPE_REAL) {
-        u64 raw = val->uni.u64;
-        return write_f64_raw(cur, raw, flg);
-    } else {
-        u64 pos = val->uni.u64;
-        u64 neg = ~pos + 1;
-        usize sgn = ((val->tag & YYJSON_SUBTYPE_SINT) > 0) & ((i64)pos < 0);
-        *cur = '-';
-        return write_u64(sgn ? neg : pos, cur + sgn);
-    }
-}
-
-
-
-/*==============================================================================
- * String Writer
- *============================================================================*/
-
-/** Character encode type, if (type > CHAR_ENC_ERR_1) bytes = type / 2; */
-typedef u8 char_enc_type;
-#define CHAR_ENC_CPY_1  0 /* 1-byte UTF-8, copy. */
-#define CHAR_ENC_ERR_1  1 /* 1-byte UTF-8, error. */
-#define CHAR_ENC_ESC_A  2 /* 1-byte ASCII, escaped as '\x'. */
-#define CHAR_ENC_ESC_1  3 /* 1-byte UTF-8, escaped as '\uXXXX'. */
-#define CHAR_ENC_CPY_2  4 /* 2-byte UTF-8, copy. */
-#define CHAR_ENC_ESC_2  5 /* 2-byte UTF-8, escaped as '\uXXXX'. */
-#define CHAR_ENC_CPY_3  6 /* 3-byte UTF-8, copy. */
-#define CHAR_ENC_ESC_3  7 /* 3-byte UTF-8, escaped as '\uXXXX'. */
-#define CHAR_ENC_CPY_4  8 /* 4-byte UTF-8, copy. */
-#define CHAR_ENC_ESC_4  9 /* 4-byte UTF-8, escaped as '\uXXXX\uXXXX'. */
-
-/** Character encode type table: don't escape unicode, don't escape '/'.
-    (generate with misc/make_tables.c) */
-static const char_enc_type enc_table_cpy[256] = {
-    3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    8, 8, 8, 8, 8, 8, 8, 8, 1, 1, 1, 1, 1, 1, 1, 1
-};
-
-/** Character encode type table: don't escape unicode, escape '/'.
-    (generate with misc/make_tables.c) */
-static const char_enc_type enc_table_cpy_slash[256] = {
-    3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    8, 8, 8, 8, 8, 8, 8, 8, 1, 1, 1, 1, 1, 1, 1, 1
-};
-
-/** Character encode type table: escape unicode, don't escape '/'.
-    (generate with misc/make_tables.c) */
-static const char_enc_type enc_table_esc[256] = {
-    3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-    9, 9, 9, 9, 9, 9, 9, 9, 1, 1, 1, 1, 1, 1, 1, 1
-};
-
-/** Character encode type table: escape unicode, escape '/'.
-    (generate with misc/make_tables.c) */
-static const char_enc_type enc_table_esc_slash[256] = {
-    3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-    9, 9, 9, 9, 9, 9, 9, 9, 1, 1, 1, 1, 1, 1, 1, 1
-};
-
-/** Escaped hex character table: ["00" "01" "02" ... "FD" "FE" "FF"].
-    (generate with misc/make_tables.c) */
-yyjson_align(2)
-static const u8 esc_hex_char_table[512] = {
-    '0', '0', '0', '1', '0', '2', '0', '3',
-    '0', '4', '0', '5', '0', '6', '0', '7',
-    '0', '8', '0', '9', '0', 'A', '0', 'B',
-    '0', 'C', '0', 'D', '0', 'E', '0', 'F',
-    '1', '0', '1', '1', '1', '2', '1', '3',
-    '1', '4', '1', '5', '1', '6', '1', '7',
-    '1', '8', '1', '9', '1', 'A', '1', 'B',
-    '1', 'C', '1', 'D', '1', 'E', '1', 'F',
-    '2', '0', '2', '1', '2', '2', '2', '3',
-    '2', '4', '2', '5', '2', '6', '2', '7',
-    '2', '8', '2', '9', '2', 'A', '2', 'B',
-    '2', 'C', '2', 'D', '2', 'E', '2', 'F',
-    '3', '0', '3', '1', '3', '2', '3', '3',
-    '3', '4', '3', '5', '3', '6', '3', '7',
-    '3', '8', '3', '9', '3', 'A', '3', 'B',
-    '3', 'C', '3', 'D', '3', 'E', '3', 'F',
-    '4', '0', '4', '1', '4', '2', '4', '3',
-    '4', '4', '4', '5', '4', '6', '4', '7',
-    '4', '8', '4', '9', '4', 'A', '4', 'B',
-    '4', 'C', '4', 'D', '4', 'E', '4', 'F',
-    '5', '0', '5', '1', '5', '2', '5', '3',
-    '5', '4', '5', '5', '5', '6', '5', '7',
-    '5', '8', '5', '9', '5', 'A', '5', 'B',
-    '5', 'C', '5', 'D', '5', 'E', '5', 'F',
-    '6', '0', '6', '1', '6', '2', '6', '3',
-    '6', '4', '6', '5', '6', '6', '6', '7',
-    '6', '8', '6', '9', '6', 'A', '6', 'B',
-    '6', 'C', '6', 'D', '6', 'E', '6', 'F',
-    '7', '0', '7', '1', '7', '2', '7', '3',
-    '7', '4', '7', '5', '7', '6', '7', '7',
-    '7', '8', '7', '9', '7', 'A', '7', 'B',
-    '7', 'C', '7', 'D', '7', 'E', '7', 'F',
-    '8', '0', '8', '1', '8', '2', '8', '3',
-    '8', '4', '8', '5', '8', '6', '8', '7',
-    '8', '8', '8', '9', '8', 'A', '8', 'B',
-    '8', 'C', '8', 'D', '8', 'E', '8', 'F',
-    '9', '0', '9', '1', '9', '2', '9', '3',
-    '9', '4', '9', '5', '9', '6', '9', '7',
-    '9', '8', '9', '9', '9', 'A', '9', 'B',
-    '9', 'C', '9', 'D', '9', 'E', '9', 'F',
-    'A', '0', 'A', '1', 'A', '2', 'A', '3',
-    'A', '4', 'A', '5', 'A', '6', 'A', '7',
-    'A', '8', 'A', '9', 'A', 'A', 'A', 'B',
-    'A', 'C', 'A', 'D', 'A', 'E', 'A', 'F',
-    'B', '0', 'B', '1', 'B', '2', 'B', '3',
-    'B', '4', 'B', '5', 'B', '6', 'B', '7',
-    'B', '8', 'B', '9', 'B', 'A', 'B', 'B',
-    'B', 'C', 'B', 'D', 'B', 'E', 'B', 'F',
-    'C', '0', 'C', '1', 'C', '2', 'C', '3',
-    'C', '4', 'C', '5', 'C', '6', 'C', '7',
-    'C', '8', 'C', '9', 'C', 'A', 'C', 'B',
-    'C', 'C', 'C', 'D', 'C', 'E', 'C', 'F',
-    'D', '0', 'D', '1', 'D', '2', 'D', '3',
-    'D', '4', 'D', '5', 'D', '6', 'D', '7',
-    'D', '8', 'D', '9', 'D', 'A', 'D', 'B',
-    'D', 'C', 'D', 'D', 'D', 'E', 'D', 'F',
-    'E', '0', 'E', '1', 'E', '2', 'E', '3',
-    'E', '4', 'E', '5', 'E', '6', 'E', '7',
-    'E', '8', 'E', '9', 'E', 'A', 'E', 'B',
-    'E', 'C', 'E', 'D', 'E', 'E', 'E', 'F',
-    'F', '0', 'F', '1', 'F', '2', 'F', '3',
-    'F', '4', 'F', '5', 'F', '6', 'F', '7',
-    'F', '8', 'F', '9', 'F', 'A', 'F', 'B',
-    'F', 'C', 'F', 'D', 'F', 'E', 'F', 'F'
-};
-
-/** Escaped single character table. (generate with misc/make_tables.c) */
-yyjson_align(2)
-static const u8 esc_single_char_table[512] = {
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    '\\', 'b', '\\', 't', '\\', 'n', ' ', ' ',
-    '\\', 'f', '\\', 'r', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', '\\', '"', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', '\\', '/',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    '\\', '\\', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '
-};
-
-/** Returns the encode table with options. */
-static_inline const char_enc_type *get_enc_table_with_flag(
-    yyjson_read_flag flg) {
-    if (unlikely(flg & YYJSON_WRITE_ESCAPE_UNICODE)) {
-        if (unlikely(flg & YYJSON_WRITE_ESCAPE_SLASHES)) {
-            return enc_table_esc_slash;
-        } else {
-            return enc_table_esc;
-        }
-    } else {
-        if (unlikely(flg & YYJSON_WRITE_ESCAPE_SLASHES)) {
-            return enc_table_cpy_slash;
-        } else {
-            return enc_table_cpy;
-        }
-    }
-}
-
-/** Write raw string. */
-static_inline u8 *write_raw(u8 *cur, const u8 *raw, usize raw_len) {
-    memcpy(cur, raw, raw_len);
-    return cur + raw_len;
-}
-
-/**
- Write UTF-8 string (requires len * 6 + 2 bytes buffer).
- @param cur Buffer cursor.
- @param esc Escape unicode.
- @param inv Allow invalid unicode.
- @param str A UTF-8 string, null-terminator is not required.
- @param str_len Length of string in bytes.
- @param enc_table Encode type table for character.
- @return The buffer cursor after string, or NULL on invalid unicode.
- */
-static_inline u8 *write_string(u8 *cur, bool esc, bool inv,
-                               const u8 *str, usize str_len,
-                               const char_enc_type *enc_table) {
-    
-    /* UTF-8 character mask and pattern, see `read_string` for details. */
-#if YYJSON_ENDIAN == YYJSON_BIG_ENDIAN
-    const u16 b2_mask = 0xE0C0UL;
-    const u16 b2_patt = 0xC080UL;
-    const u16 b2_requ = 0x1E00UL;
-    const u32 b3_mask = 0xF0C0C000UL;
-    const u32 b3_patt = 0xE0808000UL;
-    const u32 b3_requ = 0x0F200000UL;
-    const u32 b3_erro = 0x0D200000UL;
-    const u32 b4_mask = 0xF8C0C0C0UL;
-    const u32 b4_patt = 0xF0808080UL;
-    const u32 b4_requ = 0x07300000UL;
-    const u32 b4_err0 = 0x04000000UL;
-    const u32 b4_err1 = 0x03300000UL;
-#elif YYJSON_ENDIAN == YYJSON_LITTLE_ENDIAN
-    const u16 b2_mask = 0xC0E0UL;
-    const u16 b2_patt = 0x80C0UL;
-    const u16 b2_requ = 0x001EUL;
-    const u32 b3_mask = 0x00C0C0F0UL;
-    const u32 b3_patt = 0x008080E0UL;
-    const u32 b3_requ = 0x0000200FUL;
-    const u32 b3_erro = 0x0000200DUL;
-    const u32 b4_mask = 0xC0C0C0F8UL;
-    const u32 b4_patt = 0x808080F0UL;
-    const u32 b4_requ = 0x00003007UL;
-    const u32 b4_err0 = 0x00000004UL;
-    const u32 b4_err1 = 0x00003003UL;
-#else
-    v16_uni b2_mask_uni = {{ 0xE0, 0xC0 }};
-    v16_uni b2_patt_uni = {{ 0xC0, 0x80 }};
-    v16_uni b2_requ_uni = {{ 0x1E, 0x00 }};
-    v32_uni b3_mask_uni = {{ 0xF0, 0xC0, 0xC0, 0x00 }};
-    v32_uni b3_patt_uni = {{ 0xE0, 0x80, 0x80, 0x00 }};
-    v32_uni b3_requ_uni = {{ 0x0F, 0x20, 0x00, 0x00 }};
-    v32_uni b3_erro_uni = {{ 0x0D, 0x20, 0x00, 0x00 }};
-    v32_uni b4_mask_uni = {{ 0xF8, 0xC0, 0xC0, 0xC0 }};
-    v32_uni b4_patt_uni = {{ 0xF0, 0x80, 0x80, 0x80 }};
-    v32_uni b4_requ_uni = {{ 0x07, 0x30, 0x00, 0x00 }};
-    v32_uni b4_err0_uni = {{ 0x04, 0x00, 0x00, 0x00 }};
-    v32_uni b4_err1_uni = {{ 0x03, 0x30, 0x00, 0x00 }};
-    u16 b2_mask = b2_mask_uni.u;
-    u16 b2_patt = b2_patt_uni.u;
-    u16 b2_requ = b2_requ_uni.u;
-    u32 b3_mask = b3_mask_uni.u;
-    u32 b3_patt = b3_patt_uni.u;
-    u32 b3_requ = b3_requ_uni.u;
-    u32 b3_erro = b3_erro_uni.u;
-    u32 b4_mask = b4_mask_uni.u;
-    u32 b4_patt = b4_patt_uni.u;
-    u32 b4_requ = b4_requ_uni.u;
-    u32 b4_err0 = b4_err0_uni.u;
-    u32 b4_err1 = b4_err1_uni.u;
-#endif
-    
-#define is_valid_seq_2(uni) ( \
-    ((uni & b2_mask) == b2_patt) && \
-    ((uni & b2_requ)) \
-)
-    
-#define is_valid_seq_3(uni) ( \
-    ((uni & b3_mask) == b3_patt) && \
-    ((tmp = (uni & b3_requ))) && \
-    ((tmp != b3_erro)) \
-)
-    
-#define is_valid_seq_4(uni) ( \
-    ((uni & b4_mask) == b4_patt) && \
-    ((tmp = (uni & b4_requ))) && \
-    ((tmp & b4_err0) == 0 || (tmp & b4_err1) == 0) \
-)
-    
-    /* The replacement character U+FFFD, used to indicate invalid character. */
-    const v32 rep = { 'F', 'F', 'F', 'D' };
-    const v32 pre = { '\\', 'u', '0', '0' };
-    
-    const u8 *src = str;
-    const u8 *end = str + str_len;
-    *cur++ = '"';
-    
-copy_ascii:
-    /*
-     Copy continuous ASCII, loop unrolling, same as the following code:
-     
-         while (end > src) (
-            if (unlikely(enc_table[*src])) break;
-            *cur++ = *src++;
-         );
-     */
-#define expr_jump(i) \
-    if (unlikely(enc_table[src[i]])) goto stop_char_##i;
-    
-#define expr_stop(i) \
-    stop_char_##i: \
-    memcpy(cur, src, i); \
-    cur += i; src += i; goto copy_utf8;
-    
-    while (end - src >= 16) {
-        repeat16_incr(expr_jump);
-        byte_copy_16(cur, src);
-        cur += 16; src += 16;
-    }
-    
-    while (end - src >= 4) {
-        repeat4_incr(expr_jump);
-        byte_copy_4(cur, src);
-        cur += 4; src += 4;
-    }
-    
-    while (end > src) {
-        expr_jump(0);
-        *cur++ = *src++;
-    }
-    
-    *cur++ = '"';
-    return cur;
-    
-    repeat16_incr(expr_stop);
-    
-#undef expr_jump
-#undef expr_stop
-    
-copy_utf8:
-    if (unlikely(src + 4 > end)) {
-        if (end == src) goto copy_end;
-        if (end - src < enc_table[*src] / 2) goto err_one;
-    }
-    switch (enc_table[*src]) {
-        case CHAR_ENC_CPY_1: {
-            *cur++ = *src++;
-            goto copy_ascii;
-        }
-        case CHAR_ENC_CPY_2: {
-            u16 v;
-            v = byte_load_2(src);
-            if (unlikely(!is_valid_seq_2(v))) goto err_cpy;
-            
-            byte_copy_2(cur, src);
-            cur += 2;
-            src += 2;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_CPY_3: {
-            u32 v, tmp;
-            if (likely(src + 4 <= end)) {
-                v = byte_load_4(src);
-                if (unlikely(!is_valid_seq_3(v))) goto err_cpy;
-                byte_copy_4(cur, src);
-            } else {
-                v = byte_load_3(src);
-                if (unlikely(!is_valid_seq_3(v))) goto err_cpy;
-                byte_copy_4(cur, &v);
-            }
-            cur += 3;
-            src += 3;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_CPY_4: {
-            u32 v, tmp;
-            v = byte_load_4(src);
-            if (unlikely(!is_valid_seq_4(v))) goto err_cpy;
-            
-            byte_copy_4(cur, src);
-            cur += 4;
-            src += 4;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_A: {
-            byte_move_2(cur, &esc_single_char_table[*src * 2]);
-            cur += 2;
-            src += 1;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_1: {
-            byte_copy_4(cur + 0, &pre);
-            byte_copy_2(cur + 4, &esc_hex_char_table[*src * 2]);
-            cur += 6;
-            src += 1;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_2: {
-            u16 u, v;
-            v = byte_load_2(src);
-            if (unlikely(!is_valid_seq_2(v))) goto err_esc;
-            
-            u = (u16)(((u16)(src[0] & 0x1F) << 6) |
-                      ((u16)(src[1] & 0x3F) << 0));
-            byte_copy_2(cur + 0, &pre);
-            byte_copy_2(cur + 2, &esc_hex_char_table[(u >> 8) * 2]);
-            byte_copy_2(cur + 4, &esc_hex_char_table[(u & 0xFF) * 2]);
-            cur += 6;
-            src += 2;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_3: {
-            u16 u;
-            u32 v, tmp;
-            v = byte_load_3(src);
-            if (unlikely(!is_valid_seq_3(v))) goto err_esc;
-            
-            u = (u16)(((u16)(src[0] & 0x0F) << 12) |
-                      ((u16)(src[1] & 0x3F) << 6) |
-                      ((u16)(src[2] & 0x3F) << 0));
-            byte_copy_2(cur + 0, &pre);
-            byte_copy_2(cur + 2, &esc_hex_char_table[(u >> 8) * 2]);
-            byte_copy_2(cur + 4, &esc_hex_char_table[(u & 0xFF) * 2]);
-            cur += 6;
-            src += 3;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_4: {
-            u32 hi, lo, u, v, tmp;
-            v = byte_load_4(src);
-            if (unlikely(!is_valid_seq_4(v))) goto err_esc;
-            
-            u = ((u32)(src[0] & 0x07) << 18) |
-                ((u32)(src[1] & 0x3F) << 12) |
-                ((u32)(src[2] & 0x3F) << 6) |
-                ((u32)(src[3] & 0x3F) << 0);
-            u -= 0x10000;
-            hi = (u >> 10) + 0xD800;
-            lo = (u & 0x3FF) + 0xDC00;
-            byte_copy_2(cur + 0, &pre);
-            byte_copy_2(cur + 2, &esc_hex_char_table[(hi >> 8) * 2]);
-            byte_copy_2(cur + 4, &esc_hex_char_table[(hi & 0xFF) * 2]);
-            byte_copy_2(cur + 6, &pre);
-            byte_copy_2(cur + 8, &esc_hex_char_table[(lo >> 8) * 2]);
-            byte_copy_2(cur + 10, &esc_hex_char_table[(lo & 0xFF) * 2]);
-            cur += 12;
-            src += 4;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ERR_1: {
-            goto err_one;
-        }
-        default: break;
-    }
-    
-copy_end:
-    *cur++ = '"';
-    return cur;
-    
-err_one:
-    if (esc) goto err_esc;
-    else goto err_cpy;
-    
-err_cpy:
-    if (!inv) return NULL;
-    *cur++ = *src++;
-    goto copy_utf8;
-    
-err_esc:
-    if (!inv) return NULL;
-    byte_copy_2(cur + 0, &pre);
-    byte_copy_4(cur + 2, &rep);
-    cur += 6;
-    src += 1;
-    goto copy_utf8;
-    
-#undef is_valid_seq_2
-#undef is_valid_seq_3
-#undef is_valid_seq_4
-}
-
-
-
-/*==============================================================================
- * Writer Utilities
- *============================================================================*/
-
-/** Write null (requires 8 bytes buffer). */
-static_inline u8 *write_null(u8 *cur) {
-    v64 v = { 'n', 'u', 'l', 'l', ',', '\n', 0, 0 };
-    byte_copy_8(cur, &v);
-    return cur + 4;
-}
-
-/** Write bool (requires 8 bytes buffer). */
-static_inline u8 *write_bool(u8 *cur, bool val) {
-    v64 v0 = { 'f', 'a', 'l', 's', 'e', ',', '\n', 0 };
-    v64 v1 = { 't', 'r', 'u', 'e', ',', '\n', 0, 0 };
-    if (val) {
-        byte_copy_8(cur, &v1);
-    } else {
-        byte_copy_8(cur, &v0);
-    }
-    return cur + 5 - val;
-}
-
-/** Write indent (requires level * 4 bytes buffer). */
-static_inline u8 *write_indent(u8 *cur, usize level) {
-    while (level-- > 0) {
-        byte_copy_4(cur, "    ");
-        cur += 4;
-    }
-    return cur;
-}
-
-/** Write data to file. */
-static bool write_dat_to_file(const char *path, u8 *dat, usize len,
-                              yyjson_write_err *err) {
-    
-#define return_err(_code, _msg) do { \
-    err->msg = _msg; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    if (file) fclose(file); \
-    return false; \
-} while (false)
-    
-    FILE *file = fopen_writeonly(path);
-    if (file == NULL) {
-        return_err(FILE_OPEN, "file opening failed");
-    }
-    if (fwrite(dat, len, 1, file) != 1) {
-        return_err(FILE_WRITE, "file writing failed");
-    }
-    if (fclose(file) != 0) {
-        file = NULL;
-        return_err(FILE_WRITE, "file closing failed");
-    }
-    return true;
-    
-#undef return_err
-}
-
-
-
-/*==============================================================================
- * JSON Writer Implementation
- *============================================================================*/
-
-typedef struct yyjson_write_ctx {
-    usize tag;
-} yyjson_write_ctx;
-
-static_inline void yyjson_write_ctx_set(yyjson_write_ctx *ctx,
-                                        usize size, bool is_obj) {
-    ctx->tag = (size << 1) | (usize)is_obj;
-}
-
-static_inline void yyjson_write_ctx_get(yyjson_write_ctx *ctx,
-                                        usize *size, bool *is_obj) {
-    usize tag = ctx->tag;
-    *size = tag >> 1;
-    *is_obj = (bool)(tag & 1);
-}
-
-/** Write single JSON value. */
-static_inline u8 *yyjson_write_single(yyjson_val *val,
-                                      yyjson_write_flag flg,
-                                      yyjson_alc alc,
-                                      usize *dat_len,
-                                      yyjson_write_err *err) {
-    
-#define return_err(_code, _msg) do { \
-    if (hdr) alc.free(alc.ctx, (void *)hdr); \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    return NULL; \
-} while (false)
-    
-#define incr_len(_len) do { \
-    hdr = (u8 *)alc.malloc(alc.ctx, _len); \
-    if (!hdr) goto fail_alloc; \
-    cur = hdr; \
-} while (false)
-    
-#define check_str_len(_len) do { \
-    if ((USIZE_MAX < U64_MAX) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-    
-    u8 *hdr = NULL, *cur;
-    usize str_len;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool esc = (flg & YYJSON_WRITE_ESCAPE_UNICODE) != 0;
-    bool inv = (flg & YYJSON_WRITE_ALLOW_INVALID_UNICODE) != 0;
-    
-    switch (unsafe_yyjson_get_type(val)) {
-        case YYJSON_TYPE_RAW:
-            str_len = unsafe_yyjson_get_len(val);
-            str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-            check_str_len(str_len);
-            incr_len(str_len + 1);
-            cur = write_raw(cur, str_ptr, str_len);
-            break;
-            
-        case YYJSON_TYPE_STR:
-            str_len = unsafe_yyjson_get_len(val);
-            str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-            check_str_len(str_len);
-            incr_len(str_len * 6 + 4);
-            cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-            if (unlikely(!cur)) goto fail_str;
-            break;
-            
-        case YYJSON_TYPE_NUM:
-            incr_len(32);
-            cur = write_number(cur, val, flg);
-            if (unlikely(!cur)) goto fail_num;
-            break;
-            
-        case YYJSON_TYPE_BOOL:
-            incr_len(8);
-            cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-            break;
-            
-        case YYJSON_TYPE_NULL:
-            incr_len(8);
-            cur = write_null(cur);
-            break;
-            
-        case YYJSON_TYPE_ARR:
-            incr_len(4);
-            byte_copy_2(cur, "[]");
-            cur += 2;
-            break;
-            
-        case YYJSON_TYPE_OBJ:
-            incr_len(4);
-            byte_copy_2(cur, "{}");
-            cur += 2;
-            break;
-            
-        default:
-            goto fail_type;
-    }
-    
-    *cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    memset(err, 0, sizeof(yyjson_write_err));
-    return hdr;
-    
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-    
-#undef return_err
-#undef check_str_len
-#undef incr_len
-}
-
-/** Write JSON document minify.
-    The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_write_minify(const yyjson_val *root,
-                                      const yyjson_write_flag flg,
-                                      const yyjson_alc alc,
-                                      usize *dat_len,
-                                      yyjson_write_err *err) {
-    
-#define return_err(_code, _msg) do { \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    if (hdr) alc.free(alc.ctx, hdr); \
-    return NULL; \
-} while (false)
-    
-#define incr_len(_len) do { \
-    ext_len = (usize)(_len); \
-    if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \
-        alc_inc = yyjson_max(alc_len / 2, ext_len); \
-        alc_inc = size_align_up(alc_inc, sizeof(yyjson_write_ctx)); \
-        if (size_add_is_overflow(alc_len, alc_inc)) goto fail_alloc; \
-        alc_len += alc_inc; \
-        tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len); \
-        if (unlikely(!tmp)) goto fail_alloc; \
-        ctx_len = (usize)(end - (u8 *)ctx); \
-        ctx_tmp = (yyjson_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \
-        memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \
-        ctx = ctx_tmp; \
-        cur = tmp + (cur - hdr); \
-        end = tmp + alc_len; \
-        hdr = tmp; \
-    } \
-} while (false)
-    
-#define check_str_len(_len) do { \
-    if ((USIZE_MAX < U64_MAX) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-    
-    yyjson_val *val;
-    yyjson_type val_type;
-    usize ctn_len, ctn_len_tmp;
-    bool ctn_obj, ctn_obj_tmp, is_key;
-    u8 *hdr, *cur, *end, *tmp;
-    yyjson_write_ctx *ctx, *ctx_tmp;
-    usize alc_len, alc_inc, ctx_len, ext_len, str_len;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool esc = (flg & YYJSON_WRITE_ESCAPE_UNICODE) != 0;
-    bool inv = (flg & YYJSON_WRITE_ALLOW_INVALID_UNICODE) != 0;
-    
-    alc_len = root->uni.ofs / sizeof(yyjson_val);
-    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
-    cur = hdr;
-    end = hdr + alc_len;
-    ctx = (yyjson_write_ctx *)(void *)end;
-    
-doc_begin:
-    val = (yyjson_val *)root;
-    val_type = unsafe_yyjson_get_type(val);
-    ctn_obj = (val_type == YYJSON_TYPE_OBJ);
-    ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj;
-    *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-    val++;
-    
-val_begin:
-    val_type = unsafe_yyjson_get_type(val);
-    if (val_type == YYJSON_TYPE_STR) {
-        is_key = ((u8)ctn_obj & (u8)~ctn_len);
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len * 6 + 16);
-        cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-        if (unlikely(!cur)) goto fail_str;
-        *cur++ = is_key ? ':' : ',';
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NUM) {
-        incr_len(32);
-        cur = write_number(cur, val, flg);
-        if (unlikely(!cur)) goto fail_num;
-        *cur++ = ',';
-        goto val_end;
-    }
-    if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) ==
-                    (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
-        ctn_len_tmp = unsafe_yyjson_get_len(val);
-        ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        incr_len(16);
-        if (unlikely(ctn_len_tmp == 0)) {
-            /* write empty container */
-            *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = ',';
-            goto val_end;
-        } else {
-            /* push context, setup new container */
-            yyjson_write_ctx_set(--ctx, ctn_len, ctn_obj);
-            ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
-            ctn_obj = ctn_obj_tmp;
-            *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-            val++;
-            goto val_begin;
-        }
-    }
-    if (val_type == YYJSON_TYPE_BOOL) {
-        incr_len(16);
-        cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-        cur++;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NULL) {
-        incr_len(16);
-        cur = write_null(cur);
-        cur++;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_RAW) {
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len + 2);
-        cur = write_raw(cur, str_ptr, str_len);
-        *cur++ = ',';
-        goto val_end;
-    }
-    goto fail_type;
-    
-val_end:
-    val++;
-    ctn_len--;
-    if (unlikely(ctn_len == 0)) goto ctn_end;
-    goto val_begin;
-    
-ctn_end:
-    cur--;
-    *cur++ = (u8)(']' | ((u8)ctn_obj << 5));
-    *cur++ = ',';
-    if (unlikely((u8 *)ctx >= end)) goto doc_end;
-    yyjson_write_ctx_get(ctx++, &ctn_len, &ctn_obj);
-    ctn_len--;
-    if (likely(ctn_len > 0)) {
-        goto val_begin;
-    } else {
-        goto ctn_end;
-    }
-    
-doc_end:
-    *--cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    memset(err, 0, sizeof(yyjson_write_err));
-    return hdr;
-    
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-    
-#undef return_err
-#undef incr_len
-#undef check_str_len
-}
-
-/** Write JSON document pretty.
-    The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_write_pretty(const yyjson_val *root,
-                                      const yyjson_write_flag flg,
-                                      const yyjson_alc alc,
-                                      usize *dat_len,
-                                      yyjson_write_err *err) {
-    
-#define return_err(_code, _msg) do { \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    if (hdr) alc.free(alc.ctx, hdr); \
-    return NULL; \
-} while (false)
-    
-#define incr_len(_len) do { \
-    ext_len = (usize)(_len); \
-    if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \
-        alc_inc = yyjson_max(alc_len / 2, ext_len); \
-        alc_inc = size_align_up(alc_inc, sizeof(yyjson_write_ctx)); \
-        if (size_add_is_overflow(alc_len, alc_inc)) goto fail_alloc; \
-        alc_len += alc_inc; \
-        tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len); \
-        if (unlikely(!tmp)) goto fail_alloc; \
-        ctx_len = (usize)(end - (u8 *)ctx); \
-        ctx_tmp = (yyjson_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \
-        memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \
-        ctx = ctx_tmp; \
-        cur = tmp + (cur - hdr); \
-        end = tmp + alc_len; \
-        hdr = tmp; \
-    } \
-} while (false)
-    
-#define check_str_len(_len) do { \
-    if ((USIZE_MAX < U64_MAX) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-    
-    yyjson_val *val;
-    yyjson_type val_type;
-    usize ctn_len, ctn_len_tmp;
-    bool ctn_obj, ctn_obj_tmp, is_key, no_indent;
-    u8 *hdr, *cur, *end, *tmp;
-    yyjson_write_ctx *ctx, *ctx_tmp;
-    usize alc_len, alc_inc, ctx_len, ext_len, str_len, level;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool esc = (flg & YYJSON_WRITE_ESCAPE_UNICODE) != 0;
-    bool inv = (flg & YYJSON_WRITE_ALLOW_INVALID_UNICODE) != 0;
-    
-    alc_len = root->uni.ofs / sizeof(yyjson_val);
-    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
-    cur = hdr;
-    end = hdr + alc_len;
-    ctx = (yyjson_write_ctx *)(void *)end;
-    
-doc_begin:
-    val = (yyjson_val *)root;
-    val_type = unsafe_yyjson_get_type(val);
-    ctn_obj = (val_type == YYJSON_TYPE_OBJ);
-    ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj;
-    *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-    *cur++ = '\n';
-    val++;
-    level = 1;
-    
-val_begin:
-    val_type = unsafe_yyjson_get_type(val);
-    if (val_type == YYJSON_TYPE_STR) {
-        is_key = (bool)((u8)ctn_obj & (u8)~ctn_len);
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len * 6 + 16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level);
-        cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-        if (unlikely(!cur)) goto fail_str;
-        *cur++ = is_key ? ':' : ',';
-        *cur++ = is_key ? ' ' : '\n';
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NUM) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(32 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level);
-        cur = write_number(cur, val, flg);
-        if (unlikely(!cur)) goto fail_num;
-        *cur++ = ',';
-        *cur++ = '\n';
-        goto val_end;
-    }
-    if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) ==
-                    (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        ctn_len_tmp = unsafe_yyjson_get_len(val);
-        ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        if (unlikely(ctn_len_tmp == 0)) {
-            /* write empty container */
-            incr_len(16 + (no_indent ? 0 : level * 4));
-            cur = write_indent(cur, no_indent ? 0 : level);
-            *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = ',';
-            *cur++ = '\n';
-            goto val_end;
-        } else {
-            /* push context, setup new container */
-            incr_len(32 + (no_indent ? 0 : level * 4));
-            yyjson_write_ctx_set(--ctx, ctn_len, ctn_obj);
-            ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
-            ctn_obj = ctn_obj_tmp;
-            cur = write_indent(cur, no_indent ? 0 : level);
-            level++;
-            *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-            *cur++ = '\n';
-            val++;
-            goto val_begin;
-        }
-    }
-    if (val_type == YYJSON_TYPE_BOOL) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level);
-        cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-        cur += 2;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NULL) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level);
-        cur = write_null(cur);
-        cur += 2;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_RAW) {
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len + 3);
-        cur = write_raw(cur, str_ptr, str_len);
-        *cur++ = ',';
-        *cur++ = '\n';
-        goto val_end;
-    }
-    goto fail_type;
-    
-val_end:
-    val++;
-    ctn_len--;
-    if (unlikely(ctn_len == 0)) goto ctn_end;
-    goto val_begin;
-    
-ctn_end:
-    cur -= 2;
-    *cur++ = '\n';
-    incr_len(level * 4);
-    cur = write_indent(cur, --level);
-    *cur++ = (u8)(']' | ((u8)ctn_obj << 5));
-    if (unlikely((u8 *)ctx >= end)) goto doc_end;
-    yyjson_write_ctx_get(ctx++, &ctn_len, &ctn_obj);
-    ctn_len--;
-    *cur++ = ',';
-    *cur++ = '\n';
-    if (likely(ctn_len > 0)) {
-        goto val_begin;
-    } else {
-        goto ctn_end;
-    }
-    
-doc_end:
-    *cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    memset(err, 0, sizeof(yyjson_write_err));
-    return hdr;
-    
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-    
-#undef return_err
-#undef incr_len
-#undef check_str_len
-}
-
-char *yyjson_val_write_opts(const yyjson_val *val,
-                            yyjson_write_flag flg,
-                            const yyjson_alc *alc_ptr,
-                            usize *dat_len,
-                            yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    usize dummy_dat_len;
-    yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC;
-    yyjson_val *root = (yyjson_val *)val;
-    
-    err = err ? err : &dummy_err;
-    dat_len = dat_len ? dat_len : &dummy_dat_len;
-    
-#if YYJSON_DISABLE_NON_STANDARD
-    flg &= ~YYJSON_WRITE_ALLOW_INF_AND_NAN;
-    flg &= ~YYJSON_WRITE_ALLOW_INVALID_UNICODE;
-#endif
-    
-    if (unlikely(!root)) {
-        *dat_len = 0;
-        err->msg = "input JSON is NULL";
-        err->code = YYJSON_READ_ERROR_INVALID_PARAMETER;
-        return NULL;
-    }
-    
-    if (!unsafe_yyjson_is_ctn(root) || unsafe_yyjson_get_len(root) == 0) {
-        return (char *)yyjson_write_single(root, flg, alc, dat_len, err);
-    } else if (flg & YYJSON_WRITE_PRETTY) {
-        return (char *)yyjson_write_pretty(root, flg, alc, dat_len, err);
-    } else {
-        return (char *)yyjson_write_minify(root, flg, alc, dat_len, err);
-    }
-}
-
-char *yyjson_write_opts(const yyjson_doc *doc,
-                        yyjson_write_flag flg,
-                        const yyjson_alc *alc_ptr,
-                        usize *dat_len,
-                        yyjson_write_err *err) {
-    yyjson_val *root = doc ? doc->root : NULL;
-    return yyjson_val_write_opts(root, flg, alc_ptr, dat_len, err);
-}
-
-bool yyjson_val_write_file(const char *path,
-                           const yyjson_val *val,
-                           yyjson_write_flag flg,
-                           const yyjson_alc *alc_ptr,
-                           yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    u8 *dat;
-    usize dat_len = 0;
-    yyjson_val *root = (yyjson_val *)val;
-    bool suc;
-    
-    alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC;
-    err = err ? err : &dummy_err;
-    if (unlikely(!path || !*path)) {
-        err->msg = "input path is invalid";
-        err->code = YYJSON_READ_ERROR_INVALID_PARAMETER;
-        return false;
-    }
-    
-    dat = (u8 *)yyjson_val_write_opts(root, flg, alc_ptr, &dat_len, err);
-    if (unlikely(!dat)) return false;
-    suc = write_dat_to_file(path, dat, dat_len, err);
-    alc_ptr->free(alc_ptr->ctx, dat);
-    return suc;
-}
-
-bool yyjson_write_file(const char *path,
-                       const yyjson_doc *doc,
-                       yyjson_write_flag flg,
-                       const yyjson_alc *alc_ptr,
-                       yyjson_write_err *err) {
-    yyjson_val *root = doc ? doc->root : NULL;
-    return yyjson_val_write_file(path, root, flg, alc_ptr, err);
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Writer Implementation
- *============================================================================*/
-
-typedef struct yyjson_mut_write_ctx {
-    usize tag;
-    yyjson_mut_val *ctn;
-} yyjson_mut_write_ctx;
-
-static_inline void yyjson_mut_write_ctx_set(yyjson_mut_write_ctx *ctx,
-                                            yyjson_mut_val *ctn,
-                                            usize size, bool is_obj) {
-    ctx->tag = (size << 1) | (usize)is_obj;
-    ctx->ctn = ctn;
-}
-
-static_inline void yyjson_mut_write_ctx_get(yyjson_mut_write_ctx *ctx,
-                                            yyjson_mut_val **ctn,
-                                            usize *size, bool *is_obj) {
-    usize tag = ctx->tag;
-    *size = tag >> 1;
-    *is_obj = (bool)(tag & 1);
-    *ctn = ctx->ctn;
-}
-
-/** Write single JSON value. */
-static_inline u8 *yyjson_mut_write_single(yyjson_mut_val *val,
-                                          yyjson_write_flag flg,
-                                          yyjson_alc alc,
-                                          usize *dat_len,
-                                          yyjson_write_err *err) {
-    return yyjson_write_single((yyjson_val *)val, flg, alc, dat_len, err);
-}
-
-/** Write JSON document minify.
-    The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_mut_write_minify(const yyjson_mut_val *root,
-                                          yyjson_write_flag flg,
-                                          yyjson_alc alc,
-                                          usize *dat_len,
-                                          yyjson_write_err *err) {
-    
-#define return_err(_code, _msg) do { \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    if (hdr) alc.free(alc.ctx, hdr); \
-    return NULL; \
-} while (false)
-    
-#define incr_len(_len) do { \
-    ext_len = (usize)(_len); \
-    if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \
-        alc_inc = yyjson_max(alc_len / 2, ext_len); \
-        alc_inc = size_align_up(alc_inc, sizeof(yyjson_mut_write_ctx)); \
-        if (size_add_is_overflow(alc_len, alc_inc)) goto fail_alloc; \
-        alc_len += alc_inc; \
-        tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len); \
-        if (unlikely(!tmp)) goto fail_alloc; \
-        ctx_len = (usize)(end - (u8 *)ctx); \
-        ctx_tmp = (yyjson_mut_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \
-        memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \
-        ctx = ctx_tmp; \
-        cur = tmp + (cur - hdr); \
-        end = tmp + alc_len; \
-        hdr = tmp; \
-    } \
-} while (false)
-    
-#define check_str_len(_len) do { \
-    if ((USIZE_MAX < U64_MAX) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-    
-    yyjson_mut_val *val, *ctn;
-    yyjson_type val_type;
-    usize ctn_len, ctn_len_tmp;
-    bool ctn_obj, ctn_obj_tmp, is_key;
-    u8 *hdr, *cur, *end, *tmp;
-    yyjson_mut_write_ctx *ctx, *ctx_tmp;
-    usize alc_len, alc_inc, ctx_len, ext_len, str_len;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool esc = (flg & YYJSON_WRITE_ESCAPE_UNICODE) != 0;
-    bool inv = (flg & YYJSON_WRITE_ALLOW_INVALID_UNICODE) != 0;
-    
-    alc_len = 0 * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
-    cur = hdr;
-    end = hdr + alc_len;
-    ctx = (yyjson_mut_write_ctx *)(void *)end;
-    
-doc_begin:
-    val = (yyjson_mut_val *)root;
-    val_type = unsafe_yyjson_get_type(val);
-    ctn_obj = (val_type == YYJSON_TYPE_OBJ);
-    ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj;
-    *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-    ctn = val;
-    val = (yyjson_mut_val *)val->uni.ptr; /* tail */
-    val = ctn_obj ? val->next->next : val->next;
-    
-val_begin:
-    val_type = unsafe_yyjson_get_type(val);
-    if (val_type == YYJSON_TYPE_STR) {
-        is_key = ((u8)ctn_obj & (u8)~ctn_len);
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len * 6 + 16);
-        cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-        if (unlikely(!cur)) goto fail_str;
-        *cur++ = is_key ? ':' : ',';
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NUM) {
-        incr_len(32);
-        cur = write_number(cur, (yyjson_val *)val, flg);
-        if (unlikely(!cur)) goto fail_num;
-        *cur++ = ',';
-        goto val_end;
-    }
-    if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) ==
-                    (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
-        ctn_len_tmp = unsafe_yyjson_get_len(val);
-        ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        incr_len(16);
-        if (unlikely(ctn_len_tmp == 0)) {
-            /* write empty container */
-            *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = ',';
-            goto val_end;
-        } else {
-            /* push context, setup new container */
-            yyjson_mut_write_ctx_set(--ctx, ctn, ctn_len, ctn_obj);
-            ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
-            ctn_obj = ctn_obj_tmp;
-            *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-            ctn = val;
-            val = (yyjson_mut_val *)ctn->uni.ptr; /* tail */
-            val = ctn_obj ? val->next->next : val->next;
-            goto val_begin;
-        }
-    }
-    if (val_type == YYJSON_TYPE_BOOL) {
-        incr_len(16);
-        cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-        cur++;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NULL) {
-        incr_len(16);
-        cur = write_null(cur);
-        cur++;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_RAW) {
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len + 2);
-        cur = write_raw(cur, str_ptr, str_len);
-        *cur++ = ',';
-        goto val_end;
-    }
-    goto fail_type;
-    
-val_end:
-    ctn_len--;
-    if (unlikely(ctn_len == 0)) goto ctn_end;
-    val = val->next;
-    goto val_begin;
-    
-ctn_end:
-    cur--;
-    *cur++ = (u8)(']' | ((u8)ctn_obj << 5));
-    *cur++ = ',';
-    if (unlikely((u8 *)ctx >= end)) goto doc_end;
-    val = ctn->next;
-    yyjson_mut_write_ctx_get(ctx++, &ctn, &ctn_len, &ctn_obj);
-    ctn_len--;
-    if (likely(ctn_len > 0)) {
-        goto val_begin;
-    } else {
-        goto ctn_end;
-    }
-    
-doc_end:
-    *--cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    err->code = YYJSON_WRITE_SUCCESS;
-    err->msg = "success";
-    return hdr;
-    
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-    
-#undef return_err
-#undef incr_len
-#undef check_str_len
-}
-
-/** Write JSON document pretty.
-    The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_mut_write_pretty(const yyjson_mut_val *root,
-                                          yyjson_write_flag flg,
-                                          yyjson_alc alc,
-                                          usize *dat_len,
-                                          yyjson_write_err *err) {
-    
-#define return_err(_code, _msg) do { \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    if (hdr) alc.free(alc.ctx, hdr); \
-    return NULL; \
-} while (false)
-    
-#define incr_len(_len) do { \
-    ext_len = (usize)(_len); \
-    if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \
-        alc_inc = yyjson_max(alc_len / 2, ext_len); \
-        alc_inc = size_align_up(alc_inc, sizeof(yyjson_mut_write_ctx)); \
-        if (size_add_is_overflow(alc_len, alc_inc)) goto fail_alloc; \
-        alc_len += alc_inc; \
-        tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len); \
-        if (unlikely(!tmp)) goto fail_alloc; \
-        ctx_len = (usize)(end - (u8 *)ctx); \
-        ctx_tmp = (yyjson_mut_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \
-        memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \
-        ctx = ctx_tmp; \
-        cur = tmp + (cur - hdr); \
-        end = tmp + alc_len; \
-        hdr = tmp; \
-    } \
-} while (false)
-    
-#define check_str_len(_len) do { \
-    if ((USIZE_MAX < U64_MAX) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-    
-    yyjson_mut_val *val, *ctn;
-    yyjson_type val_type;
-    usize ctn_len, ctn_len_tmp;
-    bool ctn_obj, ctn_obj_tmp, is_key, no_indent;
-    u8 *hdr, *cur, *end, *tmp;
-    yyjson_mut_write_ctx *ctx, *ctx_tmp;
-    usize alc_len, alc_inc, ctx_len, ext_len, str_len, level;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool esc = (flg & YYJSON_WRITE_ESCAPE_UNICODE) != 0;
-    bool inv = (flg & YYJSON_WRITE_ALLOW_INVALID_UNICODE) != 0;
-    
-    alc_len = 0 * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
-    cur = hdr;
-    end = hdr + alc_len;
-    ctx = (yyjson_mut_write_ctx *)(void *)end;
-    
-doc_begin:
-    val = (yyjson_mut_val *)root;
-    val_type = unsafe_yyjson_get_type(val);
-    ctn_obj = (val_type == YYJSON_TYPE_OBJ);
-    ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj;
-    *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-    *cur++ = '\n';
-    ctn = val;
-    val = (yyjson_mut_val *)val->uni.ptr; /* tail */
-    val = ctn_obj ? val->next->next : val->next;
-    level = 1;
-    
-val_begin:
-    val_type = unsafe_yyjson_get_type(val);
-    if (val_type == YYJSON_TYPE_STR) {
-        is_key = (bool)((u8)ctn_obj & (u8)~ctn_len);
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len * 6 + 16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level);
-        cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-        if (unlikely(!cur)) goto fail_str;
-        *cur++ = is_key ? ':' : ',';
-        *cur++ = is_key ? ' ' : '\n';
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NUM) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(32 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level);
-        cur = write_number(cur, (yyjson_val *)val, flg);
-        if (unlikely(!cur)) goto fail_num;
-        *cur++ = ',';
-        *cur++ = '\n';
-        goto val_end;
-    }
-    if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) ==
-                    (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        ctn_len_tmp = unsafe_yyjson_get_len(val);
-        ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        if (unlikely(ctn_len_tmp == 0)) {
-            /* write empty container */
-            incr_len(16 + (no_indent ? 0 : level * 4));
-            cur = write_indent(cur, no_indent ? 0 : level);
-            *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = ',';
-            *cur++ = '\n';
-            goto val_end;
-        } else {
-            /* push context, setup new container */
-            incr_len(32 + (no_indent ? 0 : level * 4));
-            yyjson_mut_write_ctx_set(--ctx, ctn, ctn_len, ctn_obj);
-            ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
-            ctn_obj = ctn_obj_tmp;
-            cur = write_indent(cur, no_indent ? 0 : level);
-            level++;
-            *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-            *cur++ = '\n';
-            ctn = val;
-            val = (yyjson_mut_val *)ctn->uni.ptr; /* tail */
-            val = ctn_obj ? val->next->next : val->next;
-            goto val_begin;
-        }
-    }
-    if (val_type == YYJSON_TYPE_BOOL) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level);
-        cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-        cur += 2;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NULL) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level);
-        cur = write_null(cur);
-        cur += 2;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_RAW) {
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len + 3);
-        cur = write_raw(cur, str_ptr, str_len);
-        *cur++ = ',';
-        *cur++ = '\n';
-        goto val_end;
-    }
-    goto fail_type;
-    
-val_end:
-    ctn_len--;
-    if (unlikely(ctn_len == 0)) goto ctn_end;
-    val = val->next;
-    goto val_begin;
-    
-ctn_end:
-    cur -= 2;
-    *cur++ = '\n';
-    incr_len(level * 4);
-    cur = write_indent(cur, --level);
-    *cur++ = (u8)(']' | ((u8)ctn_obj << 5));
-    if (unlikely((u8 *)ctx >= end)) goto doc_end;
-    val = ctn->next;
-    yyjson_mut_write_ctx_get(ctx++, &ctn, &ctn_len, &ctn_obj);
-    ctn_len--;
-    *cur++ = ',';
-    *cur++ = '\n';
-    if (likely(ctn_len > 0)) {
-        goto val_begin;
-    } else {
-        goto ctn_end;
-    }
-    
-doc_end:
-    *cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    err->code = YYJSON_WRITE_SUCCESS;
-    err->msg = "success";
-    return hdr;
-    
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-    
-#undef return_err
-#undef incr_len
-#undef check_str_len
-}
-
-char *yyjson_mut_val_write_opts(const yyjson_mut_val *val,
-                                yyjson_write_flag flg,
-                                const yyjson_alc *alc_ptr,
-                                usize *dat_len,
-                                yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    usize dummy_dat_len;
-    yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC;
-    yyjson_mut_val *root = (yyjson_mut_val *)val;
-    
-    err = err ? err : &dummy_err;
-    dat_len = dat_len ? dat_len : &dummy_dat_len;
-    
-#if YYJSON_DISABLE_NON_STANDARD
-    flg &= ~YYJSON_WRITE_ALLOW_INF_AND_NAN;
-    flg &= ~YYJSON_WRITE_ALLOW_INVALID_UNICODE;
-#endif
-    
-    if (unlikely(!root)) {
-        *dat_len = 0;
-        err->msg = "input JSON is NULL";
-        err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER;
-        return NULL;
-    }
-    
-    if (!unsafe_yyjson_is_ctn(root) || unsafe_yyjson_get_len(root) == 0) {
-        return (char *)yyjson_mut_write_single(root, flg, alc, dat_len, err);
-    } else if (flg & YYJSON_WRITE_PRETTY) {
-        return (char *)yyjson_mut_write_pretty(root, flg, alc, dat_len, err);
-    } else {
-        return (char *)yyjson_mut_write_minify(root, flg, alc, dat_len, err);
-    }
-}
-
-char *yyjson_mut_write_opts(const yyjson_mut_doc *doc,
-                            yyjson_write_flag flg,
-                            const yyjson_alc *alc_ptr,
-                            usize *dat_len,
-                            yyjson_write_err *err) {
-    yyjson_mut_val *root = doc ? doc->root : NULL;
-    return yyjson_mut_val_write_opts(root, flg, alc_ptr, dat_len, err);
-}
-
-bool yyjson_mut_val_write_file(const char *path,
-                               const yyjson_mut_val *val,
-                               yyjson_write_flag flg,
-                               const yyjson_alc *alc_ptr,
-                               yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    u8 *dat;
-    usize dat_len = 0;
-    yyjson_mut_val *root = (yyjson_mut_val *)val;
-    bool suc;
-    
-    alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC;
-    err = err ? err : &dummy_err;
-    if (unlikely(!path || !*path)) {
-        err->msg = "input path is invalid";
-        err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER;
-        return false;
-    }
-    
-    dat = (u8 *)yyjson_mut_val_write_opts(root, flg, alc_ptr, &dat_len, err);
-    if (unlikely(!dat)) return false;
-    suc = write_dat_to_file(path, dat, dat_len, err);
-    alc_ptr->free(alc_ptr->ctx, dat);
-    return suc;
-    
-}
-
-bool yyjson_mut_write_file(const char *path,
-                           const yyjson_mut_doc *doc,
-                           yyjson_write_flag flg,
-                           const yyjson_alc *alc_ptr,
-                           yyjson_write_err *err) {
-    yyjson_mut_val *root = doc ? doc->root : NULL;
-    return yyjson_mut_val_write_file(path, root, flg, alc_ptr, err);
-}
-
-#endif /* YYJSON_DISABLE_WRITER */
-
-
-
-/*==============================================================================
- * Compiler Hint End
- *============================================================================*/
-
-#if defined(__clang__)
-#   pragma clang diagnostic pop
-#elif defined(__GNUC__)
-#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#   pragma GCC diagnostic pop
-#   endif
-#elif defined(_MSC_VER)
-#   pragma warning(pop)
-#endif /* warning suppress end */
diff --git a/thirdparty/yyjson/yyjson.h b/thirdparty/yyjson/yyjson.h
deleted file mode 100644
index 35a4594..0000000
--- a/thirdparty/yyjson/yyjson.h
+++ /dev/null
@@ -1,5553 +0,0 @@
-/*==============================================================================
- * Created by Yaoyuan on 2019/3/9.
- * Copyright (C) 2019 Yaoyuan <ibireme@gmail.com>.
- *
- * Released under the MIT License:
- * https://github.com/ibireme/yyjson/blob/master/LICENSE
- *============================================================================*/
-
-/** @file yyjson.h */
-
-#ifndef YYJSON_H
-#define YYJSON_H
-
-
-
-/*==============================================================================
- * Header Files
- *============================================================================*/
-
-#include <stdlib.h>
-#include <stddef.h>
-#include <limits.h>
-#include <string.h>
-#include <float.h>
-
-
-
-/*==============================================================================
- * Compile-time Options
- *============================================================================*/
-
-/*
- Define as 1 to disable JSON reader if you don't need to parse JSON.
- 
- This will disable these functions at compile-time:
-    - yyjson_read_opts()
-    - yyjson_read_file()
-    - yyjson_read()
- 
- This will reduce the binary size by about 60%.
- */
-#ifndef YYJSON_DISABLE_READER
-#endif
-
-/*
- Define as 1 to disable JSON writer if you don't need to serialize JSON.
- 
- This will disable these functions at compile-time:
-    - yyjson_write()
-    - yyjson_write_file()
-    - yyjson_write_opts()
-    - yyjson_val_write()
-    - yyjson_val_write_file()
-    - yyjson_val_write_opts()
-    - yyjson_mut_write()
-    - yyjson_mut_write_file()
-    - yyjson_mut_write_opts()
-    - yyjson_mut_val_write()
-    - yyjson_mut_val_write_file()
-    - yyjson_mut_val_write_opts()
- 
- This will reduce the binary size by about 30%.
- */
-#ifndef YYJSON_DISABLE_WRITER
-#endif
-
-/*
- Define as 1 to disable the fast floating-point number conversion in yyjson,
- and use libc's `strtod/snprintf` instead.
- 
- This will reduce binary size by about 30%, but significantly slow down
- floating-point reading and writing speed.
- */
-#ifndef YYJSON_DISABLE_FAST_FP_CONV
-#endif
-
-/*
- Define as 1 to disable non-standard JSON support at compile-time:
-    - Reading and writing inf/nan literal, such as 'NaN', '-Infinity'.
-    - Single line and multiple line comments.
-    - Single trailing comma at the end of an object or array.
-    - Invalid unicode in string value.
- 
- This will also invalidate these run-time options:
-    - YYJSON_READ_ALLOW_INF_AND_NAN
-    - YYJSON_READ_ALLOW_COMMENTS
-    - YYJSON_READ_ALLOW_TRAILING_COMMAS
-    - YYJSON_READ_ALLOW_INVALID_UNICODE
-    - YYJSON_WRITE_ALLOW_INF_AND_NAN
-    - YYJSON_WRITE_ALLOW_INVALID_UNICODE
- 
- This will reduce binary size by about 10%, and increase performance slightly.
- */
-#ifndef YYJSON_DISABLE_NON_STANDARD
-#endif
-
-/*
- Define as 1 to disable unaligned memory access if target architecture does not
- support unaligned memory access (such as some embedded processors).
- 
- If this value is not defined, yyjson will perform some automatic detection.
- The wrong definition of this option may cause some performance degradation,
- but will not cause run-time errors.
- */
-#ifndef YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-#endif
-
-/* Define as 1 to export symbols when building this library as Windows DLL. */
-#ifndef YYJSON_EXPORTS
-#endif
-
-/* Define as 1 to import symbols when using this library as Windows DLL. */
-#ifndef YYJSON_IMPORTS
-#endif
-
-/* Define as 1 to include <stdint.h> for compiler which doesn't support C99. */
-#ifndef YYJSON_HAS_STDINT_H
-#endif
-
-/* Define as 1 to include <stdbool.h> for compiler which doesn't support C99. */
-#ifndef YYJSON_HAS_STDBOOL_H
-#endif
-
-
-
-/*==============================================================================
- * Compiler Macros
- *============================================================================*/
-
-/** compiler version (MSVC) */
-#ifdef _MSC_VER
-#   define YYJSON_MSC_VER _MSC_VER
-#else
-#   define YYJSON_MSC_VER 0
-#endif
-
-/** compiler version (GCC) */
-#ifdef __GNUC__
-#   define YYJSON_GCC_VER __GNUC__
-#else
-#   define YYJSON_GCC_VER 0
-#endif
-
-/** C version (STDC) */
-#if defined(__STDC__) && (__STDC__ >= 1) && defined(__STDC_VERSION__)
-#   define YYJSON_STDC_VER __STDC_VERSION__
-#else
-#   define YYJSON_STDC_VER 0
-#endif
-
-/** C++ version */
-#if defined(__cplusplus)
-#   define YYJSON_CPP_VER __cplusplus
-#else
-#   define YYJSON_CPP_VER 0
-#endif
-
-/** compiler builtin check (since gcc 10.0, clang 2.6, icc 2021) */
-#ifndef yyjson_has_builtin
-#   ifdef __has_builtin
-#       define yyjson_has_builtin(x) __has_builtin(x)
-#   else
-#       define yyjson_has_builtin(x) 0
-#   endif
-#endif
-
-/** compiler attribute check (since gcc 5.0, clang 2.9, icc 17) */
-#ifndef yyjson_has_attribute
-#   ifdef __has_attribute
-#       define yyjson_has_attribute(x) __has_attribute(x)
-#   else
-#       define yyjson_has_attribute(x) 0
-#   endif
-#endif
-
-/** include check (since gcc 5.0, clang 2.7, icc 16, msvc 2017 15.3) */
-#ifndef yyjson_has_include
-#   ifdef __has_include
-#       define yyjson_has_include(x) __has_include(x)
-#   else
-#       define yyjson_has_include(x) 0
-#   endif
-#endif
-
-/** inline for compiler */
-#ifndef yyjson_inline
-#   if YYJSON_MSC_VER >= 1200
-#       define yyjson_inline __forceinline
-#   elif defined(_MSC_VER)
-#       define yyjson_inline __inline
-#   elif yyjson_has_attribute(always_inline) || YYJSON_GCC_VER >= 4
-#       define yyjson_inline __inline__ __attribute__((always_inline))
-#   elif defined(__clang__) || defined(__GNUC__)
-#       define yyjson_inline __inline__
-#   elif defined(__cplusplus) || YYJSON_STDC_VER >= 199901L
-#       define yyjson_inline inline
-#   else
-#       define yyjson_inline
-#   endif
-#endif
-
-/** noinline for compiler */
-#ifndef yyjson_noinline
-#   if YYJSON_MSC_VER >= 1400
-#       define yyjson_noinline __declspec(noinline)
-#   elif yyjson_has_attribute(noinline) || YYJSON_GCC_VER >= 4
-#       define yyjson_noinline __attribute__((noinline))
-#   else
-#       define yyjson_noinline
-#   endif
-#endif
-
-/** align for compiler */
-#ifndef yyjson_align
-#   if YYJSON_MSC_VER >= 1300
-#       define yyjson_align(x) __declspec(align(x))
-#   elif yyjson_has_attribute(aligned) || defined(__GNUC__)
-#       define yyjson_align(x) __attribute__((aligned(x)))
-#   elif YYJSON_CPP_VER >= 201103L
-#       define yyjson_align(x) alignas(x)
-#   else
-#       define yyjson_align(x)
-#   endif
-#endif
-
-/** likely for compiler */
-#ifndef yyjson_likely
-#   if yyjson_has_builtin(__builtin_expect) || YYJSON_GCC_VER >= 4
-#       define yyjson_likely(expr) __builtin_expect(!!(expr), 1)
-#   else
-#       define yyjson_likely(expr) (expr)
-#   endif
-#endif
-
-/** unlikely for compiler */
-#ifndef yyjson_unlikely
-#   if yyjson_has_builtin(__builtin_expect) || YYJSON_GCC_VER >= 4
-#       define yyjson_unlikely(expr) __builtin_expect(!!(expr), 0)
-#   else
-#       define yyjson_unlikely(expr) (expr)
-#   endif
-#endif
-
-/** function export */
-#ifndef yyjson_api
-#   if defined(_WIN32)
-#       if defined(YYJSON_EXPORTS) && YYJSON_EXPORTS
-#           define yyjson_api __declspec(dllexport)
-#       elif defined(YYJSON_IMPORTS) && YYJSON_IMPORTS
-#           define yyjson_api __declspec(dllimport)
-#       else
-#           define yyjson_api
-#       endif
-#   elif yyjson_has_attribute(visibility) || YYJSON_GCC_VER >= 4
-#       define yyjson_api __attribute__((visibility("default")))
-#   else
-#       define yyjson_api
-#   endif
-#endif
-
-/** inline function export */
-#ifndef yyjson_api_inline
-#   define yyjson_api_inline static yyjson_inline
-#endif
-
-/** stdint (C89 compatible) */
-#if (defined(YYJSON_HAS_STDINT_H) && YYJSON_HAS_STDINT_H) || \
-    YYJSON_MSC_VER >= 1600 || YYJSON_STDC_VER >= 199901L || \
-    defined(_STDINT_H) || defined(_STDINT_H_) || \
-    defined(__CLANG_STDINT_H) || defined(_STDINT_H_INCLUDED) || \
-    yyjson_has_include(<stdint.h>)
-#   include <stdint.h>
-#elif defined(_MSC_VER)
-#   if _MSC_VER < 1300
-        typedef signed char         int8_t;
-        typedef signed short        int16_t;
-        typedef signed int          int32_t;
-        typedef unsigned char       uint8_t;
-        typedef unsigned short      uint16_t;
-        typedef unsigned int        uint32_t;
-        typedef signed __int64      int64_t;
-        typedef unsigned __int64    uint64_t;
-#   else
-        typedef signed __int8       int8_t;
-        typedef signed __int16      int16_t;
-        typedef signed __int32      int32_t;
-        typedef unsigned __int8     uint8_t;
-        typedef unsigned __int16    uint16_t;
-        typedef unsigned __int32    uint32_t;
-        typedef signed __int64      int64_t;
-        typedef unsigned __int64    uint64_t;
-#   endif
-#else
-#   if UCHAR_MAX == 0xFFU
-        typedef signed char     int8_t;
-        typedef unsigned char   uint8_t;
-#   else
-#       error cannot find 8-bit integer type
-#   endif
-#   if USHRT_MAX == 0xFFFFU
-        typedef unsigned short  uint16_t;
-        typedef signed short    int16_t;
-#   elif UINT_MAX == 0xFFFFU
-        typedef unsigned int    uint16_t;
-        typedef signed int      int16_t;
-#   else
-#       error cannot find 16-bit integer type
-#   endif
-#   if UINT_MAX == 0xFFFFFFFFUL
-        typedef unsigned int    uint32_t;
-        typedef signed int      int32_t;
-#   elif ULONG_MAX == 0xFFFFFFFFUL
-        typedef unsigned long   uint32_t;
-        typedef signed long     int32_t;
-#   elif USHRT_MAX == 0xFFFFFFFFUL
-        typedef unsigned short  uint32_t;
-        typedef signed short    int32_t;
-#   else
-#       error cannot find 32-bit integer type
-#   endif
-#   if defined(__INT64_TYPE__) && defined(__UINT64_TYPE__)
-        typedef __INT64_TYPE__  int64_t;
-        typedef __UINT64_TYPE__ uint64_t;
-#   elif defined(__GNUC__) || defined(__clang__)
-#       if !defined(_SYS_TYPES_H) && !defined(__int8_t_defined)
-        __extension__ typedef long long             int64_t;
-#       endif
-        __extension__ typedef unsigned long long    uint64_t;
-#   elif defined(_LONG_LONG) || defined(__MWERKS__) || defined(_CRAYC) || \
-        defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-        typedef long long           int64_t;
-        typedef unsigned long long  uint64_t;
-#   elif (defined(__BORLANDC__) && __BORLANDC__ > 0x460) || \
-        defined(__WATCOM_INT64__) || defined (__alpha) || defined (__DECC)
-        typedef __int64             int64_t;
-        typedef unsigned __int64    uint64_t;
-#   else
-#       error cannot find 64-bit integer type
-#   endif
-#endif
-
-/** stdbool (C89 compatible) */
-#if (defined(YYJSON_HAS_STDBOOL_H) && YYJSON_HAS_STDBOOL_H) || \
-    (yyjson_has_include(<stdbool.h>) && !defined(__STRICT_ANSI__)) || \
-    YYJSON_MSC_VER >= 1800 || YYJSON_STDC_VER >= 199901L
-#   include <stdbool.h>
-#elif !defined(__bool_true_false_are_defined)
-#   define __bool_true_false_are_defined 1
-#   if defined(__cplusplus)
-#       if defined(__GNUC__) && !defined(__STRICT_ANSI__)
-#           define _Bool bool
-#           if __cplusplus < 201103L
-#               define bool bool
-#               define false false
-#               define true true
-#           endif
-#       endif
-#   else
-#       define bool unsigned char
-#       define true 1
-#       define false 0
-#   endif
-#endif
-
-/** char bit check */
-#if defined(CHAR_BIT)
-#   if CHAR_BIT != 8
-#       error non 8-bit char is not supported
-#   endif
-#endif
-
-
-
-/*==============================================================================
- * Compile Hint Begin
- *============================================================================*/
-
-/* extern "C" begin */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* warning suppress begin */
-#if defined(__clang__)
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wunused-function"
-#   pragma clang diagnostic ignored "-Wunused-parameter"
-#elif defined(__GNUC__)
-#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#   pragma GCC diagnostic push
-#   endif
-#   pragma GCC diagnostic ignored "-Wunused-function"
-#   pragma GCC diagnostic ignored "-Wunused-parameter"
-#elif defined(_MSC_VER)
-#   pragma warning(push)
-#   pragma warning(disable:4800) /* 'int': forcing value to 'true' or 'false' */
-#endif
-
-
-
-/*==============================================================================
- * Version
- *============================================================================*/
-
-/** The major version of yyjson. */
-#define YYJSON_VERSION_MAJOR  0
-
-/** The minor version of yyjson. */
-#define YYJSON_VERSION_MINOR  5
-
-/** The patch version of yyjson. */
-#define YYJSON_VERSION_PATCH  1
-
-/** The version of yyjson in hex: (major << 16) | (minor << 8) | (patch). */
-#define YYJSON_VERSION_HEX    0x000501
-
-/** The version string of yyjson. */
-#define YYJSON_VERSION_STRING "0.5.1"
-
-/** The version of yyjson in hex, same as `YYJSON_VERSION_HEX`. */
-yyjson_api uint32_t yyjson_version(void);
-
-
-
-/*==============================================================================
- * JSON Types
- *============================================================================*/
-
-/** Type of JSON value (3 bit). */
-typedef uint8_t yyjson_type;
-#define YYJSON_TYPE_NONE        ((uint8_t)0)        /* _____000 */
-#define YYJSON_TYPE_RAW         ((uint8_t)1)        /* _____001 */
-#define YYJSON_TYPE_NULL        ((uint8_t)2)        /* _____010 */
-#define YYJSON_TYPE_BOOL        ((uint8_t)3)        /* _____011 */
-#define YYJSON_TYPE_NUM         ((uint8_t)4)        /* _____100 */
-#define YYJSON_TYPE_STR         ((uint8_t)5)        /* _____101 */
-#define YYJSON_TYPE_ARR         ((uint8_t)6)        /* _____110 */
-#define YYJSON_TYPE_OBJ         ((uint8_t)7)        /* _____111 */
-
-/** Subtype of JSON value (2 bit). */
-typedef uint8_t yyjson_subtype;
-#define YYJSON_SUBTYPE_NONE     ((uint8_t)(0 << 3)) /* ___00___ */
-#define YYJSON_SUBTYPE_FALSE    ((uint8_t)(0 << 3)) /* ___00___ */
-#define YYJSON_SUBTYPE_TRUE     ((uint8_t)(1 << 3)) /* ___01___ */
-#define YYJSON_SUBTYPE_UINT     ((uint8_t)(0 << 3)) /* ___00___ */
-#define YYJSON_SUBTYPE_SINT     ((uint8_t)(1 << 3)) /* ___01___ */
-#define YYJSON_SUBTYPE_REAL     ((uint8_t)(2 << 3)) /* ___10___ */
-
-/** Mask and bits of JSON value. */
-#define YYJSON_TYPE_MASK        ((uint8_t)0x07)     /* _____111 */
-#define YYJSON_TYPE_BIT         ((uint8_t)3)
-#define YYJSON_SUBTYPE_MASK     ((uint8_t)0x18)     /* ___11___ */
-#define YYJSON_SUBTYPE_BIT      ((uint8_t)2)
-#define YYJSON_RESERVED_MASK    ((uint8_t)0xE0)     /* 111_____ */
-#define YYJSON_RESERVED_BIT     ((uint8_t)3)
-#define YYJSON_TAG_MASK         ((uint8_t)0xFF)     /* 11111111 */
-#define YYJSON_TAG_BIT          ((uint8_t)8)
-
-/** Padding size for JSON reader. */
-#define YYJSON_PADDING_SIZE     4
-
-
-
-/*==============================================================================
- * Allocator
- *============================================================================*/
-
-/**
- A memory allocator.
- 
- Typically you don't need to use it, unless you want to customize your own
- memory allocator.
- */
-typedef struct yyjson_alc {
-    /** Same as libc's malloc(), should not be NULL. */
-    void *(*malloc)(void *ctx, size_t size);
-    /** Same as libc's realloc(), should not be NULL. */
-    void *(*realloc)(void *ctx, void *ptr, size_t size);
-    /** Same as libc's free(), should not be NULL. */
-    void (*free)(void *ctx, void *ptr);
-    /** A context for malloc/realloc/free, can be NULL. */
-    void *ctx;
-} yyjson_alc;
-
-/**
- A pool allocator uses fixed length pre-allocated memory.
- 
- This allocator may used to avoid malloc()/memmove() calls. The pre-allocated
- memory should be held by the caller. The upper limit of memory required to
- read JSON can be calculated using the yyjson_read_max_memory_usage() function,
- but the memory required to write JSON cannot be calculated directly.
- 
- This is not a general-purpose allocator, and should only be used to read or
- write single JSON document.
- 
- @param alc The allocator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
-    If `buf` or `size` is invalid, this parameter is left unmodified.
- @param buf The buffer memory for this allocator.
-    If this parameter is NULL, the function will fail and return false.
- @param size The size of `buf`, in bytes.
-    If this parameter is less than 8 words (32/64 bytes on 32/64-bit OS), the
-    function will fail and return false.
- @return true if the `alc` has been successfully initialized.
- 
- @par Example
- @code
-    // parse JSON with stack memory
-    char buf[1024];
-    yyjson_alc alc;
-    yyjson_alc_pool_init(&alc, buf, 1024);
-    
-    const char *json = "{\"name\":\"Helvetica\",\"size\":16}"
-    yyjson_doc *doc = yyjson_read_opts(json, strlen(json), 0, &alc, NULL);
-    // the memory of `doc` is on the stack
- @endcode
- */
-yyjson_api bool yyjson_alc_pool_init(yyjson_alc *alc, void *buf, size_t size);
-
-
-
-/*==============================================================================
- * JSON Structure
- *============================================================================*/
-
-/**
- An immutable document for reading JSON.
- This document holds memory for all its JSON values and strings. When it is no
- longer used, the user should call yyjson_doc_free() to free its memory.
- */
-typedef struct yyjson_doc yyjson_doc;
-
-/**
- An immutable value for reading JSON.
- A JSON Value has the same lifetime as its document. The memory is held by its
- document and and cannot be freed alone.
- */
-typedef struct yyjson_val yyjson_val;
-
-/**
- A mutable document for building JSON.
- This document holds memory for all its JSON values and strings. When it is no
- longer used, the user should call yyjson_mut_doc_free() to free its memory.
- */
-typedef struct yyjson_mut_doc yyjson_mut_doc;
-
-/**
- A mutable value for building JSON.
- A JSON Value has the same lifetime as its document. The memory is held by its
- document and and cannot be freed alone.
- */
-typedef struct yyjson_mut_val yyjson_mut_val;
-
-
-
-/*==============================================================================
- * JSON Reader API
- *============================================================================*/
-
-/** Run-time options for JSON reader. */
-typedef uint32_t yyjson_read_flag;
-
-/** Default option (RFC 8259 compliant):
-    - Read positive integer as uint64_t.
-    - Read negative integer as int64_t.
-    - Read floating-point number as double with round-to-nearest mode.
-    - Read integer which cannot fit in uint64_t or int64_t as double.
-    - Report error if real number is infinity.
-    - Report error if string contains invalid UTF-8 character or BOM.
-    - Report error on trailing commas, comments, inf and nan literals. */
-static const yyjson_read_flag YYJSON_READ_NOFLAG                = 0 << 0;
-
-/** Read the input data in-situ.
-    This option allows the reader to modify and use input data to store string
-    values, which can increase reading speed slightly.
-    The caller should hold the input data before free the document.
-    The input data must be padded by at least `YYJSON_PADDING_SIZE` bytes.
-    For example: "[1,2]" should be "[1,2]\0\0\0\0", length should be 5. */
-static const yyjson_read_flag YYJSON_READ_INSITU                = 1 << 0;
-
-/** Stop when done instead of issuing an error if there's additional content
-    after a JSON document. This option may be used to parse small pieces of JSON
-    in larger data, such as `NDJSON`. */
-static const yyjson_read_flag YYJSON_READ_STOP_WHEN_DONE        = 1 << 1;
-
-/** Allow single trailing comma at the end of an object or array,
-    such as [1,2,3,] {"a":1,"b":2,} (non-standard). */
-static const yyjson_read_flag YYJSON_READ_ALLOW_TRAILING_COMMAS = 1 << 2;
-
-/** Allow C-style single line and multiple line comments (non-standard). */
-static const yyjson_read_flag YYJSON_READ_ALLOW_COMMENTS        = 1 << 3;
-
-/** Allow inf/nan number and literal, case-insensitive,
-    such as 1e999, NaN, inf, -Infinity (non-standard). */
-static const yyjson_read_flag YYJSON_READ_ALLOW_INF_AND_NAN     = 1 << 4;
-
-/** Read number as raw string (value with YYJSON_TYPE_RAW type),
-    inf/nan literal is also read as raw with `ALLOW_INF_AND_NAN` flag. */
-static const yyjson_read_flag YYJSON_READ_NUMBER_AS_RAW         = 1 << 5;
-
-/** Allow reading invalid unicode when parsing string values (non-standard).
-    Invalid characters will be allowed to appear in the string values, but
-    invalid escape sequences will still be reported as errors.
-    This flag does not affect the performance of correctly encoded strings.
-    
-    @warning Strings in JSON values may contain incorrect encoding when this
-    option is used, you need to handle these strings carefully to avoid security
-    risks. */
-static const yyjson_read_flag YYJSON_READ_ALLOW_INVALID_UNICODE = 1 << 6;
-
-
-
-/** Result code for JSON reader. */
-typedef uint32_t yyjson_read_code;
-
-/** Success, no error. */
-static const yyjson_read_code YYJSON_READ_SUCCESS                       = 0;
-
-/** Invalid parameter, such as NULL string or invalid file path. */
-static const yyjson_read_code YYJSON_READ_ERROR_INVALID_PARAMETER       = 1;
-
-/** Memory allocation failure occurs. */
-static const yyjson_read_code YYJSON_READ_ERROR_MEMORY_ALLOCATION       = 2;
-
-/** Input JSON string is empty. */
-static const yyjson_read_code YYJSON_READ_ERROR_EMPTY_CONTENT           = 3;
-
-/** Unexpected content after document, such as "[1]#". */
-static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_CONTENT      = 4;
-
-/** Unexpected ending, such as "[123". */
-static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_END          = 5;
-
-/** Unexpected character inside the document, such as "[#]". */
-static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_CHARACTER    = 6;
-
-/** Invalid JSON structure, such as "[1,]". */
-static const yyjson_read_code YYJSON_READ_ERROR_JSON_STRUCTURE          = 7;
-
-/** Invalid comment, such as unclosed multi-line comment. */
-static const yyjson_read_code YYJSON_READ_ERROR_INVALID_COMMENT         = 8;
-
-/** Invalid number, such as "123.e12", "000". */
-static const yyjson_read_code YYJSON_READ_ERROR_INVALID_NUMBER          = 9;
-
-/** Invalid string, such as invalid escaped character inside a string. */
-static const yyjson_read_code YYJSON_READ_ERROR_INVALID_STRING          = 10;
-
-/** Invalid JSON literal, such as "truu". */
-static const yyjson_read_code YYJSON_READ_ERROR_LITERAL                 = 11;
-
-/** Failed to open a file. */
-static const yyjson_read_code YYJSON_READ_ERROR_FILE_OPEN               = 12;
-
-/** Failed to read a file. */
-static const yyjson_read_code YYJSON_READ_ERROR_FILE_READ               = 13;
-
-/** Error information for JSON reader. */
-typedef struct yyjson_read_err {
-    /** Error code, see `yyjson_read_code` for all possible values. */
-    yyjson_read_code code;
-    /** Error message, constant, no need to free (NULL if success). */
-    const char *msg;
-    /** Error byte position for input data (0 if success). */
-    size_t pos;
-} yyjson_read_err;
-
-
-
-/**
- Read JSON with options.
- 
- This function is thread-safe when:
- 1. The `dat` is not modified by other threads.
- 2. The `alc` is thread-safe or NULL.
- 
- @param dat The JSON data (UTF-8 without BOM), null-terminator is not required.
-    If this parameter is NULL, the function will fail and return NULL.
-    The `dat` will not be modified without the flag `YYJSON_READ_INSITU`, so you
-    can pass a `const char *` string and case it to `char *` if you don't use
-    the `YYJSON_READ_INSITU` flag.
- @param len The length of JSON data in bytes.
-    If this parameter is 0, the function will fail and return NULL.
- @param flg The JSON read options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON reader.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON document, or NULL if an error occurs.
-    When it's no longer needed, it should be freed with yyjson_doc_free().
- */
-yyjson_api yyjson_doc *yyjson_read_opts(char *dat,
-                                        size_t len,
-                                        yyjson_read_flag flg,
-                                        const yyjson_alc *alc,
-                                        yyjson_read_err *err);
-
-/**
- Read a JSON file.
- 
- This function is thread-safe when:
- 1. The file is not modified by other threads.
- 2. The `alc` is thread-safe or NULL.
- 
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return NULL.
- @param flg The JSON read options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON reader.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON document, or NULL if an error occurs.
-    When it's no longer needed, it should be freed with yyjson_doc_free().
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to read.
- */
-yyjson_api yyjson_doc *yyjson_read_file(const char *path,
-                                        yyjson_read_flag flg,
-                                        const yyjson_alc *alc,
-                                        yyjson_read_err *err);
-
-/**
- Read a JSON string.
- 
- This function is thread-safe.
- 
- @param dat The JSON data (UTF-8 without BOM), null-terminator is not required.
-    If this parameter is NULL, the function will fail and return NULL.
- @param len The length of JSON data in bytes.
-    If this parameter is 0, the function will fail and return NULL.
- @param flg The JSON read options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @return A new JSON document, or NULL if an error occurs.
-    When it's no longer needed, it should be freed with yyjson_doc_free().
- */
-yyjson_api_inline yyjson_doc *yyjson_read(const char *dat,
-                                          size_t len,
-                                          yyjson_read_flag flg) {
-    flg &= ~YYJSON_READ_INSITU; /* const string cannot be modified */
-    return yyjson_read_opts((char *)dat, len, flg, NULL, NULL);
-}
-
-/**
- Returns the size of maximum memory usage to read a JSON data.
- 
- You may use this value to avoid malloc() or calloc() call inside the reader
- to get better performance, or read multiple JSON with one piece of memory.
- 
- @param len The length of JSON data in bytes.
- @param flg The JSON read options.
- @return The maximum memory size to read this JSON, or 0 if overflow.
- 
- @par Example
- @code
-    // read multiple JSON with same pre-allocated memory
-    
-    char *dat1, *dat2, *dat3; // JSON data
-    size_t len1, len2, len3; // JSON length
-    size_t max_len = MAX(len1, MAX(len2, len3));
-    yyjson_doc *doc;
-    
-    // use one allocator for multiple JSON
-    size_t size = yyjson_read_max_memory_usage(max_len, 0);
-    void *buf = malloc(size);
-    yyjson_alc alc;
-    yyjson_alc_pool_init(&alc, buf, size);
-    
-    // no more alloc() or realloc() call during reading
-    doc = yyjson_read_opts(dat1, len1, 0, &alc, NULL);
-    yyjson_doc_free(doc);
-    doc = yyjson_read_opts(dat2, len2, 0, &alc, NULL);
-    yyjson_doc_free(doc);
-    doc = yyjson_read_opts(dat3, len3, 0, &alc, NULL);
-    yyjson_doc_free(doc);
-    
-    free(buf);
- @endcode
- @see yyjson_alc_pool_init()
- */
-yyjson_api_inline size_t yyjson_read_max_memory_usage(size_t len,
-                                                      yyjson_read_flag flg) {
-    /*
-     1. The max value count is (json_size / 2 + 1),
-        for example: "[1,2,3,4]" size is 9, value count is 5.
-     2. Some broken JSON may cost more memory during reading, but fail at end,
-        for example: "[[[[[[[[".
-     3. yyjson use 16 bytes per value, see struct yyjson_val.
-     4. yyjson use dynamic memory with a growth factor of 1.5.
-     
-     The max memory size is (json_size / 2 * 16 * 1.5 + padding).
-     */
-    size_t mul = (size_t)12 + !(flg & YYJSON_READ_INSITU);
-    size_t pad = 256;
-    size_t max = (size_t)(~(size_t)0);
-    if (flg & YYJSON_READ_STOP_WHEN_DONE) len = len < 256 ? 256 : len;
-    if (len >= (max - pad - mul) / mul) return 0;
-    return len * mul + pad;
-}
-
-
-
-/*==============================================================================
- * JSON Writer API
- *============================================================================*/
-
-/** Run-time options for JSON writer. */
-typedef uint32_t yyjson_write_flag;
-
-/** Default option:
-    - Write JSON minify.
-    - Report error on inf or nan number.
-    - Report error on invalid UTF-8 string.
-    - Do not escape unicode or slash. */
-static const yyjson_write_flag YYJSON_WRITE_NOFLAG                  = 0 << 0;
-
-/** Write JSON pretty with 4 space indent. */
-static const yyjson_write_flag YYJSON_WRITE_PRETTY                  = 1 << 0;
-
-/** Escape unicode as `uXXXX`, make the output ASCII only. */
-static const yyjson_write_flag YYJSON_WRITE_ESCAPE_UNICODE          = 1 << 1;
-
-/** Escape '/' as '\/'. */
-static const yyjson_write_flag YYJSON_WRITE_ESCAPE_SLASHES          = 1 << 2;
-
-/** Write inf and nan number as 'Infinity' and 'NaN' literal (non-standard). */
-static const yyjson_write_flag YYJSON_WRITE_ALLOW_INF_AND_NAN       = 1 << 3;
-
-/** Write inf and nan number as null literal.
-    This flag will override `YYJSON_WRITE_ALLOW_INF_AND_NAN` flag. */
-static const yyjson_write_flag YYJSON_WRITE_INF_AND_NAN_AS_NULL     = 1 << 4;
-
-/** Allow invalid unicode when encoding string values (non-standard).
-    Invalid characters in string value will be copied byte by byte.
-    If `YYJSON_WRITE_ESCAPE_UNICODE` flag is also set, invalid character will be
-    escaped as `U+FFFD` (replacement character).
-    This flag does not affect the performance of correctly encoded strings. */
-static const yyjson_read_flag YYJSON_WRITE_ALLOW_INVALID_UNICODE    = 1 << 5;
-
-
-
-/** Result code for JSON writer */
-typedef uint32_t yyjson_write_code;
-
-/** Success, no error. */
-static const yyjson_write_code YYJSON_WRITE_SUCCESS                     = 0;
-
-/** Invalid parameter, such as NULL document. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_PARAMETER     = 1;
-
-/** Memory allocation failure occurs. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_MEMORY_ALLOCATION     = 2;
-
-/** Invalid value type in JSON document. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_VALUE_TYPE    = 3;
-
-/** NaN or Infinity number occurs. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_NAN_OR_INF            = 4;
-
-/** Failed to open a file. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_OPEN             = 5;
-
-/** Failed to write a file. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_WRITE            = 6;
-
-/** Invalid unicode in string. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_STRING        = 7;
-
-/** Error information for JSON writer. */
-typedef struct yyjson_write_err {
-    /** Error code, see `yyjson_write_code` for all possible values. */
-    yyjson_write_code code;
-    /** Error message, constant, no need to free (NULL if success). */
-    const char *msg;
-} yyjson_write_err;
-
-
-
-/*==============================================================================
- * JSON Document Writer API
- *============================================================================*/
-
-/**
- Write a document to JSON string with options.
- 
- This function is thread-safe when:
- The `alc` is thread-safe or NULL.
- 
- @param doc The JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param len A pointer to receive output length in bytes.
-    Pass NULL if you don't need length information.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free() or alc->free().
- */
-yyjson_api char *yyjson_write_opts(const yyjson_doc *doc,
-                                   yyjson_write_flag flg,
-                                   const yyjson_alc *alc,
-                                   size_t *len,
-                                   yyjson_write_err *err);
-
-/**
- Write a document to JSON file with options.
- 
- This function is thread-safe when:
- 1. The file is not accessed by other threads.
- 2. The `alc` is thread-safe or NULL.
-
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return false.
-    If this file is not empty, the content will be discarded.
- @param doc The JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_write_file(const char *path,
-                                  const yyjson_doc *doc,
-                                  yyjson_write_flag flg,
-                                  const yyjson_alc *alc,
-                                  yyjson_write_err *err);
-
-/**
- Write a document to JSON string.
- 
- This function is thread-safe.
- 
- @param doc The JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param len A pointer to receive output length in bytes.
-    Pass NULL if you don't need length information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free().
- */
-yyjson_api_inline char *yyjson_write(const yyjson_doc *doc,
-                                     yyjson_write_flag flg,
-                                     size_t *len) {
-    return yyjson_write_opts(doc, flg, NULL, len, NULL);
-}
-
-
-
-/**
- Write a document to JSON string with options.
- 
- This function is thread-safe when:
- 1. The `doc` is not modified by other threads.
- 2. The `alc` is thread-safe or NULL.
-
- @param doc The mutable JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param len A pointer to receive output length in bytes.
-    Pass NULL if you don't need length information.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free() or alc->free().
- */
-yyjson_api char *yyjson_mut_write_opts(const yyjson_mut_doc *doc,
-                                       yyjson_write_flag flg,
-                                       const yyjson_alc *alc,
-                                       size_t *len,
-                                       yyjson_write_err *err);
-
-/**
- Write a document to JSON file with options.
- 
- This function is thread-safe when:
- 1. The file is not accessed by other threads.
- 2. The `doc` is not modified by other threads.
- 3. The `alc` is thread-safe or NULL.
- 
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return false.
-    If this file is not empty, the content will be discarded.
- @param doc The mutable JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_mut_write_file(const char *path,
-                                      const yyjson_mut_doc *doc,
-                                      yyjson_write_flag flg,
-                                      const yyjson_alc *alc,
-                                      yyjson_write_err *err);
-
-/**
- Write a document to JSON string.
- 
- This function is thread-safe when:
- The `doc` is not is not modified by other threads.
- 
- @param doc The JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param len A pointer to receive output length in bytes.
-    Pass NULL if you don't need length information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free().
- */
-yyjson_api_inline char *yyjson_mut_write(const yyjson_mut_doc *doc,
-                                         yyjson_write_flag flg,
-                                         size_t *len) {
-    return yyjson_mut_write_opts(doc, flg, NULL, len, NULL);
-}
-
-
-
-/*==============================================================================
- * JSON Value Writer API
- *============================================================================*/
-
-/**
- Write a value to JSON string with options.
- 
- This function is thread-safe when:
- The `alc` is thread-safe or NULL.
- 
- @param val The JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param len A pointer to receive output length in bytes.
-    Pass NULL if you don't need length information.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free() or alc->free().
- */
-yyjson_api char *yyjson_val_write_opts(const yyjson_val *val,
-                                       yyjson_write_flag flg,
-                                       const yyjson_alc *alc,
-                                       size_t *len,
-                                       yyjson_write_err *err);
-
-/**
- Write a value to JSON file with options.
- 
- This function is thread-safe when:
- 1. The file is not accessed by other threads.
- 2. The `alc` is thread-safe or NULL.
- 
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return false.
-    If this file is not empty, the content will be discarded.
- @param val The JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_val_write_file(const char *path,
-                                      const yyjson_val *val,
-                                      yyjson_write_flag flg,
-                                      const yyjson_alc *alc,
-                                      yyjson_write_err *err);
-
-/**
- Write a value to JSON string.
- 
- This function is thread-safe.
- 
- @param val The JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param len A pointer to receive output length in bytes.
-    Pass NULL if you don't need length information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free().
- */
-yyjson_api_inline char *yyjson_val_write(const yyjson_val *val,
-                                         yyjson_write_flag flg,
-                                         size_t *len) {
-    return yyjson_val_write_opts(val, flg, NULL, len, NULL);
-}
-
-/**
- Write a value to JSON string with options.
- 
- This function is thread-safe when:
- 1. The `val` is not modified by other threads.
- 2. The `alc` is thread-safe or NULL.
- 
- @param val The mutable JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param len A pointer to receive output length in bytes.
-    Pass NULL if you don't need length information.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return  A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free() or alc->free().
- */
-yyjson_api char *yyjson_mut_val_write_opts(const yyjson_mut_val *val,
-                                           yyjson_write_flag flg,
-                                           const yyjson_alc *alc,
-                                           size_t *len,
-                                           yyjson_write_err *err);
-
-/**
- Write a value to JSON file with options.
- 
- This function is thread-safe when:
- 1. The file is not accessed by other threads.
- 2. The `val` is not modified by other threads.
- 3. The `alc` is thread-safe or NULL.
- 
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return false.
-    If this file is not empty, the content will be discarded.
- @param val The mutable JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_mut_val_write_file(const char *path,
-                                          const yyjson_mut_val *val,
-                                          yyjson_write_flag flg,
-                                          const yyjson_alc *alc,
-                                          yyjson_write_err *err);
-
-/**
- Write a value to JSON string.
- 
- This function is thread-safe when:
- The `val` is not is not modified by other threads.
- 
- @param val The JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param len A pointer to receive output length in bytes.
-    Pass NULL if you don't need length information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free().
- */
-yyjson_api_inline char *yyjson_mut_val_write(const yyjson_mut_val *val,
-                                             yyjson_write_flag flg,
-                                             size_t *len) {
-    return yyjson_mut_val_write_opts(val, flg, NULL, len, NULL);
-}
-
-
-
-/*==============================================================================
- * JSON Document API
- *============================================================================*/
-
-/** Returns the root value of this JSON document.
-    Returns NULL if `doc` is NULL. */
-yyjson_api_inline yyjson_val *yyjson_doc_get_root(yyjson_doc *doc);
-
-/** Returns read size of input JSON data.
-    Returns 0 if `doc` is NULL.
-    For example: the read size of "[1,2,3]" is 7 bytes.  */
-yyjson_api_inline size_t yyjson_doc_get_read_size(yyjson_doc *doc);
-
-/** Returns total value count in this JSON document.
-    Returns 0 if `doc` is NULL.
-    For example: the value count of "[1,2,3]" is 4. */
-yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc);
-
-/** Release the JSON document and free the memory.
-    After calling this function, the `doc` and all values from the `doc` are no
-    longer available. This function will do nothing if the `doc` is NULL. */
-yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc);
-
-
-
-/*==============================================================================
- * JSON Value Type API
- *============================================================================*/
-
-/** Returns whether the JSON value is raw.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_raw(yyjson_val *val);
-
-/** Returns whether the JSON value is `null`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_null(yyjson_val *val);
-
-/** Returns whether the JSON value is `true`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_true(yyjson_val *val);
-
-/** Returns whether the JSON value is `false`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_false(yyjson_val *val);
-
-/** Returns whether the JSON value is bool (true/false).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_bool(yyjson_val *val);
-
-/** Returns whether the JSON value is unsigned integer (uint64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_uint(yyjson_val *val);
-
-/** Returns whether the JSON value is signed integer (int64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_sint(yyjson_val *val);
-
-/** Returns whether the JSON value is integer (uint64_t/int64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_int(yyjson_val *val);
-
-/** Returns whether the JSON value is real number (double).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_real(yyjson_val *val);
-
-/** Returns whether the JSON value is number (uint64_t/int64_t/double).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_num(yyjson_val *val);
-
-/** Returns whether the JSON value is string.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_str(yyjson_val *val);
-
-/** Returns whether the JSON value is array.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_arr(yyjson_val *val);
-
-/** Returns whether the JSON value is object.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_obj(yyjson_val *val);
-
-/** Returns whether the JSON value is container (array/object).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_ctn(yyjson_val *val);
-
-
-
-/*==============================================================================
- * JSON Value Content API
- *============================================================================*/
-
-/** Returns the JSON value's type.
-    Returns YYJSON_TYPE_NONE if `val` is NULL. */
-yyjson_api_inline yyjson_type yyjson_get_type(yyjson_val *val);
-
-/** Returns the JSON value's subtype.
-    Returns YYJSON_SUBTYPE_NONE if `val` is NULL. */
-yyjson_api_inline yyjson_subtype yyjson_get_subtype(yyjson_val *val);
-
-/** Returns the JSON value's tag.
-    Returns 0 if `val` is NULL. */
-yyjson_api_inline uint8_t yyjson_get_tag(yyjson_val *val);
-
-/** Returns the JSON value's type description.
-    The return value should be one of these strings: "raw", "null", "string",
-    "array", "object", "true", "false", "uint", "sint", "real", "unknown". */
-yyjson_api_inline const char *yyjson_get_type_desc(yyjson_val *val);
-
-/** Returns the content if the value is raw.
-    Returns NULL if `val` is NULL or type is not raw. */
-yyjson_api_inline const char *yyjson_get_raw(yyjson_val *val);
-
-/** Returns the content if the value is bool.
-    Returns NULL if `val` is NULL or type is not bool. */
-yyjson_api_inline bool yyjson_get_bool(yyjson_val *val);
-
-/** Returns the content and cast to uint64_t.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline uint64_t yyjson_get_uint(yyjson_val *val);
-
-/** Returns the content and cast to int64_t.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline int64_t yyjson_get_sint(yyjson_val *val);
-
-/** Returns the content and cast to int.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline int yyjson_get_int(yyjson_val *val);
-
-/** Returns the content if the value is real number, or 0.0 on error.
-    Returns 0.0 if `val` is NULL or type is not real(double). */
-yyjson_api_inline double yyjson_get_real(yyjson_val *val);
-
-/** Returns the content if the value is string.
-    Returns NULL if `val` is NULL or type is not string. */
-yyjson_api_inline const char *yyjson_get_str(yyjson_val *val);
-
-/** Returns the content length (string length, array size, object size.
-    Returns 0 if `val` is NULL or type is not string/array/object. */
-yyjson_api_inline size_t yyjson_get_len(yyjson_val *val);
-
-/** Returns whether the JSON value is equals to a string.
-    Returns false if input is NULL or type is not string. */
-yyjson_api_inline bool yyjson_equals_str(yyjson_val *val, const char *str);
-
-/** Returns whether the JSON value is equals to a string.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    Returns false if input is NULL or type is not string. */
-yyjson_api_inline bool yyjson_equals_strn(yyjson_val *val, const char *str,
-                                          size_t len);
-
-/** Returns whether two JSON values are equal (deep compare).
-    Returns false if input is NULL. */
-yyjson_api_inline bool yyjson_equals(yyjson_val *lhs, yyjson_val *rhs);
-
-
-
-/*==============================================================================
- * JSON Array API
- *============================================================================*/
-
-/** Returns the number of elements in this array.
-    Returns 0 if `arr` is NULL or type is not array. */
-yyjson_api_inline size_t yyjson_arr_size(yyjson_val *arr);
-
-/** Returns the element at the specified position in this array.
-    Returns NULL if array is NULL/empty or the index is out of bounds.
-    @warning This function takes a linear search time if array is not flat.
-        For example: [1,{},3] is flat, [1,[2],3] is not flat. */
-yyjson_api_inline yyjson_val *yyjson_arr_get(yyjson_val *arr, size_t idx);
-
-/** Returns the first element of this array.
-    Returns NULL if `arr` is NULL/empty or type is not array. */
-yyjson_api_inline yyjson_val *yyjson_arr_get_first(yyjson_val *arr);
-
-/** Returns the last element of this array.
-    Returns NULL if `arr` is NULL/empty or type is not array.
-    @warning This function takes a linear search time if array is not flat.
-        For example: [1,{},3] is flat, [1,[2],3] is not flat.*/
-yyjson_api_inline yyjson_val *yyjson_arr_get_last(yyjson_val *arr);
-
-
-
-/*==============================================================================
- * JSON Array Iterator API
- *============================================================================*/
-
-/**
- A JSON array iterator.
- 
- @par Example
- @code
-    yyjson_val *val;
-    yyjson_arr_iter iter;
-    yyjson_arr_iter_init(arr, &iter);
-    while ((val = yyjson_arr_iter_next(&iter))) {
-        your_func(val);
-    }
- @endcode
- */
-typedef struct yyjson_arr_iter yyjson_arr_iter;
-
-/**
- Initialize an iterator for this array.
- 
- @param arr The array to be iterated over.
-    If this parameter is NULL or not an array, `iter` will be set to empty.
- @param iter The iterator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
- @return true if the `iter` has been successfully initialized.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val *arr,
-                                            yyjson_arr_iter *iter);
-
-/**
- Returns whether the iteration has more elements.
- If `iter` is NULL, this function will return false.
- */
-yyjson_api_inline bool yyjson_arr_iter_has_next(yyjson_arr_iter *iter);
-
-/**
- Returns the next element in the iteration, or NULL on end.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_val *yyjson_arr_iter_next(yyjson_arr_iter *iter);
-
-/**
- Macro for iterating over an array.
- It works like iterator, but with a more intuitive API.
- 
- @par Example
- @code
-    size_t idx, max;
-    yyjson_val *val;
-    yyjson_arr_foreach(arr, idx, max, val) {
-        your_func(idx, val);
-    }
- @endcode
- */
-#define yyjson_arr_foreach(arr, idx, max, val) \
-    for ((idx) = 0, \
-        (max) = yyjson_arr_size(arr), \
-        (val) = yyjson_arr_get_first(arr); \
-        (idx) < (max); \
-        (idx)++, \
-        (val) = unsafe_yyjson_get_next(val))
-
-
-
-/*==============================================================================
- * JSON Object API
- *============================================================================*/
-
-/** Returns the number of key-value pairs in this object.
-    Returns 0 if `obj` is NULL or type is not object. */
-yyjson_api_inline size_t yyjson_obj_size(yyjson_val *obj);
-
-/** Returns the value to which the specified key is mapped.
-    Returns NULL if this object contains no mapping for the key.
-    Returns NULL if `obj/key` is NULL, or type is not object.
-    
-    The `key` should be a null-terminated UTF-8 string.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_val *yyjson_obj_get(yyjson_val *obj, const char *key);
-
-/** Returns the value to which the specified key is mapped.
-    Returns NULL if this object contains no mapping for the key.
-    Returns NULL if `obj/key` is NULL, or type is not object.
-    
-    The `key` should be a UTF-8 string, null-terminator is not required.
-    The `key_len` should be the length of the key, in bytes.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_val *yyjson_obj_getn(yyjson_val *obj, const char *key,
-                                              size_t key_len);
-
-
-
-/*==============================================================================
- * JSON Object Iterator API
- *============================================================================*/
-
-/**
- A JSON object iterator.
- 
- @par Example
- @code
-    yyjson_val *key, *val;
-    yyjson_obj_iter iter;
-    yyjson_obj_iter_init(obj, &iter);
-    while ((key = yyjson_obj_iter_next(&iter))) {
-        val = yyjson_obj_iter_get_val(key);
-        your_func(key, val);
-    }
- @endcode
- 
- If the ordering of the keys is known at compile-time, you can use this method
- to speed up value lookups:
- @code
-    // {"k1":1, "k2": 3, "k3": 3}
-    yyjson_val *key, *val;
-    yyjson_obj_iter iter;
-    yyjson_obj_iter_init(obj, &iter);
-    yyjson_val *v1 = yyjson_obj_iter_get(&iter, "k1");
-    yyjson_val *v3 = yyjson_obj_iter_get(&iter, "k3");
- @endcode
- @see yyjson_obj_iter_get() and yyjson_obj_iter_getn()
- */
-typedef struct yyjson_obj_iter yyjson_obj_iter;
-
-/**
- Initialize an iterator for this object.
- 
- @param obj The object to be iterated over.
-    If this parameter is NULL or not an object, `iter` will be set to empty.
- @param iter The iterator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
- @return true if the `iter` has been successfully initialized.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val *obj,
-                                            yyjson_obj_iter *iter);
-
-/**
- Returns whether the iteration has more elements.
- If `iter` is NULL, this function will return false.
- */
-yyjson_api_inline bool yyjson_obj_iter_has_next(yyjson_obj_iter *iter);
-
-/**
- Returns the next key in the iteration, or NULL on end.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_val *yyjson_obj_iter_next(yyjson_obj_iter *iter);
-
-/**
- Returns the value for key inside the iteration.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_val *yyjson_obj_iter_get_val(yyjson_val *key);
-
-/**
- Iterates to a specified key and returns the value.
- 
- This function does the same thing as yyjson_obj_get(), but is much faster
- if the ordering of the keys is known at compile-time and you are using the same
- order to look up the values. If the key exists in this object, then the
- iterator will stop at the next key, otherwise the iterator will not change and
- NULL is returned.
- 
- @param iter The object iterator, should not be NULL.
- @param key The key, should be a UTF-8 string with null-terminator.
- @return The value to which the specified key is mapped.
-    NULL if this object contains no mapping for the key or input is invalid.
- 
- @warning This function takes a linear search time if the key is not nearby.
- */
-yyjson_api_inline yyjson_val *yyjson_obj_iter_get(yyjson_obj_iter *iter,
-                                                  const char *key);
-
-/**
- Iterates to a specified key and returns the value.
-
- This function does the same thing as yyjson_obj_getn(), but is much faster
- if the ordering of the keys is known at compile-time and you are using the same
- order to look up the values. If the key exists in this object, then the
- iterator will stop at the next key, otherwise the iterator will not change and
- NULL is returned.
- 
- @param iter The object iterator, should not be NULL.
- @param key The key, should be a UTF-8 string, null-terminator is not required.
- @param key_len The the length of `key`, in bytes.
- @return The value to which the specified key is mapped.
-    NULL if this object contains no mapping for the key or input is invalid.
- 
- @warning This function takes a linear search time if the key is not nearby.
- */
-yyjson_api_inline yyjson_val *yyjson_obj_iter_getn(yyjson_obj_iter *iter,
-                                                   const char *key,
-                                                   size_t key_len);
-
-/**
- Macro for iterating over an object.
- It works like iterator, but with a more intuitive API.
- 
- @par Example
- @code
-    size_t idx, max;
-    yyjson_val *key, *val;
-    yyjson_obj_foreach(obj, idx, max, key, val) {
-        your_func(key, val);
-    }
- @endcode
- */
-#define yyjson_obj_foreach(obj, idx, max, key, val) \
-    for ((idx) = 0, \
-        (max) = yyjson_obj_size(obj), \
-        (key) = (obj) ? unsafe_yyjson_get_first(obj) : NULL, \
-        (val) = (key) + 1; \
-        (idx) < (max); \
-        (idx)++, \
-        (key) = unsafe_yyjson_get_next(val), \
-        (val) = (key) + 1)
-
-
-
-/*==============================================================================
- * Mutable JSON Document API
- *============================================================================*/
-
-/** Returns the root value of this JSON document.
-    Returns NULL if `doc` is NULL. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_root(yyjson_mut_doc *doc);
-
-/** Sets the root value of this JSON document.
-    Pass NULL to clear root value of the document. */
-yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *root);
-
-/** Release the JSON document and free the memory.
-    After calling this function, the `doc` and all values from the `doc` are no
-    longer available. This function will do nothing if the `doc` is NULL.  */
-yyjson_api void yyjson_mut_doc_free(yyjson_mut_doc *doc);
-
-/** Creates and returns a new mutable JSON document, returns NULL on error.
-    If allocator is NULL, the default allocator will be used. */
-yyjson_api yyjson_mut_doc *yyjson_mut_doc_new(const yyjson_alc *alc);
-
-/** Copies and returns a new mutable document from input, returns NULL on error.
-    This makes a `deep-copy` on the immutable document.
-    If allocator is NULL, the default allocator will be used. */
-yyjson_api yyjson_mut_doc *yyjson_doc_mut_copy(yyjson_doc *doc,
-                                               const yyjson_alc *alc);
-
-/** Copies and returns a new mutable document from input, returns NULL on error.
-    This makes a `deep-copy` on the mutable document.
-    If allocator is NULL, the default allocator will be used. */
-yyjson_api yyjson_mut_doc *yyjson_mut_doc_mut_copy(yyjson_mut_doc *doc,
-                                                   const yyjson_alc *alc);
-
-/** Copies and returns a new mutable value from input, returns NULL on error.
-    This makes a `deep-copy` on the immutable value.
-    The memory was managed by mutable document. */
-yyjson_api yyjson_mut_val *yyjson_val_mut_copy(yyjson_mut_doc *doc,
-                                               yyjson_val *val);
-
-/** Copies and return a new mutable value from input, returns NULL on error,
-    This makes a `deep-copy` on the mutable value.
-    The memory was managed by mutable document.
-    
-    @warning This function is recursive and may cause a stack overflow
-        if the object level is too deep. */
-yyjson_api yyjson_mut_val *yyjson_mut_val_mut_copy(yyjson_mut_doc *doc,
-                                                   yyjson_mut_val *val);
-
-
-
-/*==============================================================================
- * Mutable JSON Value Type API
- *============================================================================*/
-
-/** Returns whether the JSON value is raw.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_raw(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is `null`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_null(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is `true`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_true(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is `false`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_false(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is bool (true/false).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_bool(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is unsigned integer (uint64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_uint(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is signed integer (int64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_sint(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is integer (uint64_t/int64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_int(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is real number (double).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_real(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is number (uint/sint/real).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_num(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is string.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_str(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is array.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_arr(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is object.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_obj(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is container (array/object).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_ctn(yyjson_mut_val *val);
-
-
-
-/*==============================================================================
- * Mutable JSON Value Content API
- *============================================================================*/
-
-/** Returns the JSON value's type.
-    Returns YYJSON_TYPE_NONE if `val` is NULL. */
-yyjson_api_inline yyjson_type yyjson_mut_get_type(yyjson_mut_val *val);
-
-/** Returns the JSON value's subtype.
-    Returns YYJSON_SUBTYPE_NONE if `val` is NULL. */
-yyjson_api_inline yyjson_subtype yyjson_mut_get_subtype(yyjson_mut_val *val);
-
-/** Returns the JSON value's tag.
-    Returns 0 if `val` is NULL. */
-yyjson_api_inline uint8_t yyjson_mut_get_tag(yyjson_mut_val *val);
-
-/** Returns the JSON value's type description.
-    The return value should be one of these strings: "raw", "null", "string",
-    "array", "object", "true", "false", "uint", "sint", "real", "unknown". */
-yyjson_api_inline const char *yyjson_mut_get_type_desc(yyjson_mut_val *val);
-
-/** Returns the content if the value is raw.
-    Returns NULL if `val` is NULL or type is not raw. */
-yyjson_api_inline const char *yyjson_mut_get_raw(yyjson_mut_val *val);
-
-/** Returns the content if the value is bool.
-    Returns NULL if `val` is NULL or type is not bool. */
-yyjson_api_inline bool yyjson_mut_get_bool(yyjson_mut_val *val);
-
-/** Returns the content and cast to uint64_t.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline uint64_t yyjson_mut_get_uint(yyjson_mut_val *val);
-
-/** Returns the content and cast to int64_t.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline int64_t yyjson_mut_get_sint(yyjson_mut_val *val);
-
-/** Returns the content and cast to int.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline int yyjson_mut_get_int(yyjson_mut_val *val);
-
-/** Returns the content if the value is real number.
-    Returns 0.0 if `val` is NULL or type is not real(double). */
-yyjson_api_inline double yyjson_mut_get_real(yyjson_mut_val *val);
-
-/** Returns the content if the value is string.
-    Returns NULL if `val` is NULL or type is not string. */
-yyjson_api_inline const char *yyjson_mut_get_str(yyjson_mut_val *val);
-
-/** Returns the content length (string length, array size, object size.
-    Returns 0 if `val` is NULL or type is not string/array/object. */
-yyjson_api_inline size_t yyjson_mut_get_len(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is equals to a string.
-    The `str` should be a null-terminated UTF-8 string.
-    Returns false if input is NULL or type is not string. */
-yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val *val,
-                                             const char *str);
-
-/** Returns whether the JSON value is equals to a string.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    Returns false if input is NULL or type is not string. */
-yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val *val,
-                                              const char *str, size_t len);
-
-/** Returns whether two JSON values are equal (deep compare).
-    Returns false if input is NULL.
-    
-    @warning This function is recursive and may cause a stack overflow
-        if the object level is too deep. */
-yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val *lhs,
-                                         yyjson_mut_val *rhs);
-
-
-
-/*==============================================================================
- * Mutable JSON Value Creation API
- *============================================================================*/
-
-/** Creates and returns a raw value, returns NULL on error.
-    The `str` should be a null-terminated UTF-8 string.
-    
-    @warning The input string is not copied, you should keep this string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_raw(yyjson_mut_doc *doc,
-                                                 const char *str);
-
-/** Creates and returns a raw value, returns NULL on error.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    
-    @warning The input string is not copied, you should keep this string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawn(yyjson_mut_doc *doc,
-                                                  const char *str,
-                                                  size_t len);
-
-/** Creates and returns a raw value, returns NULL on error.
-    The `str` should be a null-terminated UTF-8 string.
-    The input string is copied and held by the document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawcpy(yyjson_mut_doc *doc,
-                                                    const char *str);
-
-/** Creates and returns a raw value, returns NULL on error.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    The input string is copied and held by the document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawncpy(yyjson_mut_doc *doc,
-                                                     const char *str,
-                                                     size_t len);
-
-/** Creates and returns a null value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_null(yyjson_mut_doc *doc);
-
-/** Creates and returns a true value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_true(yyjson_mut_doc *doc);
-
-/** Creates and returns a false value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_false(yyjson_mut_doc *doc);
-
-/** Creates and returns a bool value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc,
-                                                  bool val);
-
-/** Creates and returns an unsigned integer value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_uint(yyjson_mut_doc *doc,
-                                                  uint64_t num);
-
-/** Creates and returns a signed integer value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_sint(yyjson_mut_doc *doc,
-                                                  int64_t num);
-
-/** Creates and returns a signed integer value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_int(yyjson_mut_doc *doc,
-                                                 int64_t num);
-
-/** Creates and returns an real number value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_real(yyjson_mut_doc *doc,
-                                                  double num);
-
-/** Creates and returns a string value, returns NULL on error.
-    The `str` should be a null-terminated UTF-8 string.
-    @warning The input string is not copied, you should keep this string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_str(yyjson_mut_doc *doc,
-                                                 const char *str);
-
-/** Creates and returns a string value, returns NULL on error.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    @warning The input string is not copied, you should keep this string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strn(yyjson_mut_doc *doc,
-                                                  const char *str,
-                                                  size_t len);
-
-/** Creates and returns a string value, returns NULL on error.
-    The `str` should be a null-terminated UTF-8 string.
-    The input string is copied and held by the document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strcpy(yyjson_mut_doc *doc,
-                                                    const char *str);
-
-/** Creates and returns a string value, returns NULL on error.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    The input string is copied and held by the document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strncpy(yyjson_mut_doc *doc,
-                                                     const char *str,
-                                                     size_t len);
-
-
-
-/*==============================================================================
- * Mutable JSON Array API
- *============================================================================*/
-
-/** Returns the number of elements in this array.
-    Returns 0 if `arr` is NULL or type is not array. */
-yyjson_api_inline size_t yyjson_mut_arr_size(yyjson_mut_val *arr);
-
-/** Returns the element at the specified position in this array.
-    Returns NULL if array is NULL/empty or the index is out of bounds.
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get(yyjson_mut_val *arr,
-                                                     size_t idx);
-
-/** Returns the first element of this array.
-    Returns NULL if `arr` is NULL/empty or type is not array. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_first(yyjson_mut_val *arr);
-
-/** Returns the last element of this array.
-    Returns NULL if `arr` is NULL/empty or type is not array. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_last(yyjson_mut_val *arr);
-
-
-
-/*==============================================================================
- * Mutable JSON Array Iterator API
- *============================================================================*/
-
-/**
- A mutable JSON array iterator.
- 
- @warning You should not modify the array while iterating over it, but you can
-    use yyjson_mut_arr_iter_remove() to remove current value.
- 
- @par Example
- @code
-    yyjson_mut_val *val;
-    yyjson_mut_arr_iter iter;
-    yyjson_mut_arr_iter_init(arr, &iter);
-    while ((val = yyjson_mut_arr_iter_next(&iter))) {
-        your_func(val);
-        if (your_val_is_unused(val)) {
-            yyjson_mut_arr_iter_remove(&iter);
-        }
-    }
- @endcode
- */
-typedef struct yyjson_mut_arr_iter yyjson_mut_arr_iter;
-
-/**
- Initialize an iterator for this array.
- 
- @param arr The array to be iterated over.
-    If this parameter is NULL or not an array, `iter` will be set to empty.
- @param iter The iterator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
- @return true if the `iter` has been successfully initialized.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val *arr,
-    yyjson_mut_arr_iter *iter);
-
-/**
- Returns whether the iteration has more elements.
- If `iter` is NULL, this function will return false.
- */
-yyjson_api_inline bool yyjson_mut_arr_iter_has_next(
-    yyjson_mut_arr_iter *iter);
-
-/**
- Returns the next element in the iteration, or NULL on end.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_next(
-    yyjson_mut_arr_iter *iter);
-
-/**
- Removes and returns current element in the iteration.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_remove(
-    yyjson_mut_arr_iter *iter);
-
-/**
- Macro for iterating over an array.
- It works like iterator, but with a more intuitive API.
- 
- @warning You should not modify the array while iterating over it.
- 
- @par Example
- @code
-    size_t idx, max;
-    yyjson_mut_val *val;
-    yyjson_mut_arr_foreach(arr, idx, max, val) {
-        your_func(idx, val);
-    }
- @endcode
- */
-#define yyjson_mut_arr_foreach(arr, idx, max, val) \
-    for ((idx) = 0, \
-        (max) = yyjson_mut_arr_size(arr), \
-        (val) = yyjson_mut_arr_get_first(arr); \
-        (idx) < (max); \
-        (idx)++, \
-        (val) = (val)->next)
-
-
-
-/*==============================================================================
- * Mutable JSON Array Creation API
- *============================================================================*/
-
-/**
- Creates and returns an empty mutable array.
- @param doc A mutable document, used for memory allocation only.
- @return The new array. NULL if input is NULL or memory allocation failed.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc);
-
-/**
- Creates and returns a new mutable array with the given boolean values.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of boolean values.
- @param count The value count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const bool vals[3] = { true, false, true };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_bool(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool(
-    yyjson_mut_doc *doc, const bool *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given sint numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of sint numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int64_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint(
-    yyjson_mut_doc *doc, const int64_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const uint64_t vals[3] = { 0, 1, 0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_uint(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint(
-    yyjson_mut_doc *doc, const uint64_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given real numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of real numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const double vals[3] = { 0.1, 0.2, 0.3 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_real(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_real(
-    yyjson_mut_doc *doc, const double *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given int8 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of int8 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int8_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint8(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint8(
-    yyjson_mut_doc *doc, const int8_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given int16 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of int16 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int16_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint16(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint16(
-    yyjson_mut_doc *doc, const int16_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given int32 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of int32 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int32_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint32(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint32(
-    yyjson_mut_doc *doc, const int32_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given int64 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of int64 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int64_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint64(
-    yyjson_mut_doc *doc, const int64_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint8 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint8 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const uint8_t vals[3] = { 0, 1, 0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_uint8(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint8(
-    yyjson_mut_doc *doc, const uint8_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint16 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint16 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const uint16_t vals[3] = { 0, 1, 0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_uint16(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint16(
-    yyjson_mut_doc *doc, const uint16_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint32 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint32 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const uint32_t vals[3] = { 0, 1, 0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_uint32(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint32(
-    yyjson_mut_doc *doc, const uint32_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint64 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint64 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-     const uint64_t vals[3] = { 0, 1, 0 };
-     yyjson_mut_val *arr = yyjson_mut_arr_with_uint64(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint64(
-    yyjson_mut_doc *doc, const uint64_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given float numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of float numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const float vals[3] = { -1.0f, 0.0f, 1.0f };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_float(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_float(
-    yyjson_mut_doc *doc, const float *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given double numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of double numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const double vals[3] = { -1.0, 0.0, 1.0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_double(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_double(
-    yyjson_mut_doc *doc, const double *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given strings, these strings
- will not be copied.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of UTF-8 null-terminator strings.
-    If this array contains NULL, the function will fail and return NULL.
- @param count The number of values in `vals`.
-    If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @warning The input strings are not copied, you should keep these strings
-    unmodified for the lifetime of this JSON document. If these strings will be
-    modified, you should use yyjson_mut_arr_with_strcpy() instead.
- 
- @par Example
- @code
-    const char *vals[3] = { "a", "b", "c" };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_str(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_str(
-    yyjson_mut_doc *doc, const char **vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given strings and string
- lengths, these strings will not be copied.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of UTF-8 strings, null-terminator is not required.
-    If this array contains NULL, the function will fail and return NULL.
- @param lens A C array of string lengths, in bytes.
- @param count The number of strings in `vals`.
-    If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @warning The input strings are not copied, you should keep these strings
-    unmodified for the lifetime of this JSON document. If these strings will be
-    modified, you should use yyjson_mut_arr_with_strncpy() instead.
- 
- @par Example
- @code
-    const char *vals[3] = { "a", "bb", "c" };
-    const size_t lens[3] = { 1, 2, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_strn(doc, vals, lens, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strn(
-    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
-
-/**
- Creates and returns a new mutable array with the given strings, these strings
- will be copied.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of UTF-8 null-terminator strings.
-    If this array contains NULL, the function will fail and return NULL.
- @param count The number of values in `vals`.
-    If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const char *vals[3] = { "a", "b", "c" };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_strcpy(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strcpy(
-    yyjson_mut_doc *doc, const char **vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given strings and string
- lengths, these strings will be copied.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of UTF-8 strings, null-terminator is not required.
-    If this array contains NULL, the function will fail and return NULL.
- @param lens A C array of string lengths, in bytes.
- @param count The number of strings in `vals`.
-    If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const char *vals[3] = { "a", "bb", "c" };
-    const size_t lens[3] = { 1, 2, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_strn(doc, vals, lens, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strncpy(
-    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
-
-
-
-/*==============================================================================
- * Mutable JSON Array Modification API
- *============================================================================*/
-
-/**
- Inserts a value into an array at a given index.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The value to be inserted. Returns false if it is NULL.
- @param idx The index to which to insert the new value.
-    Returns false if the index is out of range.
- @return Whether successful.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_arr_insert(yyjson_mut_val *arr,
-                                             yyjson_mut_val *val, size_t idx);
-
-/**
- Inserts a value at the end of the array.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The value to be inserted. Returns false if it is NULL.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val *arr,
-                                             yyjson_mut_val *val);
-
-/**
- Inserts a value at the head of the array.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The value to be inserted. Returns false if it is NULL.
- @return    Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val *arr,
-                                              yyjson_mut_val *val);
-
-/**
- Replaces a value at index and returns old value.
- @param arr The array to which the value is to be replaced.
-    Returns false if it is NULL or not an array.
- @param idx The index to which to replace the value.
-    Returns false if the index is out of range.
- @param val The new value to replace. Returns false if it is NULL.
- @return Old value, or NULL on error.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_replace(yyjson_mut_val *arr,
-                                                         size_t idx,
-                                                         yyjson_mut_val *val);
-
-/**
- Removes and returns a value at index.
- @param arr The array from which the value is to be removed.
-    Returns false if it is NULL or not an array.
- @param idx The index from which to remove the value.
-    Returns false if the index is out of range.
- @return Old value, or NULL on error.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove(yyjson_mut_val *arr,
-                                                        size_t idx);
-
-/**
- Removes and returns the first value in this array.
- @param arr The array from which the value is to be removed.
-    Returns false if it is NULL or not an array.
- @return The first value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_first(
-    yyjson_mut_val *arr);
-
-/**
- Removes and returns the last value in this array.
- @param arr The array from which the value is to be removed.
-    Returns false if it is NULL or not an array.
- @return The last value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_last(
-    yyjson_mut_val *arr);
-
-/**
- Removes all values within a specified range in the array.
- @param arr The array from which the value is to be removed.
-    Returns false if it is NULL or not an array.
- @param idx The start index of the range (0 is the first).
- @param len The number of items in the range (can be 0).
- @return Whether successful.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_arr_remove_range(yyjson_mut_val *arr,
-                                                   size_t idx, size_t len);
-
-/**
- Removes all values in this array.
- @param arr The array from which all of the values are to be removed.
-    Returns false if it is NULL or not an array.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_clear(yyjson_mut_val *arr);
-
-/**
- Rotates values in this array for the given number of times.
- For example: [1,2,3,4,5] rotate 2 is [3,4,5,1,2].
- @param arr The array to be rotated.
- @param idx Index (or times) to rotate.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_arr_rotate(yyjson_mut_val *arr,
-                                             size_t idx);
-
-
-
-/*==============================================================================
- * Mutable JSON Array Modification Convenience API
- *============================================================================*/
-
-/**
- Adds a value at the end of the array.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The value to be inserted. Returns false if it is NULL.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val *arr,
-                                              yyjson_mut_val *val);
-
-/**
- Adds a `null` value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr);
-
-/**
- Adds a `true` value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr);
-
-/**
- Adds a `false` value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc *doc,
-                                                yyjson_mut_val *arr);
-
-/**
- Adds a bool value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The bool value to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_bool(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               bool val);
-
-/**
- Adds an unsigned integer value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param num The number to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_uint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               uint64_t num);
-
-/**
- Adds a signed integer value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param num The number to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_sint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               int64_t num);
-
-/**
- Adds a integer value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param num The number to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_int(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *arr,
-                                              int64_t num);
-
-/**
- Adds a double value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param num The number to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_real(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               double num);
-
-/**
- Adds a string value at the end of the array (no copy).
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param str A null-terminated UTF-8 string.
- @return Whether successful.
- @warning The input string is not copied, you should keep this string unmodified
-    for the lifetime of this JSON document.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_str(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *arr,
-                                              const char *str);
-
-/**
- Adds a string value at the end of the array (no copy).
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param str A UTF-8 string, null-terminator is not required.
- @param len The length of the string, in bytes.
- @return Whether successful.
- @warning The input string is not copied, you should keep this string unmodified
-    for the lifetime of this JSON document.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_strn(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               const char *str,
-                                               size_t len);
-
-/**
- Adds a string value at the end of the array (copied).
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param str A null-terminated UTF-8 string.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_strcpy(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *arr,
-                                                 const char *str);
-
-/**
- Adds a string value at the end of the array (copied).
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param str A UTF-8 string, null-terminator is not required.
- @param len The length of the string, in bytes.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_strncpy(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *arr,
-                                                  const char *str,
-                                                  size_t len);
-
-/**
- Creates and adds a new array at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return The new array, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_arr(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *arr);
-
-/**
- Creates and adds a new object at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return The new object, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_obj(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *arr);
-
-
-
-/*==============================================================================
- * Mutable JSON Object API
- *============================================================================*/
-
-/** Returns the number of key-value pairs in this object.
-    Returns 0 if `obj` is NULL or type is not object. */
-yyjson_api_inline size_t yyjson_mut_obj_size(yyjson_mut_val *obj);
-
-/** Returns the value to which the specified key is mapped.
-    Returns NULL if this object contains no mapping for the key.
-    Returns NULL if `obj/key` is NULL, or type is not object.
-    
-    The `key` should be a null-terminated UTF-8 string.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_get(yyjson_mut_val *obj,
-                                                     const char *key);
-
-/** Returns the value to which the specified key is mapped.
-    Returns NULL if this object contains no mapping for the key.
-    Returns NULL if `obj/key` is NULL, or type is not object.
-    
-    The `key` should be a UTF-8 string, null-terminator is not required.
-    The `key_len` should be the length of the key, in bytes.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_getn(yyjson_mut_val *obj,
-                                                      const char *key,
-                                                      size_t key_len);
-
-
-
-/*==============================================================================
- * Mutable JSON Object Iterator API
- *============================================================================*/
-
-/**
- A mutable JSON object iterator.
- 
- @warning You should not modify the object while iterating over it, but you can
-    use yyjson_mut_obj_iter_remove() to remove current value.
- 
- @par Example
- @code
-    yyjson_mut_val *key, *val;
-    yyjson_mut_obj_iter iter;
-    yyjson_mut_obj_iter_init(obj, &iter);
-    while ((key = yyjson_mut_obj_iter_next(&iter))) {
-        val = yyjson_mut_obj_iter_get_val(key);
-        your_func(key, val);
-        if (your_val_is_unused(key, val)) {
-            yyjson_mut_obj_iter_remove(&iter);
-        }
-    }
- @endcode
- 
- If the ordering of the keys is known at compile-time, you can use this method
- to speed up value lookups:
- @code
-    // {"k1":1, "k2": 3, "k3": 3}
-    yyjson_mut_val *key, *val;
-    yyjson_mut_obj_iter iter;
-    yyjson_mut_obj_iter_init(obj, &iter);
-    yyjson_mut_val *v1 = yyjson_mut_obj_iter_get(&iter, "k1");
-    yyjson_mut_val *v3 = yyjson_mut_obj_iter_get(&iter, "k3");
- @endcode
- @see yyjson_mut_obj_iter_get() and yyjson_mut_obj_iter_getn()
- */
-typedef struct yyjson_mut_obj_iter yyjson_mut_obj_iter;
-
-/**
- Initialize an iterator for this object.
- 
- @param obj The object to be iterated over.
-    If this parameter is NULL or not an array, `iter` will be set to empty.
- @param iter The iterator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
- @return true if the `iter` has been successfully initialized.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val *obj,
-    yyjson_mut_obj_iter *iter);
-
-/**
- Returns whether the iteration has more elements.
- If `iter` is NULL, this function will return false.
- */
-yyjson_api_inline bool yyjson_mut_obj_iter_has_next(
-    yyjson_mut_obj_iter *iter);
-
-/**
- Returns the next key in the iteration, or NULL on end.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_next(
-    yyjson_mut_obj_iter *iter);
-
-/**
- Returns the value for key inside the iteration.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get_val(
-    yyjson_mut_val *key);
-
-/**
- Removes and returns current key-value pair in the iteration.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_remove(
-    yyjson_mut_obj_iter *iter);
-
-/**
- Iterates to a specified key and returns the value.
- 
- This function does the same thing as yyjson_mut_obj_get(), but is much faster
- if the ordering of the keys is known at compile-time and you are using the same
- order to look up the values. If the key exists in this object, then the
- iterator will stop at the next key, otherwise the iterator will not change and
- NULL is returned.
- 
- @param iter The object iterator, should not be NULL.
- @param key The key, should be a UTF-8 string with null-terminator.
- @return The value to which the specified key is mapped.
-    NULL if this object contains no mapping for the key or input is invalid.
- 
- @warning This function takes a linear search time if the key is not nearby.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get(
-    yyjson_mut_obj_iter *iter, const char *key);
-
-/**
- Iterates to a specified key and returns the value.
- 
- This function does the same thing as yyjson_mut_obj_getn(), but is much faster
- if the ordering of the keys is known at compile-time and you are using the same
- order to look up the values. If the key exists in this object, then the
- iterator will stop at the next key, otherwise the iterator will not change and
- NULL is returned.
- 
- @param iter The object iterator, should not be NULL.
- @param key The key, should be a UTF-8 string, null-terminator is not required.
- @param key_len The the length of `key`, in bytes.
- @return The value to which the specified key is mapped.
-    NULL if this object contains no mapping for the key or input is invalid.
- 
- @warning This function takes a linear search time if the key is not nearby.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_getn(
-    yyjson_mut_obj_iter *iter, const char *key, size_t key_len);
-
-/**
- Macro for iterating over an object.
- It works like iterator, but with a more intuitive API.
- 
- @warning You should not modify the object while iterating over it.
- 
- @par Example
- @code
-    size_t idx, max;
-    yyjson_val *key, *val;
-    yyjson_obj_foreach(obj, idx, max, key, val) {
-        your_func(key, val);
-    }
- @endcode
- */
-#define yyjson_mut_obj_foreach(obj, idx, max, key, val) \
-    for ((idx) = 0, \
-        (max) = yyjson_mut_obj_size(obj), \
-        (key) = (max) ? ((yyjson_mut_val *)(obj)->uni.ptr)->next->next : NULL, \
-        (val) = (key) ? (key)->next : NULL; \
-        (idx) < (max); \
-        (idx)++, \
-        (key) = (val)->next, \
-        (val) = (key)->next)
-
-
-
-/*==============================================================================
- * Mutable JSON Object Creation API
- *============================================================================*/
-
-/** Creates and returns a mutable object, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj(yyjson_mut_doc *doc);
-
-/**
- Creates and returns a mutable object with keys and values, returns NULL on
- error. The keys and values are not copied. The strings should be a
- null-terminated UTF-8 string.
- 
- @warning The input string is not copied, you should keep this string
-    unmodified for the lifetime of this JSON document.
- 
- @par Example
- @code
-    const char *keys[2] = { "id", "name" };
-    const char *vals[2] = { "01", "Harry" };
-    yyjson_mut_val *obj = yyjson_mut_obj_with_str(doc, keys, vals, 2);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_str(yyjson_mut_doc *doc,
-                                                          const char **keys,
-                                                          const char **vals,
-                                                          size_t count);
-
-/**
- Creates and returns a mutable object with key-value pairs and pair count,
- returns NULL on error. The keys and values are not copied. The strings should
- be a null-terminated UTF-8 string.
- 
- @warning The input string is not copied, you should keep this string
-    unmodified for the lifetime of this JSON document.
- 
- @par Example
- @code
-    const char *kv_pairs[4] = { "id", "01", "name", "Harry" };
-    yyjson_mut_val *obj = yyjson_mut_obj_with_kv(doc, kv_pairs, 2);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_kv(yyjson_mut_doc *doc,
-                                                         const char **kv_pairs,
-                                                         size_t pair_count);
-
-
-
-/*==============================================================================
- * Mutable JSON Object Modification API
- *============================================================================*/
-
-/**
- Adds a key-value pair at the end of the object.
- This function allows duplicated key in one object.
- @param obj The object to which the new key-value pair is to be added.
- @param key The key, should be a string which is created by yyjson_mut_str(),
-    yyjson_mut_strn(), yyjson_mut_strcpy() or yyjson_mut_strncpy().
- @param val The value to add to the object.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_obj_add(yyjson_mut_val *obj,
-                                          yyjson_mut_val *key,
-                                          yyjson_mut_val *val);
-/**
- Sets a key-value pair at the end of the object.
- This function may remove all key-value pairs for the given key before add.
- @param obj The object to which the new key-value pair is to be added.
- @param key The key, should be a string which is created by yyjson_mut_str(),
-    yyjson_mut_strn(), yyjson_mut_strcpy() or yyjson_mut_strncpy().
- @param val The value to add to the object. If this value is null, the behavior
-    is same as yyjson_mut_obj_remove().
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_obj_put(yyjson_mut_val *obj,
-                                          yyjson_mut_val *key,
-                                          yyjson_mut_val *val);
-
-/**
- Inserts a key-value pair to the object at the given position.
- This function allows duplicated key in one object.
- @param obj The object to which the new key-value pair is to be added.
- @param key The key, should be a string which is created by yyjson_mut_str(),
-    yyjson_mut_strn(), yyjson_mut_strcpy() or yyjson_mut_strncpy().
- @param val The value to add to the object.
- @param idx The index to which to insert the new pair.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_obj_insert(yyjson_mut_val *obj,
-                                             yyjson_mut_val *key,
-                                             yyjson_mut_val *val,
-                                             size_t idx);
-
-/**
- Removes all key-value pair from the object with given key.
- @param obj The object from which the key-value pair is to be removed.
- @param key The key, should be a string value.
- @return The first matched value, or NULL if no matched value.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove(yyjson_mut_val *obj,
-                                                        yyjson_mut_val *key);
-
-/**
- Removes all key-value pair from the object with given key.
- @param obj The object from which the key-value pair is to be removed.
- @param key The key, should be a UTF-8 string with null-terminator.
- @return The first matched value, or NULL if no matched value.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_key(
-    yyjson_mut_val *obj, const char *key);
-
-/**
- Removes all key-value pair from the object with given key.
- @param obj The object from which the key-value pair is to be removed.
- @param key The key, should be a UTF-8 string, null-terminator is not required.
- @param key_len The length of the key.
- @return The first matched value, or NULL if no matched value.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_keyn(
-    yyjson_mut_val *obj, const char *key, size_t key_len);
-
-/**
- Removes all key-value pairs in this object.
- @param obj The object from which all of the values are to be removed.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_obj_clear(yyjson_mut_val *obj);
-
-/**
- Replaces value from the object with given key.
- If the key is not exist, or the value is NULL, it will fail.
- @param obj The object to which the value is to be replaced.
- @param key The key, should be a string value.
- @param val The value to replace into the object.
- @return Whether successful.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_obj_replace(yyjson_mut_val *obj,
-                                              yyjson_mut_val *key,
-                                              yyjson_mut_val *val);
-
-/**
- Rotates key-value pairs in the object for the given number of times.
- For example: {"a":1,"b":2,"c":3,"d":4} rotate 1 is {"b":2,"c":3,"d":4,"a":1}.
- @param obj The object to be rotated.
- @param idx Index (or times) to rotate.
- @return Whether successful.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_obj_rotate(yyjson_mut_val *obj,
-                                             size_t idx);
-
-
-
-/*==============================================================================
- * Mutable JSON Object Modification Convenience API
- *============================================================================*/
-
-/** Adds a `null` value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_null(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key);
-
-/** Adds a `true` value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_true(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key);
-
-/** Adds a `false` value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_false(yyjson_mut_doc *doc,
-                                                yyjson_mut_val *obj,
-                                                const char *key);
-
-/** Adds a bool value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key, bool val);
-
-/** Adds an unsigned integer value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_uint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key, uint64_t val);
-
-/** Adds a signed integer value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_sint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key, int64_t val);
-
-/** Adds an int value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_int(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *key, int64_t val);
-
-/** Adds a double value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_real(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key, double val);
-
-/** Adds a string value at the end of the object.
-    The `key` and `val` should be null-terminated UTF-8 strings.
-    This function allows duplicated key in one object.
-    
-    @warning The key/value string are not copied, you should keep these strings
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_str(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *key, const char *val);
-
-/** Adds a string value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    The `val` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the `val`, in bytes.
-    This function allows duplicated key in one object.
-    
-    @warning The key/value string are not copied, you should keep these strings
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_strn(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key,
-                                               const char *val, size_t len);
-
-/** Adds a string value at the end of the object.
-    The `key` and `val` should be null-terminated UTF-8 strings.
-    The value string is copied.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *obj,
-                                                 const char *key,
-                                                 const char *val);
-
-/** Adds a string value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    The `val` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the `val`, in bytes.
-    This function allows duplicated key in one object.
-    
-    @warning The key/value string are not copied, you should keep these strings
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *obj,
-                                                  const char *key,
-                                                  const char *val, size_t len);
-
-/** Adds a JSON value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string are not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_val(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *key,
-                                              yyjson_mut_val *val);
-
-/** Removes all key-value pairs for the given key.
-    Returns the first value to which the specified key is mapped or NULL if this
-    object contains no mapping for the key.
-    The `key` should be a null-terminated UTF-8 string.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_str(
-    yyjson_mut_val *obj, const char *key);
-
-/** Removes all key-value pairs for the given key.
-    Returns the first value to which the specified key is mapped or NULL if this
-    object contains no mapping for the key.
-    The `key` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the key, in bytes.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_strn(
-    yyjson_mut_val *obj, const char *key, size_t len);
-
-
-
-/*==============================================================================
- * JSON Pointer API
- * https://tools.ietf.org/html/rfc6901
- *============================================================================*/
-
-/** Get a JSON value with JSON Pointer (RFC 6901).
-    The `ptr` should be a null-terminated UTF-8 string.
-    
-    Returns NULL if there's no matched value.
-    Returns NULL if `val/ptr` is NULL or `val` is not object. */
-yyjson_api_inline yyjson_val *yyjson_get_pointer(yyjson_val *val,
-                                                 const char *ptr);
-
-/** Get a JSON value with JSON Pointer (RFC 6901).
-    The `ptr` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the `ptr`, in bytes.
-    
-    Returns NULL if there's no matched value.
-    Returns NULL if `val/ptr` is NULL or `val` is not object. */
-yyjson_api_inline yyjson_val *yyjson_get_pointern(yyjson_val *val,
-                                                  const char *ptr,
-                                                  size_t len);
-
-/** Get a JSON value with JSON Pointer (RFC 6901).
-    The `ptr` should be a null-terminated UTF-8 string.
-    
-    Returns NULL if there's no matched value. */
-yyjson_api_inline yyjson_val *yyjson_doc_get_pointer(yyjson_doc *doc,
-                                                     const char *ptr);
-
-/** Get a JSON value with JSON Pointer (RFC 6901).
-    The `ptr` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the `ptr`, in bytes.
- 
-    Returns NULL if there's no matched value. */
-yyjson_api_inline yyjson_val *yyjson_doc_get_pointern(yyjson_doc *doc,
-                                                     const char *ptr,
-                                                      size_t len);
-
-/** Get a JSON value with JSON Pointer (RFC 6901).
-    The `ptr` should be a null-terminated UTF-8 string.
-    
-    Returns NULL if there's no matched value. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointer(yyjson_mut_val *val,
-                                                         const char *ptr);
-
-/** Get a JSON value with JSON Pointer (RFC 6901).
-    The `ptr` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the `ptr`, in bytes.
-    
-    Returns NULL if there's no matched value. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointern(yyjson_mut_val *val,
-                                                          const char *ptr,
-                                                          size_t len);
-
-/** Get a JSON value with JSON Pointer (RFC 6901).
-    The `ptr` should be a null-terminated UTF-8 string.
-    
-    Returns NULL if there's no matched value. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointer(
-    yyjson_mut_doc *doc, const char *ptr);
-
-/** Get a JSON value with JSON Pointer (RFC 6901).
-    The `ptr` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the `ptr`, in bytes.
-    
-    Returns NULL if there's no matched value. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointern(
-    yyjson_mut_doc *doc, const char *ptr, size_t len);
-
-
-
-/*==============================================================================
- * JSON Merge-Patch API
- * https://tools.ietf.org/html/rfc7386
- *============================================================================*/
-
-/** Creates and returns a merge-patched JSON value (RFC 7386).
-    The memory of the returned value is allocated by the `doc`.
-    Returns NULL if the patch could not be applied.
-    
-    @warning This function is recursive and may cause a stack overflow if the
-        object level is too deep. */
-yyjson_api yyjson_mut_val *yyjson_merge_patch(yyjson_mut_doc *doc,
-                                              yyjson_val *orig,
-                                              yyjson_val *patch);
-
-/** Creates and returns a merge-patched JSON value (RFC 7386).
-    The memory of the returned value is allocated by the `doc`.
-    Returns NULL if the patch could not be applied.
-    
-    @warning This function is recursive and may cause a stack overflow if the
-        object level is too deep. */
-yyjson_api yyjson_mut_val *yyjson_mut_merge_patch(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *orig,
-                                                  yyjson_mut_val *patch);
-
-
-
-/*==============================================================================
- * JSON Structure (Implementation)
- *============================================================================*/
-
-/** Payload of a JSON value (8 bytes). */
-typedef union yyjson_val_uni {
-    uint64_t    u64;
-    int64_t     i64;
-    double      f64;
-    const char *str;
-    void       *ptr;
-    size_t      ofs;
-} yyjson_val_uni;
-
-/**
- Immutable JSON value, 16 bytes.
- */
-struct yyjson_val {
-    uint64_t tag; /**< type, subtype and length */
-    yyjson_val_uni uni; /**< payload */
-};
-
-struct yyjson_doc {
-    /** Root value of the document (nonnull). */
-    yyjson_val *root;
-    /** Allocator used by document (nonnull). */
-    yyjson_alc alc;
-    /** The total number of bytes read when parsing JSON (nonzero). */
-    size_t dat_read;
-    /** The total number of value read when parsing JSON (nonzero). */
-    size_t val_read;
-    /** The string pool used by JSON values (nullable). */
-    char *str_pool;
-};
-
-
-
-/*==============================================================================
- * Unsafe JSON Value API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_type unsafe_yyjson_get_type(void *val) {
-    uint8_t tag = (uint8_t)((yyjson_val *)val)->tag;
-    return (yyjson_type)(tag & YYJSON_TYPE_MASK);
-}
-
-yyjson_api_inline yyjson_subtype unsafe_yyjson_get_subtype(void *val) {
-    uint8_t tag = (uint8_t)((yyjson_val *)val)->tag;
-    return (yyjson_subtype)(tag & YYJSON_SUBTYPE_MASK);
-}
-
-yyjson_api_inline uint8_t unsafe_yyjson_get_tag(void *val) {
-    uint8_t tag = (uint8_t)((yyjson_val *)val)->tag;
-    return (uint8_t)(tag & YYJSON_TAG_MASK);
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_raw(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_RAW;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_null(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_NULL;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_bool(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_BOOL;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_num(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_NUM;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_str(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_STR;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_arr(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_ARR;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_obj(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_OBJ;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_ctn(void *val) {
-    uint8_t mask = YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ;
-    return (unsafe_yyjson_get_tag(val) & mask) == mask;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_uint(void *val) {
-    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_sint(void *val) {
-    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_int(void *val) {
-    const uint8_t mask = YYJSON_TAG_MASK & (~YYJSON_SUBTYPE_SINT);
-    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-    return (unsafe_yyjson_get_tag(val) & mask) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_real(void *val) {
-    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_true(void *val) {
-    const uint8_t patt = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_false(void *val) {
-    const uint8_t patt = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_arr_is_flat(yyjson_val *val) {
-    size_t ofs = val->uni.ofs;
-    size_t len = (size_t)(val->tag >> YYJSON_TAG_BIT);
-    return len * sizeof(yyjson_val) + sizeof(yyjson_val) == ofs;
-}
-
-yyjson_api_inline const char *unsafe_yyjson_get_raw(void *val) {
-    return ((yyjson_val *)val)->uni.str;
-}
-
-yyjson_api_inline bool unsafe_yyjson_get_bool(void *val) {
-    uint8_t tag = unsafe_yyjson_get_tag(val);
-    return (bool)((tag & YYJSON_SUBTYPE_MASK) >> YYJSON_TYPE_BIT);
-}
-
-yyjson_api_inline uint64_t unsafe_yyjson_get_uint(void *val) {
-    return ((yyjson_val *)val)->uni.u64;
-}
-
-yyjson_api_inline int64_t unsafe_yyjson_get_sint(void *val) {
-    return ((yyjson_val *)val)->uni.i64;
-}
-
-yyjson_api_inline int unsafe_yyjson_get_int(void *val) {
-    return (int)((yyjson_val *)val)->uni.i64;
-}
-
-yyjson_api_inline double unsafe_yyjson_get_real(void *val) {
-    return ((yyjson_val *)val)->uni.f64;
-}
-
-yyjson_api_inline const char *unsafe_yyjson_get_str(void *val) {
-    return ((yyjson_val *)val)->uni.str;
-}
-
-yyjson_api_inline size_t unsafe_yyjson_get_len(void *val) {
-    return (size_t)(((yyjson_val *)val)->tag >> YYJSON_TAG_BIT);
-}
-
-yyjson_api_inline void unsafe_yyjson_set_len(void *val, size_t len) {
-    uint64_t tag = ((yyjson_val *)val)->tag & YYJSON_TAG_MASK;
-    tag |= (uint64_t)len << YYJSON_TAG_BIT;
-    ((yyjson_val *)val)->tag = tag;
-}
-
-yyjson_api_inline yyjson_val *unsafe_yyjson_get_first(yyjson_val *ctn) {
-    return ctn + 1;
-}
-
-yyjson_api_inline yyjson_val *unsafe_yyjson_get_next(yyjson_val *val) {
-    bool is_ctn = unsafe_yyjson_is_ctn(val);
-    size_t ctn_ofs = val->uni.ofs;
-    size_t ofs = (is_ctn ? ctn_ofs : sizeof(yyjson_val));
-    return (yyjson_val *)(void *)((uint8_t *)val + ofs);
-}
-
-yyjson_api_inline bool unsafe_yyjson_equals_strn(void *val, const char *str,
-                                                 size_t len) {
-    uint64_t tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-    return ((yyjson_val *)val)->tag == tag &&
-    memcmp(((yyjson_val *)val)->uni.str, str, len) == 0;
-}
-
-yyjson_api_inline bool unsafe_yyjson_equals_str(void *val, const char *str) {
-    return unsafe_yyjson_equals_strn(val, str, strlen(str));
-}
-
-
-
-/*==============================================================================
- * JSON Document API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_val *yyjson_doc_get_root(yyjson_doc *doc) {
-    return doc ? doc->root : NULL;
-}
-
-yyjson_api_inline size_t yyjson_doc_get_read_size(yyjson_doc *doc) {
-    return doc ? doc->dat_read : 0;
-}
-
-yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc) {
-    return doc ? doc->val_read : 0;
-}
-
-yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc) {
-    if (doc) {
-        yyjson_alc alc = doc->alc;
-        if (doc->str_pool) alc.free(alc.ctx, doc->str_pool);
-        alc.free(alc.ctx, doc);
-    }
-}
-
-
-
-/*==============================================================================
- * JSON Value Type API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_is_raw(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_raw(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_null(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_null(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_true(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_true(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_false(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_false(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_bool(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_bool(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_uint(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_uint(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_sint(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_sint(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_int(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_int(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_real(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_real(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_num(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_num(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_str(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_str(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_arr(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_arr(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_obj(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_obj(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_ctn(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_ctn(val) : false;
-}
-
-
-
-/*==============================================================================
- * JSON Value Content API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_type yyjson_get_type(yyjson_val *val) {
-    return val ? unsafe_yyjson_get_type(val) : YYJSON_TYPE_NONE;
-}
-
-yyjson_api_inline yyjson_subtype yyjson_get_subtype(yyjson_val *val) {
-    return val ? unsafe_yyjson_get_subtype(val) : YYJSON_SUBTYPE_NONE;
-}
-
-yyjson_api_inline uint8_t yyjson_get_tag(yyjson_val *val) {
-    return val ? unsafe_yyjson_get_tag(val) : 0;
-}
-
-yyjson_api_inline const char *yyjson_get_type_desc(yyjson_val *val) {
-    switch (yyjson_get_tag(val)) {
-        case YYJSON_TYPE_RAW  | YYJSON_SUBTYPE_NONE:  return "raw";
-        case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:  return "null";
-        case YYJSON_TYPE_STR  | YYJSON_SUBTYPE_NONE:  return "string";
-        case YYJSON_TYPE_ARR  | YYJSON_SUBTYPE_NONE:  return "array";
-        case YYJSON_TYPE_OBJ  | YYJSON_SUBTYPE_NONE:  return "object";
-        case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE:  return "true";
-        case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE: return "false";
-        case YYJSON_TYPE_NUM  | YYJSON_SUBTYPE_UINT:  return "uint";
-        case YYJSON_TYPE_NUM  | YYJSON_SUBTYPE_SINT:  return "sint";
-        case YYJSON_TYPE_NUM  | YYJSON_SUBTYPE_REAL:  return "real";
-        default:                                      return "unknown";
-    }
-}
-
-yyjson_api_inline const char *yyjson_get_raw(yyjson_val *val) {
-    return yyjson_is_raw(val) ? unsafe_yyjson_get_raw(val) : NULL;
-}
-
-yyjson_api_inline bool yyjson_get_bool(yyjson_val *val) {
-    return yyjson_is_bool(val) ? unsafe_yyjson_get_bool(val) : false;
-}
-
-yyjson_api_inline uint64_t yyjson_get_uint(yyjson_val *val) {
-    return yyjson_is_int(val) ? unsafe_yyjson_get_uint(val) : 0;
-}
-
-yyjson_api_inline int64_t yyjson_get_sint(yyjson_val *val) {
-    return yyjson_is_int(val) ? unsafe_yyjson_get_sint(val) : 0;
-}
-
-yyjson_api_inline int yyjson_get_int(yyjson_val *val) {
-    return yyjson_is_int(val) ? unsafe_yyjson_get_int(val) : 0;
-}
-
-yyjson_api_inline double yyjson_get_real(yyjson_val *val) {
-    return yyjson_is_real(val) ? unsafe_yyjson_get_real(val) : 0.0;
-}
-
-yyjson_api_inline const char *yyjson_get_str(yyjson_val *val) {
-    return yyjson_is_str(val) ? unsafe_yyjson_get_str(val) : NULL;
-}
-
-yyjson_api_inline size_t yyjson_get_len(yyjson_val *val) {
-    return val ? unsafe_yyjson_get_len(val) : 0;
-}
-
-yyjson_api_inline bool yyjson_equals_str(yyjson_val *val, const char *str) {
-    if (yyjson_likely(val && str)) {
-        return unsafe_yyjson_equals_str(val, str);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_equals_strn(yyjson_val *val, const char *str,
-                                          size_t len) {
-    if (yyjson_likely(val && str)) {
-        return unsafe_yyjson_equals_strn(val, str, len);
-    }
-    return false;
-}
-
-yyjson_api bool unsafe_yyjson_equals(yyjson_val *lhs, yyjson_val *rhs);
-
-yyjson_api_inline bool yyjson_equals(yyjson_val *lhs, yyjson_val *rhs) {
-    if (yyjson_unlikely(!lhs || !rhs))
-        return false;
-    
-    return unsafe_yyjson_equals(lhs, rhs);
-}
-
-
-
-/*==============================================================================
- * JSON Array API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline size_t yyjson_arr_size(yyjson_val *arr) {
-    return yyjson_is_arr(arr) ? unsafe_yyjson_get_len(arr) : 0;
-}
-
-yyjson_api_inline yyjson_val *yyjson_arr_get(yyjson_val *arr, size_t idx) {
-    if (yyjson_likely(yyjson_is_arr(arr))) {
-        if (yyjson_likely(unsafe_yyjson_get_len(arr) > idx)) {
-            yyjson_val *val = unsafe_yyjson_get_first(arr);
-            if (unsafe_yyjson_arr_is_flat(arr)) {
-                return val + idx;
-            } else {
-                while (idx-- > 0) val = unsafe_yyjson_get_next(val);
-                return val;
-            }
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_val *yyjson_arr_get_first(yyjson_val *arr) {
-    if (yyjson_likely(yyjson_is_arr(arr))) {
-        if (yyjson_likely(unsafe_yyjson_get_len(arr) > 0)) {
-            return unsafe_yyjson_get_first(arr);
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_val *yyjson_arr_get_last(yyjson_val *arr) {
-    if (yyjson_likely(yyjson_is_arr(arr))) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(len > 0)) {
-            yyjson_val *val = unsafe_yyjson_get_first(arr);
-            if (unsafe_yyjson_arr_is_flat(arr)) {
-                return val + (len - 1);
-            } else {
-                while (len-- > 1) val = unsafe_yyjson_get_next(val);
-                return val;
-            }
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * JSON Array Iterator API (Implementation)
- *============================================================================*/
-
-struct yyjson_arr_iter {
-    size_t idx; /**< current index, from 0 */
-    size_t max; /**< maximum index, idx < max */
-    yyjson_val *cur; /**< current value */
-};
-
-yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val *arr,
-                                            yyjson_arr_iter *iter) {
-    if (yyjson_likely(yyjson_is_arr(arr) && iter)) {
-        iter->idx = 0;
-        iter->max = unsafe_yyjson_get_len(arr);
-        iter->cur = unsafe_yyjson_get_first(arr);
-        return true;
-    }
-    if (iter) memset(iter, 0, sizeof(yyjson_arr_iter));
-    return false;
-}
-
-yyjson_api_inline bool yyjson_arr_iter_has_next(yyjson_arr_iter *iter) {
-    return iter ? iter->idx < iter->max : false;
-}
-
-yyjson_api_inline yyjson_val *yyjson_arr_iter_next(yyjson_arr_iter *iter) {
-    yyjson_val *val;
-    if (iter && iter->idx < iter->max) {
-        val = iter->cur;
-        iter->cur = unsafe_yyjson_get_next(val);
-        iter->idx++;
-        return val;
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * JSON Object API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline size_t yyjson_obj_size(yyjson_val *obj) {
-    return yyjson_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0;
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_get(yyjson_val *obj,
-                                             const char *key) {
-    return yyjson_obj_getn(obj, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_getn(yyjson_val *obj,
-                                              const char *_key,
-                                              size_t key_len) {
-    uint64_t tag = (((uint64_t)key_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-    if (yyjson_likely(yyjson_is_obj(obj) && _key)) {
-        size_t len = unsafe_yyjson_get_len(obj);
-        yyjson_val *key = unsafe_yyjson_get_first(obj);
-        while (len-- > 0) {
-            if (key->tag == tag &&
-                memcmp(key->uni.ptr, _key, key_len) == 0) {
-                return key + 1;
-            }
-            key = unsafe_yyjson_get_next(key + 1);
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * JSON Object Iterator API (Implementation)
- *============================================================================*/
-
-struct yyjson_obj_iter {
-    size_t idx; /**< current key index, from 0 */
-    size_t max; /**< maximum key index, idx < max */
-    yyjson_val *cur; /**< current key */
-    yyjson_val *obj; /**< the object being iterated */
-};
-
-yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val *obj,
-                                            yyjson_obj_iter *iter) {
-    if (yyjson_likely(yyjson_is_obj(obj) && iter)) {
-        iter->idx = 0;
-        iter->max = unsafe_yyjson_get_len(obj);
-        iter->cur = unsafe_yyjson_get_first(obj);
-        iter->obj = obj;
-        return true;
-    }
-    if (iter) memset(iter, 0, sizeof(yyjson_obj_iter));
-    return false;
-}
-
-yyjson_api_inline bool yyjson_obj_iter_has_next(yyjson_obj_iter *iter) {
-    return iter ? iter->idx < iter->max : false;
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_iter_next(yyjson_obj_iter *iter) {
-    if (iter && iter->idx < iter->max) {
-        yyjson_val *key = iter->cur;
-        iter->idx++;
-        iter->cur = unsafe_yyjson_get_next(key + 1);
-        return key;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_iter_get_val(yyjson_val *key) {
-    return key ? key + 1 : NULL;
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_iter_get(yyjson_obj_iter *iter,
-                                                  const char *key) {
-    return yyjson_obj_iter_getn(iter, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_iter_getn(yyjson_obj_iter *iter,
-                                                   const char *key,
-                                                   size_t key_len) {
-    if (iter && key) {
-        size_t idx = iter->idx;
-        size_t max = iter->max;
-        yyjson_val *cur = iter->cur;
-        if (yyjson_unlikely(idx == max)) {
-            idx = 0;
-            cur = unsafe_yyjson_get_first(iter->obj);
-        }
-        while (idx++ < max) {
-            yyjson_val *next = unsafe_yyjson_get_next(cur + 1);
-            if (unsafe_yyjson_get_len(cur) == key_len &&
-                memcmp(cur->uni.str, key, key_len) == 0) {
-                iter->idx = idx;
-                iter->cur = next;
-                return cur + 1;
-            }
-            cur = next;
-            if (idx == iter->max && iter->idx < iter->max) {
-                idx = 0;
-                max = iter->idx;
-                cur = unsafe_yyjson_get_first(iter->obj);
-            }
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Structure (Implementation)
- *============================================================================*/
-
-/**
- Mutable JSON value, 24 bytes.
- The 'tag' and 'uni' field is same as immutable value.
- The 'next' field links all elements inside the container to be a cycle.
- */
-struct yyjson_mut_val {
-    uint64_t tag; /**< type, subtype and length */
-    yyjson_val_uni uni; /**< payload */
-    yyjson_mut_val *next; /**< the next value in circular linked list */
-};
-
-/**
- A memory chunk in string memory pool.
- */
-typedef struct yyjson_str_chunk {
-    struct yyjson_str_chunk *next;
-    /* flexible array member here */
-} yyjson_str_chunk;
-
-/**
- A memory pool to hold all strings in a mutable document.
- */
-typedef struct yyjson_str_pool {
-    char *cur; /* cursor inside current chunk */
-    char *end; /* the end of current chunk */
-    size_t chunk_size; /* chunk size in bytes while creating new chunk */
-    size_t chunk_size_max; /* maximum chunk size in bytes */
-    yyjson_str_chunk *chunks; /* a linked list of chunks, nullable */
-} yyjson_str_pool;
-
-/**
- A memory chunk in value memory pool.
- */
-typedef struct yyjson_val_chunk {
-    struct yyjson_val_chunk *next;
-    /* flexible array member here */
-} yyjson_val_chunk;
-
-/**
- A memory pool to hold all values in a mutable document.
- */
-typedef struct yyjson_val_pool {
-    yyjson_mut_val *cur; /* cursor inside current chunk */
-    yyjson_mut_val *end; /* the end of current chunk */
-    size_t chunk_size; /* chunk size in bytes while creating new chunk */
-    size_t chunk_size_max; /* maximum chunk size in bytes */
-    yyjson_val_chunk *chunks; /* a linked list of chunks, nullable */
-} yyjson_val_pool;
-
-struct yyjson_mut_doc {
-    yyjson_mut_val *root; /**< root value of the JSON document, nullable */
-    yyjson_alc alc; /**< a valid allocator, nonnull */
-    yyjson_str_pool str_pool; /**< string memory pool */
-    yyjson_val_pool val_pool; /**< value memory pool */
-};
-
-/* Ensures the capacity to at least equal to the specified byte length. */
-yyjson_api bool unsafe_yyjson_str_pool_grow(yyjson_str_pool *pool,
-                                            yyjson_alc *alc, size_t len);
-
-/* Ensures the capacity to at least equal to the specified value count. */
-yyjson_api bool unsafe_yyjson_val_pool_grow(yyjson_val_pool *pool,
-                                            yyjson_alc *alc, size_t count);
-
-yyjson_api_inline char *unsafe_yyjson_mut_strncpy(yyjson_mut_doc *doc,
-                                                  const char *str, size_t len) {
-    char *mem;
-    yyjson_alc *alc = &doc->alc;
-    yyjson_str_pool *pool = &doc->str_pool;
-    
-    if (!str) return NULL;
-    if (yyjson_unlikely((size_t)(pool->end - pool->cur) <= len)) {
-        if (yyjson_unlikely(!unsafe_yyjson_str_pool_grow(pool, alc, len + 1))) {
-            return NULL;
-        }
-    }
-    
-    mem = pool->cur;
-    pool->cur = mem + len + 1;
-    memcpy((void *)mem, (const void *)str, len);
-    mem[len] = '\0';
-    return mem;
-}
-
-yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_val(yyjson_mut_doc *doc,
-                                                        size_t count) {
-    yyjson_mut_val *val;
-    yyjson_alc *alc = &doc->alc;
-    yyjson_val_pool *pool = &doc->val_pool;
-    if (yyjson_unlikely((size_t)(pool->end - pool->cur) < count)) {
-        if (yyjson_unlikely(!unsafe_yyjson_val_pool_grow(pool, alc, count))) {
-            return NULL;
-        }
-    }
-    
-    val = pool->cur;
-    pool->cur += count;
-    return val;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Document API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_root(yyjson_mut_doc *doc) {
-    return doc ? doc->root : NULL;
-}
-
-yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *root) {
-    if (doc) doc->root = root;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Value Type API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_mut_is_raw(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_raw(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_null(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_null(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_true(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_true(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_false(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_false(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_bool(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_bool(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_uint(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_uint(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_sint(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_sint(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_int(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_int(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_real(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_real(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_num(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_num(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_str(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_str(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_arr(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_arr(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_obj(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_obj(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_ctn(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_ctn(val) : false;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Value Content API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_type yyjson_mut_get_type(yyjson_mut_val *val) {
-    return yyjson_get_type((yyjson_val *)val);
-}
-
-yyjson_api_inline yyjson_subtype yyjson_mut_get_subtype(yyjson_mut_val *val) {
-    return yyjson_get_subtype((yyjson_val *)val);
-}
-
-yyjson_api_inline uint8_t yyjson_mut_get_tag(yyjson_mut_val *val) {
-    return yyjson_get_tag((yyjson_val *)val);
-}
-
-yyjson_api_inline const char *yyjson_mut_get_type_desc(yyjson_mut_val *val) {
-    return yyjson_get_type_desc((yyjson_val *)val);
-}
-
-yyjson_api_inline const char *yyjson_mut_get_raw(yyjson_mut_val *val) {
-    return yyjson_get_raw((yyjson_val *)val);
-}
-
-yyjson_api_inline bool yyjson_mut_get_bool(yyjson_mut_val *val) {
-    return yyjson_get_bool((yyjson_val *)val);
-}
-
-yyjson_api_inline uint64_t yyjson_mut_get_uint(yyjson_mut_val *val) {
-    return yyjson_get_uint((yyjson_val *)val);
-}
-
-yyjson_api_inline int64_t yyjson_mut_get_sint(yyjson_mut_val *val) {
-    return yyjson_get_sint((yyjson_val *)val);
-}
-
-yyjson_api_inline int yyjson_mut_get_int(yyjson_mut_val *val) {
-    return yyjson_get_int((yyjson_val *)val);
-}
-
-yyjson_api_inline double yyjson_mut_get_real(yyjson_mut_val *val) {
-    return yyjson_get_real((yyjson_val *)val);
-}
-
-yyjson_api_inline const char *yyjson_mut_get_str(yyjson_mut_val *val) {
-    return yyjson_get_str((yyjson_val *)val);
-}
-
-yyjson_api_inline size_t yyjson_mut_get_len(yyjson_mut_val *val) {
-    return yyjson_get_len((yyjson_val *)val);
-}
-
-yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val *val,
-                                             const char *str) {
-    return yyjson_equals_str((yyjson_val *)val, str);
-}
-
-yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val *val,
-                                              const char *str, size_t len) {
-    return yyjson_equals_strn((yyjson_val *)val, str, len);
-}
-
-yyjson_api bool unsafe_yyjson_mut_equals(yyjson_mut_val *lhs,
-                                         yyjson_mut_val *rhs);
-
-yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val *lhs,
-                                         yyjson_mut_val *rhs) {
-    if (yyjson_unlikely(!lhs || !rhs)) return false;
-    return unsafe_yyjson_mut_equals(lhs, rhs);
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Value Creation API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_raw(yyjson_mut_doc *doc,
-                                                 const char *str) {
-    if (yyjson_likely(str)) return yyjson_mut_rawn(doc, str, strlen(str));
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawn(yyjson_mut_doc *doc,
-                                                  const char *str,
-                                                  size_t len) {
-    if (yyjson_likely(doc && str)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
-            val->uni.str = str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawcpy(yyjson_mut_doc *doc,
-                                                    const char *str) {
-    if (yyjson_likely(str)) return yyjson_mut_rawncpy(doc, str, strlen(str));
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawncpy(yyjson_mut_doc *doc,
-                                                     const char *str,
-                                                     size_t len) {
-    if (yyjson_likely(doc && str)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len);
-        if (yyjson_likely(val && new_str)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
-            val->uni.str = new_str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_null(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_true(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_false(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc,
-                                                  bool _val) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)_val << 3);
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_uint(yyjson_mut_doc *doc,
-                                                  uint64_t num) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-            val->uni.u64 = num;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_sint(yyjson_mut_doc *doc,
-                                                  int64_t num) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-            val->uni.i64 = num;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_int(yyjson_mut_doc *doc,
-                                                 int64_t num) {
-    return yyjson_mut_sint(doc, num);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_real(yyjson_mut_doc *doc,
-                                                  double num) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-            val->uni.f64 = num;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_str(yyjson_mut_doc *doc,
-                                                 const char *str) {
-    if (yyjson_likely(str)) return yyjson_mut_strn(doc, str, strlen(str));
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strn(yyjson_mut_doc *doc,
-                                                  const char *str,
-                                                  size_t len) {
-    if (yyjson_likely(doc && str)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-            val->uni.str = str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strcpy(yyjson_mut_doc *doc,
-                                                    const char *str) {
-    if (yyjson_likely(str)) return yyjson_mut_strncpy(doc, str, strlen(str));
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strncpy(yyjson_mut_doc *doc,
-                                                     const char *str,
-                                                     size_t len) {
-    if (yyjson_likely(doc && str)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len);
-        if (yyjson_likely(val && new_str)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-            val->uni.str = new_str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Array API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline size_t yyjson_mut_arr_size(yyjson_mut_val *arr) {
-    return yyjson_mut_is_arr(arr) ? unsafe_yyjson_get_len(arr) : 0;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get(yyjson_mut_val *arr,
-                                                     size_t idx) {
-    if (yyjson_likely(idx < yyjson_mut_arr_size(arr))) {
-        yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr;
-        while (idx-- > 0) val = val->next;
-        return val->next;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_first(
-    yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) {
-        return ((yyjson_mut_val *)arr->uni.ptr)->next;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_last(
-    yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) {
-        return ((yyjson_mut_val *)arr->uni.ptr);
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Array Iterator API (Implementation)
- *============================================================================*/
-
-struct yyjson_mut_arr_iter {
-    size_t idx; /**< current index, from 0 */
-    size_t max; /**< maximum index, idx < max */
-    yyjson_mut_val *cur; /**< current value */
-    yyjson_mut_val *pre; /**< previous value */
-    yyjson_mut_val *arr; /**< the array being iterated */
-};
-
-yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val *arr,
-                                                yyjson_mut_arr_iter *iter) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && iter)) {
-        iter->idx = 0;
-        iter->max = unsafe_yyjson_get_len(arr);
-        iter->cur = iter->max ? (yyjson_mut_val *)arr->uni.ptr : NULL;
-        iter->pre = NULL;
-        iter->arr = arr;
-        return true;
-    }
-    if (iter) memset(iter, 0, sizeof(yyjson_mut_arr_iter));
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_iter_has_next(yyjson_mut_arr_iter *iter) {
-    return iter ? iter->idx < iter->max : false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_next(
-    yyjson_mut_arr_iter *iter) {
-    if (iter && iter->idx < iter->max) {
-        yyjson_mut_val *val = iter->cur;
-        iter->pre = val;
-        iter->cur = val->next;
-        iter->idx++;
-        return iter->cur;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_remove(
-    yyjson_mut_arr_iter *iter) {
-    if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
-        yyjson_mut_val *prev = iter->pre;
-        yyjson_mut_val *cur = iter->cur;
-        yyjson_mut_val *next = cur->next;
-        if (yyjson_unlikely(iter->idx == iter->max)) iter->arr->uni.ptr = prev;
-        iter->idx--;
-        iter->max--;
-        unsafe_yyjson_set_len(iter->arr, iter->max);
-        prev->next = next;
-        iter->cur = next;
-        return cur;
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Array Creation API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-#define yyjson_mut_arr_with_func(func) \
-    if (yyjson_likely(doc && ((0 < count && count < \
-        (~(size_t)0) / sizeof(yyjson_mut_val) && vals) || count == 0))) { \
-        yyjson_mut_val *arr = unsafe_yyjson_mut_val(doc, 1 + count); \
-        if (yyjson_likely(arr)) { \
-            arr->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR; \
-            if (count > 0) { \
-                size_t i; \
-                for (i = 0; i < count; i++) { \
-                    yyjson_mut_val *val = arr + i + 1; \
-                    func \
-                    val->next = val + 1; \
-                } \
-                arr[count].next = arr + 1; \
-                arr->uni.ptr = arr + count; \
-            } \
-            return arr; \
-        } \
-    } \
-    return NULL
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool(
-    yyjson_mut_doc *doc, const bool *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)vals[i] << 3);
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint(
-    yyjson_mut_doc *doc, const int64_t *vals, size_t count) {
-    return yyjson_mut_arr_with_sint64(doc, vals, count);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint(
-    yyjson_mut_doc *doc, const uint64_t *vals, size_t count) {
-    return yyjson_mut_arr_with_uint64(doc, vals, count);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_real(
-    yyjson_mut_doc *doc, const double *vals, size_t count) {
-    return yyjson_mut_arr_with_double(doc, vals, count);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint8(
-    yyjson_mut_doc *doc, const int8_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = (int64_t)vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint16(
-    yyjson_mut_doc *doc, const int16_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint32(
-    yyjson_mut_doc *doc, const int32_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint64(
-    yyjson_mut_doc *doc, const int64_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint8(
-    yyjson_mut_doc *doc, const uint8_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint16(
-    yyjson_mut_doc *doc, const uint16_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint32(
-    yyjson_mut_doc *doc, const uint32_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint64(
-    yyjson_mut_doc *doc, const uint64_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_float(
-    yyjson_mut_doc *doc, const float *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-        val->uni.f64 = (double)vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_double(
-    yyjson_mut_doc *doc, const double *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-        val->uni.f64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_str(
-    yyjson_mut_doc *doc, const char **vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        uint64_t len = (uint64_t)strlen(vals[i]);
-        val->tag = (len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = vals[i];
-        if (yyjson_unlikely(!val->uni.str)) return NULL;
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strn(
-    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
-    if (yyjson_unlikely(count > 0 && !lens)) return NULL;
-    yyjson_mut_arr_with_func({
-        val->tag = ((uint64_t)lens[i] << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = vals[i];
-        if (yyjson_unlikely(!val->uni.str)) return NULL;
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strcpy(
-    yyjson_mut_doc *doc, const char **vals, size_t count) {
-    size_t len;
-    const char *str;
-    yyjson_mut_arr_with_func({
-        str = vals[i];
-        if (!str) return NULL;
-        len = strlen(str);
-        val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len);
-        if (yyjson_unlikely(!val->uni.str)) return NULL;
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strncpy(
-    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
-    size_t len;
-    const char *str;
-    if (yyjson_unlikely(count > 0 && !lens)) return NULL;
-    yyjson_mut_arr_with_func({
-        str = vals[i];
-        len = lens[i];
-        val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len);
-        if (yyjson_unlikely(!val->uni.str)) return NULL;
-    });
-}
-
-#undef yyjson_mut_arr_with_func
-
-
-
-/*==============================================================================
- * Mutable JSON Array Modification API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_mut_arr_insert(yyjson_mut_val *arr,
-                                             yyjson_mut_val *val, size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(idx <= len)) {
-            unsafe_yyjson_set_len(arr, len + 1);
-            if (len == 0) {
-                val->next = val;
-                arr->uni.ptr = val;
-            } else {
-                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-                yyjson_mut_val *next = prev->next;
-                if (idx == len) {
-                    prev->next = val;
-                    val->next = next;
-                    arr->uni.ptr = val;
-                } else {
-                    while (idx-- > 0) {
-                        prev = next;
-                        next = next->next;
-                    }
-                    prev->next = val;
-                    val->next = next;
-                }
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val *arr,
-                                             yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        unsafe_yyjson_set_len(arr, len + 1);
-        if (len == 0) {
-            val->next = val;
-        } else {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            yyjson_mut_val *next = prev->next;
-            prev->next = val;
-            val->next = next;
-        }
-        arr->uni.ptr = val;
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val *arr,
-                                              yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        unsafe_yyjson_set_len(arr, len + 1);
-        if (len == 0) {
-            val->next = val;
-            arr->uni.ptr = val;
-        } else {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            yyjson_mut_val *next = prev->next;
-            prev->next = val;
-            val->next = next;
-        }
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_replace(yyjson_mut_val *arr,
-                                                         size_t idx,
-                                                         yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(idx < len)) {
-            if (yyjson_likely(len > 1)) {
-                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-                yyjson_mut_val *next = prev->next;
-                while (idx-- > 0) {
-                    prev = next;
-                    next = next->next;
-                }
-                prev->next = val;
-                val->next = next->next;
-                if ((void *)next == arr->uni.ptr) arr->uni.ptr = val;
-                return next;
-            } else {
-                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-                val->next = val;
-                arr->uni.ptr = val;
-                return prev;
-            }
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove(yyjson_mut_val *arr,
-                                                        size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(idx < len)) {
-            unsafe_yyjson_set_len(arr, len - 1);
-            if (yyjson_likely(len > 1)) {
-                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-                yyjson_mut_val *next = prev->next;
-                while (idx-- > 0) {
-                    prev = next;
-                    next = next->next;
-                }
-                prev->next = next->next;
-                if ((void *)next == arr->uni.ptr) arr->uni.ptr = prev;
-                return next;
-            } else {
-                return ((yyjson_mut_val *)arr->uni.ptr);
-            }
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_first(
-    yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (len > 1) {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            yyjson_mut_val *next = prev->next;
-            prev->next = next->next;
-            unsafe_yyjson_set_len(arr, len - 1);
-            return next;
-        } else if (len == 1) {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            unsafe_yyjson_set_len(arr, 0);
-            return prev;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_last(
-    yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(len > 1)) {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            yyjson_mut_val *next = prev->next;
-            unsafe_yyjson_set_len(arr, len - 1);
-            while (--len > 0) prev = prev->next;
-            prev->next = next;
-            next = (yyjson_mut_val *)arr->uni.ptr;
-            arr->uni.ptr = prev;
-            return next;
-        } else if (len == 1) {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            unsafe_yyjson_set_len(arr, 0);
-            return prev;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_remove_range(yyjson_mut_val *arr,
-                                                   size_t _idx, size_t _len) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *prev, *next;
-        bool tail_removed;
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_unlikely(_idx + _len > len)) return false;
-        if (yyjson_unlikely(_len == 0)) return true;
-        unsafe_yyjson_set_len(arr, len - _len);
-        if (yyjson_unlikely(len == _len)) return true;
-        tail_removed = (_idx + _len == len);
-        prev = ((yyjson_mut_val *)arr->uni.ptr);
-        while (_idx-- > 0) prev = prev->next;
-        next = prev->next;
-        while (_len-- > 0) next = next->next;
-        prev->next = next;
-        if (yyjson_unlikely(tail_removed)) arr->uni.ptr = prev;
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_clear(yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        unsafe_yyjson_set_len(arr, 0);
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_rotate(yyjson_mut_val *arr,
-                                             size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) &&
-                      unsafe_yyjson_get_len(arr) > idx)) {
-        yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr;
-        while (idx-- > 0) val = val->next;
-        arr->uni.ptr = (void *)val;
-        return true;
-    }
-    return false;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Array Modification Convenience API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val *arr,
-                                              yyjson_mut_val *val) {
-    return yyjson_mut_arr_append(arr, val);
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_null(doc);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_true(doc);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc *doc,
-                                                yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_false(doc);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_bool(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               bool _val) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_bool(doc, _val);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_uint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               uint64_t num) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_uint(doc, num);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_sint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               int64_t num) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_sint(doc, num);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_int(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *arr,
-                                              int64_t num) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_sint(doc, num);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_real(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               double num) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_real(doc, num);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_str(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *arr,
-                                              const char *str) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_str(doc, str);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_strn(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               const char *str, size_t len) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_strn(doc, str, len);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_strcpy(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *arr,
-                                                 const char *str) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_strcpy(doc, str);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_strncpy(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *arr,
-                                                  const char *str, size_t len) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_strncpy(doc, str, len);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_arr(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_arr(doc);
-        return yyjson_mut_arr_append(arr, val) ? val : NULL;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_obj(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_obj(doc);
-        return yyjson_mut_arr_append(arr, val) ? val : NULL;
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline size_t yyjson_mut_obj_size(yyjson_mut_val *obj) {
-    return yyjson_mut_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_get(yyjson_mut_val *obj,
-                                                     const char *key) {
-    return yyjson_mut_obj_getn(obj, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_getn(yyjson_mut_val *obj,
-                                                      const char *_key,
-                                                      size_t key_len) {
-    uint64_t tag = (((uint64_t)key_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-    size_t len = yyjson_mut_obj_size(obj);
-    if (yyjson_likely(len && _key)) {
-        yyjson_mut_val *key = ((yyjson_mut_val *)obj->uni.ptr)->next->next;
-        while (len-- > 0) {
-            if (key->tag == tag &&
-                memcmp(key->uni.ptr, _key, key_len) == 0) {
-                return key->next;
-            }
-            key = key->next->next;
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object Iterator API (Implementation)
- *============================================================================*/
-
-struct yyjson_mut_obj_iter {
-    size_t idx; /**< current key index, from 0 */
-    size_t max; /**< maximum key index, idx < max */
-    yyjson_mut_val *cur; /**< current key */
-    yyjson_mut_val *pre; /**< previous key */
-    yyjson_mut_val *obj; /**< the object being iterated */
-};
-
-yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val *obj,
-                                                yyjson_mut_obj_iter *iter) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && iter)) {
-        iter->idx = 0;
-        iter->max = unsafe_yyjson_get_len(obj);
-        iter->cur = iter->max ? (yyjson_mut_val *)obj->uni.ptr : NULL;
-        iter->pre = NULL;
-        iter->obj = obj;
-        return true;
-    }
-    if (iter) memset(iter, 0, sizeof(yyjson_mut_obj_iter));
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_iter_has_next(yyjson_mut_obj_iter *iter) {
-    return iter ? iter->idx < iter->max : false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_next(
-    yyjson_mut_obj_iter *iter) {
-    if (iter && iter->idx < iter->max) {
-        yyjson_mut_val *key = iter->cur;
-        iter->pre = key;
-        iter->cur = key->next->next;
-        iter->idx++;
-        return iter->cur;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get_val(
-    yyjson_mut_val *key) {
-    return key ? key->next : NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_remove(
-    yyjson_mut_obj_iter *iter) {
-    if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
-        yyjson_mut_val *prev = iter->pre;
-        yyjson_mut_val *cur = iter->cur;
-        yyjson_mut_val *next = cur->next->next;
-        if (yyjson_unlikely(iter->idx == iter->max)) iter->obj->uni.ptr = prev;
-        iter->idx--;
-        iter->max--;
-        unsafe_yyjson_set_len(iter->obj, iter->max);
-        prev->next->next = next;
-        iter->cur = next;
-        return cur;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get(
-    yyjson_mut_obj_iter *iter, const char *key) {
-    return yyjson_mut_obj_iter_getn(iter, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_getn(
-    yyjson_mut_obj_iter *iter, const char *key, size_t key_len) {
-    if (iter && key) {
-        size_t idx = 0;
-        size_t max = iter->max;
-        yyjson_mut_val *pre, *cur = iter->cur;
-        while (idx++ < max) {
-            pre = cur;
-            cur = cur->next->next;
-            if (unsafe_yyjson_get_len(cur) == key_len &&
-                memcmp(cur->uni.str, key, key_len) == 0) {
-                iter->idx += idx;
-                if (iter->idx > max) iter->idx -= max + 1;
-                iter->pre = pre;
-                iter->cur = cur;
-                return cur->next;
-            }
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object Creation API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_str(yyjson_mut_doc *doc,
-                                                          const char **keys,
-                                                          const char **vals,
-                                                          size_t count) {
-    if (yyjson_likely(doc && ((count > 0 && keys && vals) || (count == 0)))) {
-        yyjson_mut_val *obj = unsafe_yyjson_mut_val(doc, 1 + count * 2);
-        if (yyjson_likely(obj)) {
-            obj->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_OBJ;
-            if (count > 0) {
-                size_t i;
-                for (i = 0; i < count; i++) {
-                    yyjson_mut_val *key = obj + (i * 2 + 1);
-                    yyjson_mut_val *val = obj + (i * 2 + 2);
-                    uint64_t key_len = (uint64_t)strlen(keys[i]);
-                    uint64_t val_len = (uint64_t)strlen(vals[i]);
-                    key->tag = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-                    val->tag = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-                    key->uni.str = keys[i];
-                    val->uni.str = vals[i];
-                    key->next = val;
-                    val->next = val + 1;
-                }
-                obj[count * 2].next = obj + 1;
-                obj->uni.ptr = obj + (count * 2 - 1);
-            }
-            return obj;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_kv(yyjson_mut_doc *doc,
-                                                         const char **pairs,
-                                                         size_t count) {
-    if (yyjson_likely(doc && ((count > 0 && pairs) || (count == 0)))) {
-        yyjson_mut_val *obj = unsafe_yyjson_mut_val(doc, 1 + count * 2);
-        if (yyjson_likely(obj)) {
-            obj->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_OBJ;
-            if (count > 0) {
-                size_t i;
-                for (i = 0; i < count; i++) {
-                    yyjson_mut_val *key = obj + (i * 2 + 1);
-                    yyjson_mut_val *val = obj + (i * 2 + 2);
-                    const char *key_str = pairs[i * 2 + 0];
-                    const char *val_str = pairs[i * 2 + 1];
-                    uint64_t key_len = (uint64_t)strlen(key_str);
-                    uint64_t val_len = (uint64_t)strlen(val_str);
-                    key->tag = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-                    val->tag = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-                    key->uni.str = key_str;
-                    val->uni.str = val_str;
-                    key->next = val;
-                    val->next = val + 1;
-                }
-                obj[count * 2].next = obj + 1;
-                obj->uni.ptr = obj + (count * 2 - 1);
-            }
-            return obj;
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object Modification API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline void unsafe_yyjson_mut_obj_add(yyjson_mut_val *obj,
-                                                 yyjson_mut_val *key,
-                                                 yyjson_mut_val *val,
-                                                 size_t len) {
-    if (yyjson_likely(len)) {
-        yyjson_mut_val *prev_val = ((yyjson_mut_val *)obj->uni.ptr)->next;
-        yyjson_mut_val *next_key = prev_val->next;
-        prev_val->next = key;
-        val->next = next_key;
-    } else {
-        val->next = key;
-    }
-    key->next = val;
-    obj->uni.ptr = (void *)key;
-    unsafe_yyjson_set_len(obj, len + 1);
-}
-
-yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_obj_remove(
-    yyjson_mut_val *obj, const char *key, size_t key_len, uint64_t key_tag) {
-    size_t obj_len = unsafe_yyjson_get_len(obj);
-    if (obj_len) {
-        yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr;
-        yyjson_mut_val *cur_key = pre_key->next->next;
-        yyjson_mut_val *removed_item = NULL;
-        size_t i;
-        for (i = 0; i < obj_len; i++) {
-            if (key_tag == cur_key->tag &&
-                memcmp(key, cur_key->uni.ptr, key_len) == 0) {
-                if (!removed_item) removed_item = cur_key->next;
-                cur_key = cur_key->next->next;
-                pre_key->next->next = cur_key;
-                if (i + 1 == obj_len) obj->uni.ptr = pre_key;
-                i--;
-                obj_len--;
-            } else {
-                pre_key = cur_key;
-                cur_key = cur_key->next->next;
-            }
-        }
-        unsafe_yyjson_set_len(obj, obj_len);
-        return removed_item;
-    } else {
-        return NULL;
-    }
-}
-
-yyjson_api_inline bool unsafe_yyjson_mut_obj_replace(yyjson_mut_val *obj,
-                                                     yyjson_mut_val *key,
-                                                     yyjson_mut_val *val) {
-    size_t key_len = unsafe_yyjson_get_len(key);
-    size_t obj_len = unsafe_yyjson_get_len(obj);
-    if (obj_len) {
-        yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr;
-        yyjson_mut_val *cur_key = pre_key->next->next;
-        size_t i;
-        for (i = 0; i < obj_len; i++) {
-            if (key->tag == cur_key->tag &&
-                memcmp(key->uni.str, cur_key->uni.ptr, key_len) == 0) {
-                cur_key->next->tag = val->tag;
-                cur_key->next->uni.u64 = val->uni.u64;
-                return true;
-            } else {
-                cur_key = cur_key->next->next;
-            }
-        }
-    }
-    return false;
-}
-
-yyjson_api_inline void unsafe_yyjson_mut_obj_rotate(yyjson_mut_val *obj,
-                                                    size_t idx) {
-    yyjson_mut_val *key = (yyjson_mut_val *)obj->uni.ptr;
-    while (idx-- > 0) key = key->next->next;
-    obj->uni.ptr = (void *)key;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add(yyjson_mut_val *obj,
-                                          yyjson_mut_val *key,
-                                          yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
-                      yyjson_mut_is_str(key) && val)) {
-        unsafe_yyjson_mut_obj_add(obj, key, val, unsafe_yyjson_get_len(obj));
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_put(yyjson_mut_val *obj,
-                                          yyjson_mut_val *key,
-                                          yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
-                      yyjson_mut_is_str(key))) {
-        unsafe_yyjson_mut_obj_remove(obj, key->uni.str,
-                                     unsafe_yyjson_get_len(key), key->tag);
-        if (yyjson_likely(val)) {
-            unsafe_yyjson_mut_obj_add(obj, key, val,
-                                      unsafe_yyjson_get_len(obj));
-        }
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_insert(yyjson_mut_val *obj,
-                                             yyjson_mut_val *key,
-                                             yyjson_mut_val *val,
-                                             size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
-                      yyjson_mut_is_str(key) && val)) {
-        size_t len = unsafe_yyjson_get_len(obj);
-        if (yyjson_likely(len >= idx)) {
-            if (len > idx) {
-                void *ptr = obj->uni.ptr;
-                unsafe_yyjson_mut_obj_rotate(obj, idx);
-                unsafe_yyjson_mut_obj_add(obj, key, val, len);
-                obj->uni.ptr = ptr;
-            } else {
-                unsafe_yyjson_mut_obj_add(obj, key, val, len);
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove(yyjson_mut_val *obj,
-    yyjson_mut_val *key) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key))) {
-        return unsafe_yyjson_mut_obj_remove(obj, key->uni.str,
-                                            unsafe_yyjson_get_len(key),
-                                            key->tag);
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_key(
-    yyjson_mut_val *obj, const char *key) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) {
-        size_t key_len = strlen(key);
-        uint64_t tag = ((uint64_t)key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        return unsafe_yyjson_mut_obj_remove(obj, key, key_len, tag);
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_keyn(
-    yyjson_mut_val *obj, const char *key, size_t key_len) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) {
-        uint64_t tag = ((uint64_t)key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        return unsafe_yyjson_mut_obj_remove(obj, key, key_len, tag);
-    }
-    return NULL;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_clear(yyjson_mut_val *obj) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj))) {
-        unsafe_yyjson_set_len(obj, 0);
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_replace(yyjson_mut_val *obj,
-                                              yyjson_mut_val *key,
-                                              yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
-                      yyjson_mut_is_str(key) && val)) {
-        return unsafe_yyjson_mut_obj_replace(obj, key, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_rotate(yyjson_mut_val *obj,
-                                             size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
-                      unsafe_yyjson_get_len(obj) > idx)) {
-        unsafe_yyjson_mut_obj_rotate(obj, idx);
-        return true;
-    }
-    return false;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object Modification Convenience API (Implementation)
- *============================================================================*/
-
-#define yyjson_mut_obj_add_func(func) \
-    if (yyjson_likely(doc && yyjson_mut_is_obj(obj) && _key)) { \
-        yyjson_mut_val *key = unsafe_yyjson_mut_val(doc, 2); \
-        if (yyjson_likely(key)) { \
-            size_t len = unsafe_yyjson_get_len(obj); \
-            yyjson_mut_val *val = key + 1; \
-            key->tag = YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE; \
-            key->tag |= (uint64_t)strlen(_key) << YYJSON_TAG_BIT; \
-            key->uni.str = _key; \
-            func \
-            unsafe_yyjson_mut_obj_add(obj, key, val, len); \
-            return true; \
-        } \
-    } \
-    return false
-
-yyjson_api_inline bool yyjson_mut_obj_add_null(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_true(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_false(yyjson_mut_doc *doc,
-                                                yyjson_mut_val *obj,
-                                                const char *_key) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               bool _val) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)(_val) << 3);
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_uint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               uint64_t _val) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_sint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               int64_t _val) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_int(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *_key,
-                                              int64_t _val) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_real(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               double _val) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-        val->uni.f64 = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_str(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *_key,
-                                              const char *_val) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        val->tag = ((uint64_t)strlen(_val) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_strn(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               const char *_val,
-                                               size_t _len) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *obj,
-                                                 const char *_key,
-                                                 const char *_val) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        size_t _len = strlen(_val);
-        val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len);
-        if (yyjson_unlikely(!val->uni.str)) return false;
-        val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *obj,
-                                                  const char *_key,
-                                                  const char *_val,
-                                                  size_t _len) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len);
-        if (yyjson_unlikely(!val->uni.str)) return false;
-        val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_val(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *_key,
-                                              yyjson_mut_val *_val) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        val = _val;
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_str(yyjson_mut_val *obj,
-                                                            const char *key) {
-    return yyjson_mut_obj_remove_strn(obj, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_strn(
-    yyjson_mut_val *obj, const char *_key, size_t _len) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && _key)) {
-        yyjson_mut_val *key;
-        yyjson_mut_obj_iter iter;
-        yyjson_mut_val *val_removed = NULL;
-        yyjson_mut_obj_iter_init(obj, &iter);
-        while ((key = yyjson_mut_obj_iter_next(&iter)) != NULL) {
-            if (unsafe_yyjson_get_len(key) == _len &&
-                memcmp(key->uni.str, _key, _len) == 0) {
-                if (!val_removed) val_removed = key->next;
-                yyjson_mut_obj_iter_remove(&iter);
-            }
-        }
-        return val_removed;
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * JSON Pointer API (Implementation)
- *============================================================================*/
-
-/* `val` not null, `ptr` start with '/', `len` > 0. */
-yyjson_api yyjson_val *unsafe_yyjson_get_pointer(yyjson_val *val,
-                                                 const char *ptr,
-                                                 size_t len);
-
-/* `val` not null, `ptr` start with '/', `len` > 0. */
-yyjson_api yyjson_mut_val *unsafe_yyjson_mut_get_pointer(yyjson_mut_val *val,
-                                                         const char *ptr,
-                                                         size_t len);
-
-yyjson_api_inline yyjson_val *yyjson_get_pointern(yyjson_val *val,
-                                                  const char *ptr,
-                                                  size_t len) {
-    if (!val || !ptr) return NULL;
-    if (len == 0) return val;
-    if (*ptr != '/') return NULL;
-    return unsafe_yyjson_get_pointer(val, ptr, len);
-}
-
-yyjson_api_inline yyjson_val *yyjson_get_pointer(yyjson_val *val,
-                                                 const char *ptr) {
-    if (!val || !ptr) return NULL;
-    return yyjson_get_pointern(val, ptr, strlen(ptr));
-}
-
-yyjson_api_inline yyjson_val *yyjson_doc_get_pointern(yyjson_doc *doc,
-                                                      const char *ptr,
-                                                      size_t len) {
-    return yyjson_get_pointern(doc ? doc->root : NULL, ptr, len);
-}
-
-yyjson_api_inline yyjson_val *yyjson_doc_get_pointer(yyjson_doc *doc,
-                                                     const char *ptr) {
-    return yyjson_get_pointer(doc ? doc->root : NULL, ptr);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointern(yyjson_mut_val *val,
-                                                          const char *ptr,
-                                                          size_t len) {
-    if (!val || !ptr) return NULL;
-    if (len == 0) return val;
-    if (*ptr != '/') return NULL;
-    return unsafe_yyjson_mut_get_pointer(val, ptr, len);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointer(yyjson_mut_val *val,
-                                                         const char *ptr) {
-    if (!val || !ptr) return NULL;
-    return yyjson_mut_get_pointern(val, ptr, strlen(ptr));
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointern(
-    yyjson_mut_doc *doc, const char *ptr, size_t len) {
-    return yyjson_mut_get_pointern(doc ? doc->root : NULL, ptr, len);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointer(
-    yyjson_mut_doc *doc, const char *ptr) {
-    return yyjson_mut_get_pointer(doc ? doc->root : NULL, ptr);
-}
-
-
-
-/*==============================================================================
- * Compiler Hint End
- *============================================================================*/
-
-#if defined(__clang__)
-#   pragma clang diagnostic pop
-#elif defined(__GNUC__)
-#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#   pragma GCC diagnostic pop
-#   endif
-#elif defined(_MSC_VER)
-#   pragma warning(pop)
-#endif /* warning suppress end */
-
-#ifdef __cplusplus
-}
-#endif /* extern "C" end */
-
-#endif /* YYJSON_H */
diff --git a/thirdparty/zhmtools/Embind.h b/thirdparty/zhmtools/Embind.h
deleted file mode 100644
index b8fb0aa..0000000
--- a/thirdparty/zhmtools/Embind.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#pragma once
-
-#if __EMSCRIPTEN__
-
-#include <emscripten/bind.h>
-
-#include <vector>
-#include <string>
-
-using namespace emscripten;
-
-#define ZHM_MODULE_NAME_FOR_TARGET(TARGET) HM ## _ ## TARGET
-#define ZHM_MODULE_NAME ZHM_MODULE_NAME_FOR_TARGET(ZHM_TARGET)
-
-std::vector<std::string> GetSupportedResourceTypes()
-{
-	auto* s_Resources = ZHM_TARGET_FUNC(GetSupportedResourceTypes)();
-
-	std::vector<std::string> s_TypesVector;
-
-	for (size_t i = 0; i < s_Resources->TypeCount; ++i)
-		s_TypesVector.push_back(s_Resources->Types[i]);
-
-	ZHM_TARGET_FUNC(FreeSupportedResourceTypes)(s_Resources);
-
-	return s_TypesVector;
-}
-
-bool IsResourceTypeSupported(const std::string& p_ResourceType)
-{
-	return ZHM_TARGET_FUNC(IsResourceTypeSupported)(p_ResourceType.c_str());
-}
-
-val ConvertResourceToJson(const std::string& p_ResourceType, const std::string& p_ResourceData)
-{
-	auto* s_Converter = ZHM_TARGET_FUNC(GetConverterForResource)(p_ResourceType.c_str());
-
-	if (s_Converter == nullptr)
-		return val::null();
-
-	auto* s_Result = s_Converter->FromMemoryToJsonString(p_ResourceData.data(), p_ResourceData.size());
-
-	if (s_Result == nullptr)
-		return val::null();
-
-	std::string s_JsonData(s_Result->JsonData, s_Result->StrSize);
-
-	s_Converter->FreeJsonString(s_Result);
-
-	return val(s_JsonData);
-}
-
-val GenerateResourceFromJson(const std::string& p_ResourceType, const std::string& p_ResourceData)
-{
-	auto* s_Generator = ZHM_TARGET_FUNC(GetGeneratorForResource)(p_ResourceType.c_str());
-
-	if (s_Generator == nullptr)
-		return val::null();
-
-	auto* s_Result = s_Generator->FromJsonStringToResourceMem(p_ResourceData.data(), p_ResourceData.size(), false);
-
-	if (s_Result == nullptr)
-		return val::null();
-
-	emscripten::val s_View(emscripten::typed_memory_view(s_Result->DataSize, reinterpret_cast<const uint8_t*>(s_Result->ResourceData)));
-
-	auto s_JSResult = emscripten::val::global("Uint8Array").new_(s_Result->DataSize);
-	s_JSResult.call<void>("set", s_View);
-
-	s_Generator->FreeResourceMem(s_Result);
-
-	return s_JSResult;
-}
-
-EMSCRIPTEN_BINDINGS(ZHM_MODULE_NAME)
-{
-	register_vector<std::string>("vector<string>");
-	
-	function("GetSupportedResourceTypes", &GetSupportedResourceTypes);
-	function("IsResourceTypeSupported", &IsResourceTypeSupported);
-	function("ConvertResourceToJson", &ConvertResourceToJson);
-	function("GenerateResourceFromJson", &GenerateResourceFromJson);
-}
-
-#endif
\ No newline at end of file
diff --git a/thirdparty/zhmtools/LICENSE b/thirdparty/zhmtools/LICENSE
deleted file mode 100644
index 153d416..0000000
--- a/thirdparty/zhmtools/LICENSE
+++ /dev/null
@@ -1,165 +0,0 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  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 that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU 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 as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
\ No newline at end of file
diff --git a/thirdparty/zhmtools/ResourceConverter.h b/thirdparty/zhmtools/ResourceConverter.h
deleted file mode 100644
index d2725e8..0000000
--- a/thirdparty/zhmtools/ResourceConverter.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-	struct JsonString;
-	
-	struct ResourceConverter
-	{
-		/**
-		 * Convert a binary resource found at [p_ResourceFilePath] to its json representation and
-		 * store it in the [p_OutputFilePath] file on the filesystem.
-		 *
-		 * Returns [true] on success, or [false] otherwise.
-		 */
-		bool (*FromResourceFileToJsonFile)(const char* p_ResourceFilePath, const char* p_OutputFilePath);
-
-		/**
-		 * Convert a resource from an in-memory buffer to its json representation and store it in
-		 * the [p_OutputFilePath] file on the filesystem. The [p_ResourceData] parameter must
-		 * point to the binary data of the resource and the [p_Size] parameter must be the size of
-		 * the resource in bytes.
-		 *
-		 * Returns [true] on success, or [false] otherwise.
-		 */
-		bool (*FromMemoryToJsonFile)(const void* p_ResourceData, size_t p_Size, const char* p_OutputFilePath);
-
-		/**
-		 * Convert a binary resource found at [p_ResourceFilePath] to its json representation and
-		 * store it in memory as a [JsonString]. After using it, the [JsonString] must be cleaned up
-		 * by passing it to the [FreeJsonString] function.
-
-		 * If the operation fails, this function will return [nullptr].
-		 */
-		JsonString* (*FromResourceFileToJsonString)(const char* p_ResourceFilePath);
-
-		/**
-		 * Convert a resource from an in-memory buffer to its json representation and store it in
-		 * memory as a [JsonString]. The [p_ResourceData] parameter must point to the binary data
-		 * of the resource and the [p_Size] parameter must be the size of the resource in bytes.
-		 * After using it, the [JsonString] must be cleaned up by passing it to the
-		 * [FreeJsonString] function.
-		 *
-		 * If the operation fails, this function will return [nullptr].
-		 */
-		JsonString* (*FromMemoryToJsonString)(const void* p_ResourceData, size_t p_Size);
-
-		/**
-		 * Clean up an in-memory json string. The [JsonString] becomes invalid after a call to
-		 * this function, and attempting to use it results in undefined behavior.
-		 */
-		void (*FreeJsonString)(JsonString* p_JsonString);
-	};
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/thirdparty/zhmtools/ResourceGenerator.h b/thirdparty/zhmtools/ResourceGenerator.h
deleted file mode 100644
index a456c7a..0000000
--- a/thirdparty/zhmtools/ResourceGenerator.h
+++ /dev/null
@@ -1,79 +0,0 @@
-#pragma once
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-	struct ResourceMem;
-	
-	struct ResourceGenerator
-	{
-		/**
-		 * Generate a new binary resource from the json file found at [p_JsonFilePath] and store it
-		 * in the [p_ResourceFilePath] file on the filesystem.
-		 *
-		 * The [p_GenerateCompatible] parameter specifies whether the generated resource should try to
-		 * maintain compatibility with the quirks of the original BIN1 format. Doesn't matter when
-		 * producing files for use in the game, but certain third party tools might behave better with them.
-		 * Generating "compatible" resources can take significantly longer.
-		 *
-		 * Returns [true] on success, or [false] otherwise.
-		 */
-		bool (*FromJsonFileToResourceFile)(const char* p_JsonFilePath, const char* p_ResourceFilePath, bool p_GenerateCompatible);
-
-		/**
-		 * Generate a new binary resource from the specified json string and store it in the
-		 * [p_ResourceFilePath] file on the filesystem. The [p_JsonStr] must point to the json
-		 * string data and the [p_JsonStrLength] must be the length of the data, excluding any
-		 * null terminators.
-		 *
-		 * The [p_GenerateCompatible] parameter specifies whether the generated resource should try to
-		 * maintain compatibility with the quirks of the original BIN1 format. Doesn't matter when
-		 * producing files for use in the game, but certain third party tools might behave better with them.
-		 * Generating "compatible" resources can take significantly longer.
-		 *
-		 * Returns [true] on success, or [false] otherwise.
-		 */
-		bool (*FromJsonStringToResourceFile)(const char* p_JsonStr, size_t p_JsonStrLength, const char* p_ResourceFilePath, bool p_GenerateCompatible);
-
-		/**
-		 * Generate a new binary resource from the json file found at [p_JsonFilePath] and store it
-		 * in memory as a [ResourceMem]. After using it, the [ResourceMem] must be cleaned up
-		 * by passing it to the [FreeResourceMem] function.
-		 *
-		 * The [p_GenerateCompatible] parameter specifies whether the generated resource should try to
-		 * maintain compatibility with the quirks of the original BIN1 format. Doesn't matter when
-		 * producing files for use in the game, but certain third party tools might behave better with them.
-		 * Generating "compatible" resources can take significantly longer.
-		 *
-		 * If the operation fails, this function will return [nullptr].
-		 */
-		ResourceMem* (*FromJsonFileToResourceMem)(const char* p_JsonFilePath, bool p_GenerateCompatible);
-
-		/**
-		 * Generate a new binary resource from the specified json string and store it in memory as
-		 * a [ResourceMem]. The [p_JsonStr] must point to the json string data and the
-		 * [p_JsonStrLength] must be the length of the data, excluding any null terminators. After
-		 * using it, the [ResourceMem] must be cleaned up by passing it to the [FreeResourceMem]
-		 * function.
-		 *
-		 * The [p_GenerateCompatible] parameter specifies whether the generated resource should try to
-		 * maintain compatibility with the quirks of the original BIN1 format. Doesn't matter when
-		 * producing files for use in the game, but certain third party tools might behave better with them.
-		 * Generating "compatible" resources can take significantly longer.
-		 *
-		 * If the operation fails, this function will return [nullptr].
-		 */
-		ResourceMem* (*FromJsonStringToResourceMem)(const char* p_JsonStr, size_t p_JsonStrLength, bool p_GenerateCompatible);
-
-		/**
-		 * Clean up an in-memory binary resource. The [ResourceMem] becomes invalid after a call
-		 * to this function, and attempting to use it results in undefined behavior.
-		 */
-		void (*FreeResourceMem)(ResourceMem* p_ResourceMem);
-	};
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/thirdparty/zhmtools/ResourceLib.h b/thirdparty/zhmtools/ResourceLib.h
deleted file mode 100644
index 7905f46..0000000
--- a/thirdparty/zhmtools/ResourceLib.h
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "ResourceConverter.h"
-#include "ResourceGenerator.h"
-#include "ResourceLibCommon.h"
-
-#if __EMSCRIPTEN__
-#include <emscripten.h>
-#else
-#define EMSCRIPTEN_KEEPALIVE
-#endif
-
-#if defined(_MSC_VER)
-#	define RESOURCELIB_EXPORT __declspec(dllexport)
-#	define RESOURCELIB_IMPORT __declspec(dllimport)
-#else
-#	define RESOURCELIB_EXPORT __attribute__((visibility("default")))
-#	define RESOURCELIB_IMPORT
-#endif
-
-#if RESOURCELIB_EXPORTS
-#	define RESOURCELIB_API RESOURCELIB_EXPORT
-#else
-#	define RESOURCELIB_API RESOURCELIB_IMPORT
-#endif
-
-#define ZHM_TARGET_FUNC_FINAL(X, Y) HM ## X ## _ ## Y
-#define ZHM_TARGET_FUNC_EVAL(X, Y) ZHM_TARGET_FUNC_FINAL(X, Y)
-#define ZHM_TARGET_FUNC(FunctionName) ZHM_TARGET_FUNC_EVAL(ZHM_TARGET, FunctionName)
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-	/**
-	 * Get a binary -> json converter for the given resource type (eg. TEMP).
-	 * If a converter for this resource type doesn't exist, this function will return [nullptr].
-	 */
-	EMSCRIPTEN_KEEPALIVE RESOURCELIB_API ResourceConverter* ZHM_TARGET_FUNC(GetConverterForResource)(const char* p_ResourceType);
-
-	/**
-	 * Get a json -> binary generator for the given resource type (eg. TEMP).
-	 * If a generator for this resource type doesn't exist, this function will return [nullptr].
-	 */
-	EMSCRIPTEN_KEEPALIVE RESOURCELIB_API ResourceGenerator* ZHM_TARGET_FUNC(GetGeneratorForResource)(const char* p_ResourceType);
-
-	/**
-	 * Get a list of resource types that this library supports converting between json and binary forms.
-	 * After using the result of this function it must be cleaned up by passing it to the
-	 * [HMX_FreeSupportedResourceTypes] function.
-	 */
-	EMSCRIPTEN_KEEPALIVE RESOURCELIB_API ResourceTypesArray* ZHM_TARGET_FUNC(GetSupportedResourceTypes)();
-
-	/**
-	 * Clean up the supported resource types array. The [ResourceTypesArray] becomes invalid after a
-	 * call to this function, and attempting to use it results in undefined behavior.
-	 */
-	EMSCRIPTEN_KEEPALIVE RESOURCELIB_API void ZHM_TARGET_FUNC(FreeSupportedResourceTypes)(ResourceTypesArray* p_Array);
-
-	/**
-	 * Checks if this library supports converting between the json and binary forms of the specified resource types
-	 * and returns [true] if it does, or [false] otherwise.
-	 */
-	EMSCRIPTEN_KEEPALIVE RESOURCELIB_API bool ZHM_TARGET_FUNC(IsResourceTypeSupported)(const char* p_ResourceType);
-
-#ifdef __cplusplus
-}
-#endif
-
-#include "Embind.h"
\ No newline at end of file
diff --git a/thirdparty/zhmtools/ResourceLibCommon.h b/thirdparty/zhmtools/ResourceLibCommon.h
deleted file mode 100644
index 9efd8c5..0000000
--- a/thirdparty/zhmtools/ResourceLibCommon.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-	struct JsonString
-	{
-		/**
-		 * The json string data. Is always null terminated.
-		 */
-		const char* JsonData;
-
-		/**
-		 * The length of the json string data. Does not include the null terminator.
-		 */
-		size_t StrSize;
-	};
-
-	struct ResourceMem
-	{
-		const void* ResourceData;
-		size_t DataSize;
-	};
-	
-	struct ResourceTypesArray
-	{
-		const char** Types;
-		size_t TypeCount;
-	};
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/thirdparty/zhmtools/ResourceLib_HM2.dll b/thirdparty/zhmtools/ResourceLib_HM2.dll
deleted file mode 100644
index 5493b5b..0000000
Binary files a/thirdparty/zhmtools/ResourceLib_HM2.dll and /dev/null differ
diff --git a/thirdparty/zhmtools/ResourceLib_HM2.h b/thirdparty/zhmtools/ResourceLib_HM2.h
deleted file mode 100644
index e13f460..0000000
--- a/thirdparty/zhmtools/ResourceLib_HM2.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-
-#undef ZHM_TARGET
-#define ZHM_TARGET 2
-
-#include "ResourceLib.h"
\ No newline at end of file
diff --git a/thirdparty/zhmtools/ResourceLib_HM2.lib b/thirdparty/zhmtools/ResourceLib_HM2.lib
deleted file mode 100644
index 942f94f..0000000
Binary files a/thirdparty/zhmtools/ResourceLib_HM2.lib and /dev/null differ
diff --git a/thirdparty/zhmtools/ResourceLib_HM2016.dll b/thirdparty/zhmtools/ResourceLib_HM2016.dll
deleted file mode 100644
index 39c5155..0000000
Binary files a/thirdparty/zhmtools/ResourceLib_HM2016.dll and /dev/null differ
diff --git a/thirdparty/zhmtools/ResourceLib_HM2016.h b/thirdparty/zhmtools/ResourceLib_HM2016.h
deleted file mode 100644
index 492dd60..0000000
--- a/thirdparty/zhmtools/ResourceLib_HM2016.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-
-#undef ZHM_TARGET
-#define ZHM_TARGET 2016
-
-#include "ResourceLib.h"
\ No newline at end of file
diff --git a/thirdparty/zhmtools/ResourceLib_HM2016.lib b/thirdparty/zhmtools/ResourceLib_HM2016.lib
deleted file mode 100644
index 2ffbb8f..0000000
Binary files a/thirdparty/zhmtools/ResourceLib_HM2016.lib and /dev/null differ
diff --git a/thirdparty/zhmtools/ResourceLib_HM3.dll b/thirdparty/zhmtools/ResourceLib_HM3.dll
deleted file mode 100644
index 32a6b66..0000000
Binary files a/thirdparty/zhmtools/ResourceLib_HM3.dll and /dev/null differ
diff --git a/thirdparty/zhmtools/ResourceLib_HM3.h b/thirdparty/zhmtools/ResourceLib_HM3.h
deleted file mode 100644
index a585831..0000000
--- a/thirdparty/zhmtools/ResourceLib_HM3.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-
-#undef ZHM_TARGET
-#define ZHM_TARGET 3
-
-#include "ResourceLib.h"
\ No newline at end of file
diff --git a/thirdparty/zhmtools/ResourceLib_HM3.lib b/thirdparty/zhmtools/ResourceLib_HM3.lib
deleted file mode 100644
index e2ae15c..0000000
Binary files a/thirdparty/zhmtools/ResourceLib_HM3.lib and /dev/null differ